commit 3ec262dd51466100b44910b60308e46b00f2a097
Author: Quentin Machu <me@quentin-machu.fr>
Date:   Fri Nov 13 14:11:28 2015 -0500

    Initial commit

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 00000000..090b49c0
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,7 @@
+.*
+*.md
+DCO
+LICENSE
+NOTICE
+docs
+cloudconfig
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100755
index 00000000..86449310
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,71 @@
+# How to Contribute
+
+CoreOS projects are [Apache 2.0 licensed](LICENSE) and accept contributions via
+GitHub pull requests. This document outlines some of the conventions on
+development workflow, commit message formatting, contact points and other
+resources to make it easier to get your contribution accepted.
+
+# Certificate of Origin
+
+By contributing to this project you agree to the Developer Certificate of
+Origin (DCO). This document was created by the Linux Kernel community and is a
+simple statement that you, as a contributor, have the legal right to make the
+contribution. See the [DCO](DCO) file for details.
+
+# Email and Chat
+
+The project currently uses the general CoreOS email list and IRC channel:
+- Email: [coreos-dev](https://groups.google.com/forum/#!forum/coreos-dev)
+- IRC: #[coreos](irc://irc.freenode.org:6667/#coreos) IRC channel on freenode.org
+
+Please avoid emailing maintainers found in the MAINTAINERS file directly. They
+are very busy and read the mailing lists.
+
+## Getting Started
+
+- Fork the repository on GitHub
+- Read the [README](README.md) for build and test instructions
+- Play with the project, submit bugs, submit patches!
+
+## Contribution Flow
+
+This is a rough outline of what a contributor's workflow looks like:
+
+- Create a topic branch from where you want to base your work (usually master).
+- Make commits of logical units.
+- Make sure your commit messages are in the proper format (see below).
+- Push your changes to a topic branch in your fork of the repository.
+- Make sure the tests pass, and add any new tests as appropriate.
+- Submit a pull request to the original repository.
+
+Thanks for your contributions!
+
+### Format of the Commit Message
+
+We follow a rough convention for commit messages that is designed to answer two
+questions: what changed and why. The subject line should feature the what and
+the body of the commit should describe the why.
+
+```
+scripts: add the test-cluster command
+
+this uses tmux to setup a test cluster that you can easily kill and
+start for debugging.
+
+Fixes #38
+```
+
+The format can be described more formally as follows:
+
+```
+<subsystem>: <what changed>
+<BLANK LINE>
+<why this change was made>
+<BLANK LINE>
+<footer>
+```
+
+The first line is the subject and should be no longer than 70 characters, the
+second line is always blank, and other lines should be wrapped at 80 characters.
+This allows the message to be easier to read on GitHub as well as in various
+git tools.
diff --git a/DCO b/DCO
new file mode 100755
index 00000000..716561d5
--- /dev/null
+++ b/DCO
@@ -0,0 +1,36 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..ab5c5057
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,18 @@
+FROM golang:1.5
+MAINTAINER Quentin Machu <quentin.machu@coreos.com>
+
+RUN apt-get update && apt-get install -y bzr rpm && apt-get autoremove -y && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+RUN mkdir         /db
+VOLUME            /db
+
+EXPOSE 6060 6061
+
+ADD .         /go/src/github.com/coreos/clair/
+WORKDIR       /go/src/github.com/coreos/clair/
+
+ENV GO15VENDOREXPERIMENT 1
+RUN go install -v
+RUN go test $(go list ./... | grep -v /vendor/) # https://github.com/golang/go/issues/11659
+
+ENTRYPOINT ["clair"]
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
new file mode 100644
index 00000000..6b72a9cb
--- /dev/null
+++ b/Godeps/Godeps.json
@@ -0,0 +1,94 @@
+{
+	"ImportPath": "github.com/coreos/clair",
+	"GoVersion": "go1.5.1",
+	"Packages": [
+		"./..."
+	],
+	"Deps": [
+		{
+			"ImportPath": "github.com/alecthomas/template",
+			"Rev": "b867cc6ab45cece8143cfcc6fc9c77cf3f2c23c0"
+		},
+		{
+			"ImportPath": "github.com/alecthomas/units",
+			"Rev": "6b4e7dc5e3143b85ea77909c72caf89416fc2915"
+		},
+		{
+			"ImportPath": "github.com/barakmich/glog",
+			"Rev": "fafcb6128a8a2e6360ff034091434d547397d54a"
+		},
+		{
+			"ImportPath": "github.com/boltdb/bolt",
+			"Comment": "v1.0-98-gafceb31",
+			"Rev": "afceb316b96ea97cbac6d23afbdf69543d80748a"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-systemd/journal",
+			"Comment": "v3-15-gcfa48f3",
+			"Rev": "cfa48f34d8dc4ff58f9b48725181a09f9092dc3c"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/capnslog",
+			"Rev": "42a8c3b1a6f917bb8346ef738f32712a7ca0ede7"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/timeutil",
+			"Rev": "42a8c3b1a6f917bb8346ef738f32712a7ca0ede7"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/proto",
+			"Rev": "58bbd41c1a2d1b7154f5d99a8d0d839b3093301a"
+		},
+		{
+			"ImportPath": "github.com/google/cayley",
+			"Comment": "v0.4.1-160-gcdf0154",
+			"Rev": "cdf0154d1a34019651eb4f46ce666b31f4d8cae7"
+		},
+		{
+			"ImportPath": "github.com/julienschmidt/httprouter",
+			"Comment": "v1.1",
+			"Rev": "8c199fb6259ffc1af525cc3ad52ee60ba8359669"
+		},
+		{
+			"ImportPath": "github.com/lib/pq",
+			"Comment": "go1.0-cutoff-56-gdc50b6a",
+			"Rev": "dc50b6ad2d3ee836442cf3389009c7cd1e64bb43"
+		},
+		{
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+		},
+		{
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Comment": "v1.0-17-g089c718",
+			"Rev": "089c7181b8c728499929ff09b62d3fdd8df8adff"
+		},
+		{
+			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
+			"Rev": "315fcfb05d4d46d4354b313d146ef688dda272a9"
+		},
+		{
+			"ImportPath": "github.com/syndtr/gosnappy/snappy",
+			"Rev": "156a073208e131d7d2e212cb749feae7c339e846"
+		},
+		{
+			"ImportPath": "github.com/tylerb/graceful",
+			"Comment": "v1.2.3",
+			"Rev": "48afeb21e2fcbcff0f30bd5ad6b97747b0fae38e"
+		},
+		{
+			"ImportPath": "golang.org/x/net/netutil",
+			"Rev": "7654728e381988afd88e58cabfd6363a5ea91810"
+		},
+		{
+			"ImportPath": "gopkg.in/alecthomas/kingpin.v2",
+			"Comment": "v2.0.10",
+			"Rev": "e1f37920c1d0ced4d1c92f9526a2a433183f02e9"
+		},
+		{
+			"ImportPath": "gopkg.in/mgo.v2",
+			"Comment": "r2015.05.29",
+			"Rev": "01ee097136da162d1dd3c9b44fbdf3abf4fd6552"
+		}
+	]
+}
diff --git a/Godeps/Readme b/Godeps/Readme
new file mode 100644
index 00000000..4cdaa53d
--- /dev/null
+++ b/Godeps/Readme
@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.
diff --git a/LICENSE b/LICENSE
new file mode 100755
index 00000000..e06d2081
--- /dev/null
+++ b/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.
+
diff --git a/NOTICE b/NOTICE
new file mode 100755
index 00000000..e520005c
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,5 @@
+CoreOS Project
+Copyright 2015 CoreOS, Inc
+
+This product includes software developed at CoreOS, Inc.
+(http://www.coreos.com/).
diff --git a/README.md b/README.md
new file mode 100644
index 00000000..ae326146
--- /dev/null
+++ b/README.md
@@ -0,0 +1,81 @@
+Clair
+=====
+
+Clair is a container vulnerability analysis service. It provides the list of vulnerabilities that threaten each container and can sends notifications whenever new vulnerabilities that affect existing containers are released.
+
+We named the project « Clair », which means in French *clear*, *bright*, *transparent* because we believe that it enables users to have a clear insight into the security of their container infrastructure.
+
+## Why should I use Clair?
+
+Clair is a single-binary server that exposes an JSON, HTTP API. It does not require any agent to sit on your containers neither does it need any specific container tweak to be done. It has been designed to perform massive analysis on the [Quay.io Container Registry](https://quay.io).
+
+Whether you host a container registry, a continuous-integration system, or build dozens to thousands containers, you would benefit from Clair. More generally, if you consider that container security matters (and, honestly, you should), you should give it a shot.
+
+## How Clair Detects Vulnerabilities
+
+Clair has been designed to analyze a container layer only once, without running the container. The analysis has to extract all required data to detect the known vulnerabilities which may affect a layer but also any future vulnerabilities.
+
+Detecting vulnerabilities can be achieved by several techniques. One possiblity is to compute hashes of binaries. These are presented on a layer and then compared with a database. However, building this database may become tricky considering the number of different packages and library versions.
+
+To detect vulnerabilities Clair decided to take advantage of package managers, which quickly and comprehensively provide lists of installed binary and source packages. Package lists are extracted for each layer that composes of your container image, the difference between the layer’s package list, and its parent one is stored. Not only is this method storage-efficient, but it also enables us to scan a layer that may be used in many images only once. Coupled with vulnerability databases such as the Debian’s Security Bug Tracker, Clair is able to tell which vulnerabilities threaten a container, and which layer and package introduced them.
+
+### Graph
+
+Clair internally uses a graph, which has its model described in the [associated doc](docs/Model.md) to store and query data. Below is a non-exhaustive example graph that correspond to the following *Dockerfile*.
+
+```
+1.  MAINTAINER Quentin Machu <quentin.machu@coreos.com>
+2.  FROM ubuntu:trusty
+3.  RUN apt−get update && apt−get upgrade −y
+4.  EXPOSE 22
+5.  CMD ["/usr/sbin/sshd", "-D"]
+```
+
+![Example graph](docs/Model.png)
+
+The above image shows five layers represented by the purple nodes, associated with their ids and parents. Because the second layer imports *Ubuntu Trusty* in the container, Clair can detect the operating system and some packages, in green (we only show one here for the sake of simplicity). The third layer upgrades packages, so the graph reflects that this layer removes the previous version and installs the new one. Finally, the graph knows about a vulnerability, drawn in red, which is fixed by a particular package. Note that two synthetic package versions exist (0 and ∞): they ensure database consistency during parallel modification. ∞ also allows us to define very easily that a vulnerability is not yet fixed; thus, it affects every package version.
+
+Querying this particular graph will tell us that our image is not vulnerable at all because none of the successor versions of its only package fix any vulnerability. However, an image based on the second layer could be vulnerable.
+
+### Architecture
+
+Clair is divided into X main modules (which represent Go packages):
+
+- **api** defines how users interact with Clair and exposes a [documented HTTP API](docs/API.md).
+- **worker** extracts useful informations from layers and store everything in the database.
+- **updater** periodically updates Clair's vulnerability database from known vulnerability sources.
+- **notifier** dispatches [notifications](docs/Notifications.md) about vulnerable containers when vulnerabilities are released or updated.
+- **database** persists layers informations and vulnerabilities in [Cayley graph database](https://github.com/google/cayley).
+- **health** summarizes health checks of every Clair's services.
+
+Multiple backend databases are supported, a testing deployment would use an in-memory storage while a production deployment should use [Bolt](https://github.com/boltdb/bolt) (single-instance deployment) or PostgreSQL (distributed deployment, probably behind a load-balancer). To learn more about how to run Clair, take a look at the [doc](docs/Run.md).
+
+#### Detectors & Fetchers
+
+Clair currently supports three operating systems and their package managers, which we believe are the most common ones: *Debian* (dpkg), *Ubuntu* (dpkg), *CentOS* (yum).
+
+Supporting an operating system implies that we are able to extract the operating system's name and version from a layer and the list of package it has. This is done inside the *worker/detectors* package and extending that is straightforward.
+
+All of this is useless if no vulnerability is known for any of these packages. The *updater/fetchers* package defines trusted sources of vulnerabilities, how to fetch them and parse them. For now, Clair uses three databases, one for each supported operating system:
+- [Ubuntu CVE Tracker](https://launchpad.net/ubuntu-cve-tracker)
+- [Debian Security Bug Tracker](https://security-tracker.debian.org/tracker/)
+- [Red Hat Security Data](https://www.redhat.com/security/data/metrics/)
+
+Using these distro-specific sources gives us confidence that Clair can take into consideration *all* the different package implementations and backports without ever reporting anything possibly inaccurate.
+
+# Coming Soon
+
+- Improved performances.
+- Extended detection system
+  - More package managers
+  - Generic features such as detecting presence/absence of files
+  - ...
+- Expose more informations about vulnerability
+  - Access vector
+  - Acess complexity
+  - ...
+
+# Related links
+
+- Talk @ ContainerDays NYC 2015 [[Slides]](https://docs.google.com/presentation/d/1toUKgqLyy1b-pZlDgxONLduiLmt2yaLR0GliBB7b3L0/pub?start=false&loop=false&slide=id.p) [[Video]](https://www.youtube.com/watch?v=PA3oBAgjnkU)
+- [Quay](https://quay.io): First container registry using Clair.
diff --git a/api/api.go b/api/api.go
new file mode 100644
index 00000000..deb18d67
--- /dev/null
+++ b/api/api.go
@@ -0,0 +1,126 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package api provides a RESTful HTTP API, enabling external apps to interact
+// with clair.
+package api
+
+import (
+	"io/ioutil"
+	"net"
+	"net/http"
+	"strconv"
+	"time"
+
+	"crypto/tls"
+	"crypto/x509"
+
+	"github.com/coreos/pkg/capnslog"
+	"github.com/coreos/clair/utils"
+	"github.com/tylerb/graceful"
+)
+
+var log = capnslog.NewPackageLogger("github.com/coreos/clair", "api")
+
+// Config represents the configuration for the Main API.
+type Config struct {
+	Port                      int
+	TimeOut                   time.Duration
+	CertFile, KeyFile, CAFile string
+}
+
+// RunMain launches the main API, which exposes every possible interactions
+// with clair.
+func RunMain(conf *Config, st *utils.Stopper) {
+	log.Infof("starting API on port %d.", conf.Port)
+	defer func() {
+		log.Info("API stopped")
+		st.End()
+	}()
+
+	srv := &graceful.Server{
+		Timeout:          0,    // Already handled by our TimeOut middleware
+		NoSignalHandling: true, // We want to use our own Stopper
+		Server: &http.Server{
+			Addr:      ":" + strconv.Itoa(conf.Port),
+			TLSConfig: setupClientCert(conf.CAFile),
+			Handler:   NewVersionRouter(conf.TimeOut),
+		},
+	}
+	listenAndServeWithStopper(srv, st, conf.CertFile, conf.KeyFile)
+}
+
+// RunHealth launches the Health API, which only exposes a method to fetch
+// clair's health without any security or authentification mechanism.
+func RunHealth(port int, st *utils.Stopper) {
+	log.Infof("starting Health API on port %d.", port)
+	defer func() {
+		log.Info("Health API stopped")
+		st.End()
+	}()
+
+	srv := &graceful.Server{
+		Timeout:          10 * time.Second, // Interrupt health checks when stopping
+		NoSignalHandling: true,             // We want to use our own Stopper
+		Server: &http.Server{
+			Addr:    ":" + strconv.Itoa(port),
+			Handler: NewHealthRouter(),
+		},
+	}
+	listenAndServeWithStopper(srv, st, "", "")
+}
+
+// listenAndServeWithStopper wraps graceful.Server's
+// ListenAndServe/ListenAndServeTLS and adds the ability to interrupt them with
+// the provided utils.Stopper
+func listenAndServeWithStopper(srv *graceful.Server, st *utils.Stopper, certFile, keyFile string) {
+	go func() {
+		<-st.Chan()
+		srv.Stop(0)
+	}()
+
+	var err error
+	if certFile != "" && keyFile != "" {
+		log.Info("API: TLS Enabled")
+		err = srv.ListenAndServeTLS(certFile, keyFile)
+	} else {
+		err = srv.ListenAndServe()
+	}
+
+	if opErr, ok := err.(*net.OpError); !ok || (ok && opErr.Op != "accept") {
+		log.Fatal(err)
+	}
+}
+
+// setupClientCert creates a tls.Config instance using a CA file path
+// (if provided) and and calls log.Fatal if it does not exist.
+func setupClientCert(caFile string) *tls.Config {
+	if len(caFile) > 0 {
+		log.Info("API: Client Certificate Authentification Enabled")
+		caCert, err := ioutil.ReadFile(caFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		caCertPool := x509.NewCertPool()
+		caCertPool.AppendCertsFromPEM(caCert)
+		return &tls.Config{
+			ClientCAs:  caCertPool,
+			ClientAuth: tls.RequireAndVerifyClientCert,
+		}
+	}
+
+	return &tls.Config{
+		ClientAuth: tls.NoClientCert,
+	}
+}
diff --git a/api/jsonhttp/json.go b/api/jsonhttp/json.go
new file mode 100644
index 00000000..b0e39d3f
--- /dev/null
+++ b/api/jsonhttp/json.go
@@ -0,0 +1,78 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package jsonhttp provides helper functions to write JSON responses to
+// http.ResponseWriter and read JSON bodies from http.Request.
+package jsonhttp
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/worker"
+)
+
+// MaxPostSize is the maximum number of bytes that ParseBody reads from an
+// http.Request.Body.
+var MaxPostSize int64 = 1048576
+
+// Render writes a JSON-encoded object to a http.ResponseWriter, as well as
+// a HTTP status code.
+func Render(w http.ResponseWriter, httpStatus int, v interface{}) {
+	w.WriteHeader(httpStatus)
+	if v != nil {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		result, _ := json.Marshal(v)
+		w.Write(result)
+	}
+}
+
+// RenderError writes an error, wrapped in the Message field of a JSON-encoded
+// object to a http.ResponseWriter, as well as a HTTP status code.
+// If the status code is 0, RenderError tries to guess the proper HTTP status
+// code from the error type.
+func RenderError(w http.ResponseWriter, httpStatus int, err error) {
+	if httpStatus == 0 {
+		httpStatus = http.StatusInternalServerError
+		// Try to guess the http status code from the error type
+		if _, isBadRequestError := err.(*cerrors.ErrBadRequest); isBadRequestError {
+			httpStatus = http.StatusBadRequest
+		} else {
+			switch err {
+			case cerrors.ErrNotFound:
+				httpStatus = http.StatusNotFound
+			case database.ErrTransaction, database.ErrBackendException:
+				httpStatus = http.StatusServiceUnavailable
+			case worker.ErrParentUnknown, worker.ErrUnsupported:
+				httpStatus = http.StatusBadRequest
+			}
+		}
+	}
+
+	Render(w, httpStatus, struct{ Message string }{Message: err.Error()})
+}
+
+// ParseBody reads a JSON-encoded body from a http.Request and unmarshals it
+// into the provided object.
+func ParseBody(r *http.Request, v interface{}) (int, error) {
+	defer r.Body.Close()
+	err := json.NewDecoder(io.LimitReader(r.Body, MaxPostSize)).Decode(v)
+	if err != nil {
+		return http.StatusUnsupportedMediaType, err
+	}
+	return 0, nil
+}
diff --git a/api/logic/general.go b/api/logic/general.go
new file mode 100644
index 00000000..3a040c92
--- /dev/null
+++ b/api/logic/general.go
@@ -0,0 +1,54 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package logic implements all the available API methods.
+// Every methods are documented in docs/API.md.
+package logic
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/coreos/clair/api/jsonhttp"
+	"github.com/coreos/clair/health"
+	"github.com/coreos/clair/worker"
+	"github.com/julienschmidt/httprouter"
+)
+
+// Version is an integer representing the API version.
+const Version = 1
+
+// GETVersions returns API and Engine versions.
+func GETVersions(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+	jsonhttp.Render(w, http.StatusOK, struct {
+		APIVersion    string
+		EngineVersion string
+	}{
+		APIVersion:    strconv.Itoa(Version),
+		EngineVersion: strconv.Itoa(worker.Version),
+	})
+}
+
+// GETHealth sums up the health of all the registered services.
+func GETHealth(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+	globalHealth, statuses := health.Healthcheck()
+
+	httpStatus := http.StatusOK
+	if !globalHealth {
+		httpStatus = http.StatusServiceUnavailable
+	}
+
+	jsonhttp.Render(w, httpStatus, statuses)
+	return
+}
diff --git a/api/logic/layers.go b/api/logic/layers.go
new file mode 100644
index 00000000..64d53977
--- /dev/null
+++ b/api/logic/layers.go
@@ -0,0 +1,365 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logic
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/coreos/clair/api/jsonhttp"
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils/types"
+	"github.com/coreos/clair/worker"
+	"github.com/julienschmidt/httprouter"
+)
+
+// POSTLayersParameters represents the expected parameters for POSTLayers.
+type POSTLayersParameters struct {
+	ID, Path, ParentID string
+}
+
+// POSTLayers analyzes a layer and returns the engine version that has been used
+// for the analysis.
+func POSTLayers(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+	var parameters POSTLayersParameters
+	if s, err := jsonhttp.ParseBody(r, &parameters); err != nil {
+		jsonhttp.RenderError(w, s, err)
+		return
+	}
+
+	// Process data.
+	if err := worker.Process(parameters.ID, parameters.ParentID, parameters.Path); err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Get engine version and return.
+	jsonhttp.Render(w, http.StatusCreated, struct{ Version string }{Version: strconv.Itoa(worker.Version)})
+}
+
+// GETLayersOS returns the operating system of a layer if it exists.
+// It uses not only the specified layer but also its parent layers if necessary.
+// An empty OS string is returned if no OS has been detected.
+func GETLayersOS(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Find layer.
+	layer, err := database.FindOneLayerByID(p.ByName("id"), []string{database.FieldLayerParent, database.FieldLayerOS})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Get OS.
+	os, err := layer.OperatingSystem()
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	jsonhttp.Render(w, http.StatusOK, struct{ OS string }{OS: os})
+}
+
+// GETLayersParent returns the parent ID of a layer if it exists.
+// An empty ID string is returned if the layer has no parent.
+func GETLayersParent(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Find layer
+	layer, err := database.FindOneLayerByID(p.ByName("id"), []string{database.FieldLayerParent})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Get layer's parent.
+	parent, err := layer.Parent([]string{database.FieldLayerID})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	ID := ""
+	if parent != nil {
+		ID = parent.ID
+	}
+	jsonhttp.Render(w, http.StatusOK, struct{ ID string }{ID: ID})
+}
+
+// GETLayersPackages returns the complete list of packages that a layer has
+// if it exists.
+func GETLayersPackages(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Find layer
+	layer, err := database.FindOneLayerByID(p.ByName("id"), []string{database.FieldLayerParent, database.FieldLayerPackages})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Find layer's packages.
+	packagesNodes, err := layer.AllPackages()
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	packages := []*database.Package{}
+	if len(packagesNodes) > 0 {
+		packages, err = database.FindAllPackagesByNodes(packagesNodes, []string{database.FieldPackageOS, database.FieldPackageName, database.FieldPackageVersion})
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+	}
+
+	jsonhttp.Render(w, http.StatusOK, struct{ Packages []*database.Package }{Packages: packages})
+}
+
+// GETLayersPackagesDiff returns the list of packages that a layer installs and
+// removes if it exists.
+func GETLayersPackagesDiff(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Find layer.
+	layer, err := database.FindOneLayerByID(p.ByName("id"), []string{database.FieldLayerPackages})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Find layer's packages.
+	installedPackages, removedPackages := make([]*database.Package, 0), make([]*database.Package, 0)
+	if len(layer.InstalledPackagesNodes) > 0 {
+		installedPackages, err = database.FindAllPackagesByNodes(layer.InstalledPackagesNodes, []string{database.FieldPackageOS, database.FieldPackageName, database.FieldPackageVersion})
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+	}
+	if len(layer.RemovedPackagesNodes) > 0 {
+		removedPackages, err = database.FindAllPackagesByNodes(layer.RemovedPackagesNodes, []string{database.FieldPackageOS, database.FieldPackageName, database.FieldPackageVersion})
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+	}
+
+	jsonhttp.Render(w, http.StatusOK, struct{ InstalledPackages, RemovedPackages []*database.Package }{InstalledPackages: installedPackages, RemovedPackages: removedPackages})
+}
+
+// GETLayersVulnerabilities returns the complete list of vulnerabilities that
+// a layer has if it exists.
+func GETLayersVulnerabilities(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Get minumum priority parameter.
+	minimumPriority := types.Priority(r.URL.Query().Get("minimumPriority"))
+	if minimumPriority == "" {
+		minimumPriority = "High" // Set default priority to High
+	} else if !minimumPriority.IsValid() {
+		jsonhttp.RenderError(w, 0, cerrors.NewBadRequestError("invalid priority"))
+		return
+	}
+
+	// Find layer
+	layer, err := database.FindOneLayerByID(p.ByName("id"), []string{database.FieldLayerParent, database.FieldLayerPackages})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Find layer's packages.
+	packagesNodes, err := layer.AllPackages()
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Find vulnerabilities.
+	vulnerabilities, err := getVulnerabilitiesFromLayerPackagesNodes(packagesNodes, minimumPriority, []string{database.FieldVulnerabilityID, database.FieldVulnerabilityLink, database.FieldVulnerabilityPriority, database.FieldVulnerabilityDescription})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	jsonhttp.Render(w, http.StatusOK, struct{ Vulnerabilities []*database.Vulnerability }{Vulnerabilities: vulnerabilities})
+}
+
+// GETLayersVulnerabilitiesDiff returns the list of vulnerabilities that a layer
+// adds and removes if it exists.
+func GETLayersVulnerabilitiesDiff(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Get minumum priority parameter.
+	minimumPriority := types.Priority(r.URL.Query().Get("minimumPriority"))
+	if minimumPriority == "" {
+		minimumPriority = "High" // Set default priority to High
+	} else if !minimumPriority.IsValid() {
+		jsonhttp.RenderError(w, 0, cerrors.NewBadRequestError("invalid priority"))
+		return
+	}
+
+	// Find layer.
+	layer, err := database.FindOneLayerByID(p.ByName("id"), []string{database.FieldLayerPackages})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Selected fields for vulnerabilities.
+	selectedFields := []string{database.FieldVulnerabilityID, database.FieldVulnerabilityLink, database.FieldVulnerabilityPriority, database.FieldVulnerabilityDescription}
+
+	// Find vulnerabilities for installed packages.
+	addedVulnerabilities, err := getVulnerabilitiesFromLayerPackagesNodes(layer.InstalledPackagesNodes, minimumPriority, selectedFields)
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Find vulnerabilities for removed packages.
+	removedVulnerabilities, err := getVulnerabilitiesFromLayerPackagesNodes(layer.RemovedPackagesNodes, minimumPriority, selectedFields)
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Remove vulnerabilities which appears both in added and removed lists (eg. case of updated packages but still vulnerable).
+	for ia, a := range addedVulnerabilities {
+		for ir, r := range removedVulnerabilities {
+			if a.ID == r.ID {
+				addedVulnerabilities = append(addedVulnerabilities[:ia], addedVulnerabilities[ia+1:]...)
+				removedVulnerabilities = append(removedVulnerabilities[:ir], removedVulnerabilities[ir+1:]...)
+			}
+		}
+	}
+
+	jsonhttp.Render(w, http.StatusOK, struct{ Adds, Removes []*database.Vulnerability }{Adds: addedVulnerabilities, Removes: removedVulnerabilities})
+}
+
+// POSTBatchLayersVulnerabilitiesParameters represents the expected parameters
+// for POSTBatchLayersVulnerabilities.
+type POSTBatchLayersVulnerabilitiesParameters struct {
+	LayersIDs []string
+}
+
+// POSTBatchLayersVulnerabilities returns the complete list of vulnerabilities
+// that the provided layers have, if they all exist.
+func POSTBatchLayersVulnerabilities(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Parse body
+	var parameters POSTBatchLayersVulnerabilitiesParameters
+	if s, err := jsonhttp.ParseBody(r, &parameters); err != nil {
+		jsonhttp.RenderError(w, s, err)
+		return
+	}
+	if len(parameters.LayersIDs) == 0 {
+		jsonhttp.RenderError(w, http.StatusBadRequest, errors.New("at least one LayerID query parameter must be provided"))
+		return
+	}
+
+	// Get minumum priority parameter.
+	minimumPriority := types.Priority(r.URL.Query().Get("minimumPriority"))
+	if minimumPriority == "" {
+		minimumPriority = "High" // Set default priority to High
+	} else if !minimumPriority.IsValid() {
+		jsonhttp.RenderError(w, 0, cerrors.NewBadRequestError("invalid priority"))
+		return
+	}
+
+	response := make(map[string]interface{})
+	// For each LayerID parameter
+	for _, layerID := range parameters.LayersIDs {
+		// Find layer
+		layer, err := database.FindOneLayerByID(layerID, []string{database.FieldLayerParent, database.FieldLayerPackages})
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+
+		// Find layer's packages.
+		packagesNodes, err := layer.AllPackages()
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+
+		// Find vulnerabilities.
+		vulnerabilities, err := getVulnerabilitiesFromLayerPackagesNodes(packagesNodes, minimumPriority, []string{database.FieldVulnerabilityID, database.FieldVulnerabilityLink, database.FieldVulnerabilityPriority, database.FieldVulnerabilityDescription})
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+
+		response[layerID] = struct{ Vulnerabilities []*database.Vulnerability }{Vulnerabilities: vulnerabilities}
+	}
+
+	jsonhttp.Render(w, http.StatusOK, response)
+}
+
+// getSuccessorsFromPackagesNodes returns the node list of packages that have
+// versions following the versions of the provided packages.
+func getSuccessorsFromPackagesNodes(packagesNodes []string) ([]string, error) {
+	if len(packagesNodes) == 0 {
+		return []string{}, nil
+	}
+
+	// Get packages.
+	packages, err := database.FindAllPackagesByNodes(packagesNodes, []string{database.FieldPackageNextVersion})
+	if err != nil {
+		return []string{}, err
+	}
+
+	// Find all packages' successors.
+	var packagesNextVersions []string
+	for _, pkg := range packages {
+		nextVersions, err := pkg.NextVersions([]string{})
+		if err != nil {
+			return []string{}, err
+		}
+		for _, version := range nextVersions {
+			packagesNextVersions = append(packagesNextVersions, version.Node)
+		}
+	}
+
+	return packagesNextVersions, nil
+}
+
+// getVulnerabilitiesFromLayerPackagesNodes returns the list of vulnerabilities
+// affecting the provided package nodes, filtered by Priority.
+func getVulnerabilitiesFromLayerPackagesNodes(packagesNodes []string, minimumPriority types.Priority, selectedFields []string) ([]*database.Vulnerability, error) {
+	if len(packagesNodes) == 0 {
+		return []*database.Vulnerability{}, nil
+	}
+
+	// Get successors of the packages.
+	packagesNextVersions, err := getSuccessorsFromPackagesNodes(packagesNodes)
+	if err != nil {
+		return []*database.Vulnerability{}, err
+	}
+	if len(packagesNextVersions) == 0 {
+		return []*database.Vulnerability{}, nil
+	}
+
+	// Find vulnerabilities fixed in these successors.
+	vulnerabilities, err := database.FindAllVulnerabilitiesByFixedIn(packagesNextVersions, selectedFields)
+	if err != nil {
+		return []*database.Vulnerability{}, err
+	}
+
+	// Filter vulnerabilities depending on their priority and remove duplicates.
+	filteredVulnerabilities := []*database.Vulnerability{}
+	seen := map[string]struct{}{}
+	for _, v := range vulnerabilities {
+		if minimumPriority.Compare(v.Priority) <= 0 {
+			if _, alreadySeen := seen[v.ID]; !alreadySeen {
+				filteredVulnerabilities = append(filteredVulnerabilities, v)
+				seen[v.ID] = struct{}{}
+			}
+		}
+	}
+
+	return filteredVulnerabilities, nil
+}
diff --git a/api/logic/vulnerabilities.go b/api/logic/vulnerabilities.go
new file mode 100644
index 00000000..695c7359
--- /dev/null
+++ b/api/logic/vulnerabilities.go
@@ -0,0 +1,247 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logic
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/coreos/clair/api/jsonhttp"
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/julienschmidt/httprouter"
+)
+
+// GETVulnerabilities returns a vulnerability identified by an ID if it exists.
+func GETVulnerabilities(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Find vulnerability.
+	vulnerability, err := database.FindOneVulnerability(p.ByName("id"), []string{database.FieldVulnerabilityID, database.FieldVulnerabilityLink, database.FieldVulnerabilityPriority, database.FieldVulnerabilityDescription, database.FieldVulnerabilityFixedIn})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	abstractVulnerability, err := vulnerability.ToAbstractVulnerability()
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	jsonhttp.Render(w, http.StatusOK, abstractVulnerability)
+}
+
+// POSTVulnerabilities manually inserts a vulnerability into the database if it
+// does not exist yet.
+func POSTVulnerabilities(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	var parameters *database.AbstractVulnerability
+	if s, err := jsonhttp.ParseBody(r, &parameters); err != nil {
+		jsonhttp.RenderError(w, s, err)
+		return
+	}
+
+	// Ensure that the vulnerability does not exist.
+	vulnerability, err := database.FindOneVulnerability(parameters.ID, []string{})
+	if err != nil && err != cerrors.ErrNotFound {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+	if vulnerability != nil {
+		jsonhttp.RenderError(w, 0, cerrors.NewBadRequestError("vulnerability already exists"))
+		return
+	}
+
+	// Insert packages.
+	packages := database.AbstractPackagesToPackages(parameters.AffectedPackages)
+	err = database.InsertPackages(packages)
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+	var pkgNodes []string
+	for _, p := range packages {
+		pkgNodes = append(pkgNodes, p.Node)
+	}
+
+	// Insert vulnerability.
+	notifications, err := database.InsertVulnerabilities([]*database.Vulnerability{parameters.ToVulnerability(pkgNodes)})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Insert notifications.
+	err = database.InsertNotifications(notifications, database.GetDefaultNotificationWrapper())
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	jsonhttp.Render(w, http.StatusCreated, nil)
+}
+
+// PUTVulnerabilities updates a vulnerability if it exists.
+func PUTVulnerabilities(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	var parameters *database.AbstractVulnerability
+	if s, err := jsonhttp.ParseBody(r, &parameters); err != nil {
+		jsonhttp.RenderError(w, s, err)
+		return
+	}
+	parameters.ID = p.ByName("id")
+
+	// Ensure that the vulnerability exists.
+	_, err := database.FindOneVulnerability(parameters.ID, []string{})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Insert packages.
+	packages := database.AbstractPackagesToPackages(parameters.AffectedPackages)
+	err = database.InsertPackages(packages)
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+	var pkgNodes []string
+	for _, p := range packages {
+		pkgNodes = append(pkgNodes, p.Node)
+	}
+
+	// Insert vulnerability.
+	notifications, err := database.InsertVulnerabilities([]*database.Vulnerability{parameters.ToVulnerability(pkgNodes)})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Insert notifications.
+	err = database.InsertNotifications(notifications, database.GetDefaultNotificationWrapper())
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	jsonhttp.Render(w, http.StatusCreated, nil)
+}
+
+// DELVulnerabilities deletes a vulnerability if it exists.
+func DELVulnerabilities(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	err := database.DeleteVulnerability(p.ByName("id"))
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	jsonhttp.Render(w, http.StatusNoContent, nil)
+}
+
+// GETVulnerabilitiesIntroducingLayers returns the list of layers that
+// introduces a given vulnerability, if it exists.
+// To clarify, it does not return the list of every layers that have
+// the vulnerability.
+func GETVulnerabilitiesIntroducingLayers(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Find vulnerability to verify that it exists.
+	_, err := database.FindOneVulnerability(p.ByName("id"), []string{})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	layers, err := database.FindAllLayersIntroducingVulnerability(p.ByName("id"), []string{database.FieldLayerID})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	layersIDs := []string{}
+	for _, l := range layers {
+		layersIDs = append(layersIDs, l.ID)
+	}
+
+	jsonhttp.Render(w, http.StatusOK, struct{ IntroducingLayersIDs []string }{IntroducingLayersIDs: layersIDs})
+}
+
+// POSTVulnerabilitiesAffectedLayersParameters represents the expected
+// parameters for POSTVulnerabilitiesAffectedLayers.
+type POSTVulnerabilitiesAffectedLayersParameters struct {
+	LayersIDs []string
+}
+
+// POSTVulnerabilitiesAffectedLayers returns whether the specified layers
+// (by their IDs) are vulnerable to the given Vulnerability or not.
+func POSTVulnerabilitiesAffectedLayers(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+	// Parse body.
+	var parameters POSTBatchLayersVulnerabilitiesParameters
+	if s, err := jsonhttp.ParseBody(r, &parameters); err != nil {
+		jsonhttp.RenderError(w, s, err)
+		return
+	}
+	if len(parameters.LayersIDs) == 0 {
+		jsonhttp.RenderError(w, http.StatusBadRequest, errors.New("getting the entire list of affected layers is not supported yet: at least one LayerID query parameter must be provided"))
+		return
+	}
+
+	// Find vulnerability.
+	vulnerability, err := database.FindOneVulnerability(p.ByName("id"), []string{database.FieldVulnerabilityFixedIn})
+	if err != nil {
+		jsonhttp.RenderError(w, 0, err)
+		return
+	}
+
+	// Save the fixed in nodes into a map for fast check.
+	fixedInPackagesMap := make(map[string]struct{})
+	for _, fixedInNode := range vulnerability.FixedInNodes {
+		fixedInPackagesMap[fixedInNode] = struct{}{}
+	}
+
+	response := make(map[string]interface{})
+	// For each LayerID parameter.
+	for _, layerID := range parameters.LayersIDs {
+		// Find layer
+		layer, err := database.FindOneLayerByID(layerID, []string{database.FieldLayerParent, database.FieldLayerPackages, database.FieldLayerPackages})
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+
+		// Find layer's packages.
+		packagesNodes, err := layer.AllPackages()
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+
+		// Get successors packages of layer' packages.
+		successors, err := getSuccessorsFromPackagesNodes(packagesNodes)
+		if err != nil {
+			jsonhttp.RenderError(w, 0, err)
+			return
+		}
+
+		// Determine if the layer is vulnerable by verifying if one of the successors
+		// of its packages are fixed by the vulnerability.
+		vulnerable := false
+		for _, p := range successors {
+			if _, fixed := fixedInPackagesMap[p]; fixed {
+				vulnerable = true
+				break
+			}
+		}
+
+		response[layerID] = struct{ Vulnerable bool }{Vulnerable: vulnerable}
+	}
+
+	jsonhttp.Render(w, http.StatusOK, response)
+}
diff --git a/api/router.go b/api/router.go
new file mode 100644
index 00000000..2e07a2b8
--- /dev/null
+++ b/api/router.go
@@ -0,0 +1,96 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package api
+
+import (
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/coreos/clair/api/logic"
+	"github.com/coreos/clair/api/wrappers"
+	"github.com/julienschmidt/httprouter"
+)
+
+// VersionRouter is an HTTP router that forwards requests to the appropriate
+// router depending on the API version specified in the requested URI.
+type VersionRouter map[string]*httprouter.Router
+
+// NewVersionRouter instantiates a VersionRouter and every sub-routers that are
+// necessary to handle supported API versions.
+func NewVersionRouter(to time.Duration) *VersionRouter {
+	return &VersionRouter{
+		"/v1": NewRouterV1(to),
+	}
+}
+
+// ServeHTTP forwards requests to the appropriate router depending on the API
+// version specified in the requested URI and remove the version information
+// from the request URL.Path, without modifying the request uRequestURI.
+func (vs VersionRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	urlStr := r.URL.String()
+	var version string
+	if len(urlStr) >= 3 {
+		version = urlStr[:3]
+	}
+	if router, _ := vs[version]; router != nil {
+		// Remove the version number from the request path to let the router do its
+		// job but do not update the RequestURI
+		r.URL.Path = strings.Replace(r.URL.Path, version, "", 1)
+		router.ServeHTTP(w, r)
+		return
+	}
+	http.NotFound(w, r)
+}
+
+// NewRouterV1 creates a new router for the API (Version 1)
+func NewRouterV1(to time.Duration) *httprouter.Router {
+	router := httprouter.New()
+	wrap := func(fn httprouter.Handle) httprouter.Handle {
+		return wrappers.Log(wrappers.TimeOut(to, fn))
+	}
+
+	// General
+	router.GET("/versions", wrap(logic.GETVersions))
+	router.GET("/health", wrap(logic.GETHealth))
+
+	// Layers
+	router.POST("/layers", wrap(logic.POSTLayers))
+	router.GET("/layers/:id/os", wrap(logic.GETLayersOS))
+	router.GET("/layers/:id/parent", wrap(logic.GETLayersParent))
+	router.GET("/layers/:id/packages", wrap(logic.GETLayersPackages))
+	router.GET("/layers/:id/packages/diff", wrap(logic.GETLayersPackagesDiff))
+	router.GET("/layers/:id/vulnerabilities", wrap(logic.GETLayersVulnerabilities))
+	router.GET("/layers/:id/vulnerabilities/diff", wrap(logic.GETLayersVulnerabilitiesDiff))
+	// # Batch version of "/layers/:id/vulnerabilities"
+	router.POST("/batch/layers/vulnerabilities", wrap(logic.POSTBatchLayersVulnerabilities))
+
+	// Vulnerabilities
+	router.POST("/vulnerabilities", wrap(logic.POSTVulnerabilities))
+	router.PUT("/vulnerabilities/:id", wrap(logic.PUTVulnerabilities))
+	router.GET("/vulnerabilities/:id", wrap(logic.GETVulnerabilities))
+	router.DELETE("/vulnerabilities/:id", wrap(logic.DELVulnerabilities))
+	router.GET("/vulnerabilities/:id/introducing-layers", wrap(logic.GETVulnerabilitiesIntroducingLayers))
+	router.POST("/vulnerabilities/:id/affected-layers", wrap(logic.POSTVulnerabilitiesAffectedLayers))
+
+	return router
+}
+
+// NewHealthRouter creates a new router that only serve the Health function on /
+func NewHealthRouter() *httprouter.Router {
+	router := httprouter.New()
+	router.GET("/", logic.GETHealth)
+	return router
+}
diff --git a/api/wrappers/log.go b/api/wrappers/log.go
new file mode 100644
index 00000000..337f7b95
--- /dev/null
+++ b/api/wrappers/log.go
@@ -0,0 +1,75 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package logic implements all the available API methods.
+// Every methods are documented in docs/API.md.
+
+// Package wrappers contains httprouter.Handle wrappers that are used in the API.
+package wrappers
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/coreos/pkg/capnslog"
+	"github.com/julienschmidt/httprouter"
+)
+
+var log = capnslog.NewPackageLogger("github.com/coreos/clair", "api")
+
+type logWriter struct {
+	http.ResponseWriter
+	status int
+	size   int
+}
+
+func (lw *logWriter) Header() http.Header {
+	return lw.ResponseWriter.Header()
+}
+
+func (lw *logWriter) Write(b []byte) (int, error) {
+	if !lw.Written() {
+		lw.WriteHeader(http.StatusOK)
+	}
+	size, err := lw.ResponseWriter.Write(b)
+	lw.size += size
+	return size, err
+}
+
+func (lw *logWriter) WriteHeader(s int) {
+	lw.status = s
+	lw.ResponseWriter.WriteHeader(s)
+}
+
+func (lw *logWriter) Size() int {
+	return lw.size
+}
+
+func (lw *logWriter) Written() bool {
+	return lw.status != 0
+}
+
+func (lw *logWriter) Status() int {
+	return lw.status
+}
+
+// Log wraps a http.HandlerFunc and logs the API call
+func Log(fn httprouter.Handle) httprouter.Handle {
+	return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+		lw := &logWriter{ResponseWriter: w}
+		start := time.Now()
+		fn(lw, r, p)
+		log.Infof("%d %s %s (%s)", lw.Status(), r.Method, r.RequestURI, time.Since(start))
+	}
+}
diff --git a/api/wrappers/timeout.go b/api/wrappers/timeout.go
new file mode 100644
index 00000000..dac70de6
--- /dev/null
+++ b/api/wrappers/timeout.go
@@ -0,0 +1,105 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package logic implements all the available API methods.
+// Every methods are documented in docs/API.md.
+
+package wrappers
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/coreos/clair/api/jsonhttp"
+	"github.com/julienschmidt/httprouter"
+)
+
+// ErrHandlerTimeout is returned on ResponseWriter Write calls
+// in handlers which have timed out.
+var ErrHandlerTimeout = errors.New("http: Handler timeout")
+
+type timeoutWriter struct {
+	http.ResponseWriter
+
+	mu          sync.Mutex
+	timedOut    bool
+	wroteHeader bool
+}
+
+func (tw *timeoutWriter) Header() http.Header {
+	return tw.ResponseWriter.Header()
+}
+
+func (tw *timeoutWriter) Write(p []byte) (int, error) {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+	tw.wroteHeader = true // implicitly at least
+	if tw.timedOut {
+		return 0, ErrHandlerTimeout
+	}
+	return tw.ResponseWriter.Write(p)
+}
+
+func (tw *timeoutWriter) WriteHeader(status int) {
+	tw.mu.Lock()
+	defer tw.mu.Unlock()
+	if tw.timedOut || tw.wroteHeader {
+		return
+	}
+	tw.wroteHeader = true
+	tw.ResponseWriter.WriteHeader(status)
+}
+
+// TimeOut wraps a http.HandlerFunc and ensure that a response is given under
+// the specified duration.
+//
+// If the handler takes longer than the time limit, the wrapper responds with
+// a Service Unavailable error, an error message and the handler response which
+// may come later is ignored.
+//
+// After a timeout, any write the handler to its ResponseWriter will return
+// ErrHandlerTimeout.
+//
+// If the duration is 0, the wrapper does nothing.
+func TimeOut(d time.Duration, fn httprouter.Handle) httprouter.Handle {
+	if d == 0 {
+		fmt.Println("nope timeout")
+		return fn
+	}
+
+	return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+		done := make(chan bool)
+		tw := &timeoutWriter{ResponseWriter: w}
+
+		go func() {
+			fn(tw, r, p)
+			done <- true
+		}()
+
+		select {
+		case <-done:
+			return
+		case <-time.After(d):
+			tw.mu.Lock()
+			defer tw.mu.Unlock()
+			if !tw.wroteHeader {
+				jsonhttp.RenderError(tw.ResponseWriter, http.StatusServiceUnavailable, ErrHandlerTimeout)
+			}
+			tw.timedOut = true
+		}
+	}
+}
diff --git a/database/database.go b/database/database.go
new file mode 100644
index 00000000..75c3ac94
--- /dev/null
+++ b/database/database.go
@@ -0,0 +1,182 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package database implements every database models and the functions that
+// manipulate them.
+package database
+
+import (
+	"errors"
+	"os"
+
+	"github.com/barakmich/glog"
+	"github.com/coreos/pkg/capnslog"
+	"github.com/coreos/clair/health"
+	"github.com/coreos/clair/utils"
+	"github.com/google/cayley"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/path"
+
+	// Load all supported backends.
+	_ "github.com/google/cayley/graph/bolt"
+	_ "github.com/google/cayley/graph/leveldb"
+	_ "github.com/google/cayley/graph/memstore"
+	_ "github.com/google/cayley/graph/mongo"
+	_ "github.com/google/cayley/graph/sql"
+)
+
+const (
+	// FieldIs is the graph predicate defining the type of an entity.
+	FieldIs = "is"
+)
+
+var (
+	log = capnslog.NewPackageLogger("github.com/coreos/clair", "database")
+
+	// ErrTransaction is an error that occurs when a database transaction fails.
+	ErrTransaction = errors.New("database: transaction failed (concurrent modification?)")
+	// ErrBackendException is an error that occurs when the database backend does
+	// not work properly (ie. unreachable).
+	ErrBackendException = errors.New("database: could not query backend")
+	// ErrInconsistent is an error that occurs when a database consistency check
+	// fails (ie. when an entity which is supposed to be unique is detected twice)
+	ErrInconsistent = errors.New("database: inconsistent database")
+	// ErrCantOpen is an error that occurs when the database could not be opened
+	ErrCantOpen = errors.New("database: could not open database")
+
+	store *cayley.Handle
+)
+
+func init() {
+	health.RegisterHealthchecker("database", Healthcheck)
+}
+
+// Open opens a Cayley database, creating it if necessary and return its handle
+func Open(dbType, dbPath string) error {
+	if store != nil {
+		log.Errorf("could not open database at %s : a database is already opened", dbPath)
+		return ErrCantOpen
+	}
+
+	var err error
+
+	// Try to create database if necessary
+	if dbType == "bolt" || dbType == "leveldb" {
+		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+			// No, initialize it if possible
+			log.Infof("database at %s does not exist yet, creating it", dbPath)
+
+			if err = graph.InitQuadStore(dbType, dbPath, nil); err != nil {
+				log.Errorf("could not create database at %s : %s", dbPath, err)
+				return ErrCantOpen
+			}
+		}
+	} else if dbType == "sql" {
+		graph.InitQuadStore(dbType, dbPath, nil)
+	}
+
+	store, err = cayley.NewGraph(dbType, dbPath, nil)
+	if err != nil {
+		log.Errorf("could not open database at %s : %s", dbPath, err)
+		return ErrCantOpen
+	}
+
+	return nil
+}
+
+// Close closes a Cayley database
+func Close() {
+	if store != nil {
+		store.Close()
+		store = nil
+	}
+}
+
+// Healthcheck simply adds and then remove a quad in Cayley to ensure it is working
+// It returns true when everything is ok
+func Healthcheck() health.Status {
+	var err error
+	if store != nil {
+		t := cayley.NewTransaction()
+		q := cayley.Quad("cayley", "is", "healthy", "")
+		t.AddQuad(q)
+		t.RemoveQuad(q)
+		glog.SetStderrThreshold("FATAL") // TODO REMOVE ME
+		err = store.ApplyTransaction(t)
+		glog.SetStderrThreshold("ERROR") // TODO REMOVE ME
+	}
+
+	return health.Status{IsEssential: true, IsHealthy: err == nil, Details: nil}
+}
+
+// toValue returns a single value from a path
+// If the path does not lead to a value, an empty string is returned
+// If the path leads to multiple values or if a database error occurs, an empty string and an error are returned
+func toValue(p *path.Path) (string, error) {
+	var value string
+
+	it, _ := p.BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		if value != "" {
+			log.Error("failed query in toValue: used on an iterator containing multiple values")
+			return "", ErrInconsistent
+		}
+
+		if it.Result() != nil {
+			value = store.NameOf(it.Result())
+		}
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in toValue: %s", it.Err())
+		return "", ErrBackendException
+	}
+
+	return value, nil
+}
+
+// toValues returns multiple values from a path
+// If the path does not lead to any value, an empty array is returned
+// If a database error occurs, an empty array and an error are returned
+func toValues(p *path.Path) ([]string, error) {
+	var values []string
+
+	it, _ := p.BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		if it.Result() != nil {
+			value := store.NameOf(it.Result())
+			if value != "" {
+				values = append(values, value)
+			}
+		}
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in toValues: %s", it.Err())
+		return []string{}, ErrBackendException
+	}
+
+	return values, nil
+}
+
+// saveFields appends cayley's Save method to a path for each field in
+// selectedFields, except the ones that appears also in exceptFields
+func saveFields(p *path.Path, selectedFields []string, exceptFields []string) {
+	for _, selectedField := range selectedFields {
+		if utils.Contains(selectedField, exceptFields) {
+			continue
+		}
+		p = p.Save(selectedField, selectedField)
+	}
+}
diff --git a/database/database_test.go b/database/database_test.go
new file mode 100644
index 00000000..9bc07df5
--- /dev/null
+++ b/database/database_test.go
@@ -0,0 +1,81 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"testing"
+
+	"github.com/google/cayley"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHealthcheck(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	b := Healthcheck()
+	assert.True(t, b.IsHealthy, "Healthcheck failed")
+}
+
+func TestToValue(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	// toValue()
+	v, err := toValue(cayley.StartPath(store, "tests").Out("are"))
+	assert.Nil(t, err, "toValue should work even if the requested path leads to nothing")
+	assert.Equal(t, "", v, "toValue should return an empty string if the requested path leads to nothing")
+
+	store.AddQuad(cayley.Quad("tests", "are", "awesome", ""))
+	v, err = toValue(cayley.StartPath(store, "tests").Out("are"))
+	assert.Nil(t, err, "toValue should have worked")
+	assert.Equal(t, "awesome", v, "toValue did not return the expected value")
+
+	store.AddQuad(cayley.Quad("tests", "are", "running", ""))
+	v, err = toValue(cayley.StartPath(store, "tests").Out("are"))
+	assert.NotNil(t, err, "toValue should return an error and an empty string if the path leads to multiple values")
+	assert.Equal(t, "", v, "toValue should return an error and an empty string if the path leads to multiple values")
+
+	// toValues()
+	vs, err := toValues(cayley.StartPath(store, "CoreOS").Out(FieldIs))
+	assert.Nil(t, err, "toValues should work even if the requested path leads to nothing")
+	assert.Len(t, vs, 0, "toValue should return an empty array if the requested path leads to nothing")
+	words := []string{"powerful", "lightweight"}
+	for i, word := range words {
+		store.AddQuad(cayley.Quad("CoreOS", FieldIs, word, ""))
+		v, err := toValues(cayley.StartPath(store, "CoreOS").Out(FieldIs))
+		assert.Nil(t, err, "toValues should have worked")
+		assert.Len(t, v, i+1, "toValues did not return the right amount of values")
+		for _, e := range words[:i+1] {
+			assert.Contains(t, v, e, "toValues did not return the values we expected")
+		}
+	}
+
+	// toValue(s)() and empty values
+	store.AddQuad(cayley.Quad("bob", "likes", "", ""))
+	v, err = toValue(cayley.StartPath(store, "bob").Out("likes"))
+	assert.Nil(t, err, "toValue should work even if the requested path leads to nothing")
+	assert.Equal(t, "", v, "toValue should return an empty string if the requested path leads to nothing")
+
+	store.AddQuad(cayley.Quad("bob", "likes", "running", ""))
+	v, err = toValue(cayley.StartPath(store, "bob").Out("likes"))
+	assert.Nil(t, err, "toValue should have worked")
+	assert.Equal(t, "running", v, "toValue did not return the expected value")
+
+	store.AddQuad(cayley.Quad("bob", "likes", "swimming", ""))
+	va, err := toValues(cayley.StartPath(store, "bob").Out("likes"))
+	assert.Nil(t, err, "toValues should have worked")
+	assert.Len(t, va, 2, "toValues should have returned 2 values")
+}
diff --git a/database/flag.go b/database/flag.go
new file mode 100644
index 00000000..8a5cccac
--- /dev/null
+++ b/database/flag.go
@@ -0,0 +1,58 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/google/cayley"
+)
+
+// UpdateFlag creates a flag or update an existing flag's value
+func UpdateFlag(name, value string) error {
+	if name == "" || value == "" {
+		log.Warning("could not insert a flag which has an empty name or value")
+		return cerrors.NewBadRequestError("could not insert a flag which has an empty name or value")
+	}
+
+	// Initialize transaction
+	t := cayley.NewTransaction()
+
+	// Get current flag value
+	currentValue, err := GetFlagValue(name)
+	if err != nil {
+		return err
+	}
+
+	// Build transaction
+	name = "flag:" + name
+	if currentValue != "" {
+		t.RemoveQuad(cayley.Quad(name, "value", currentValue, ""))
+	}
+	t.AddQuad(cayley.Quad(name, "value", value, ""))
+
+	// Apply transaction
+	if err = store.ApplyTransaction(t); err != nil {
+		log.Errorf("failed transaction (UpdateFlag): %s", err)
+		return ErrTransaction
+	}
+
+	// Return
+	return nil
+}
+
+// GetFlagValue returns the value of the flag given by its name (or an empty string if the flag does not exist)
+func GetFlagValue(name string) (string, error) {
+	return toValue(cayley.StartPath(store, "flag:"+name).Out("value"))
+}
diff --git a/database/flag_test.go b/database/flag_test.go
new file mode 100644
index 00000000..c6399bfb
--- /dev/null
+++ b/database/flag_test.go
@@ -0,0 +1,48 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFlag(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	// Get non existing flag
+	f, err := GetFlagValue("test")
+	assert.Nil(t, err, "GetFlagValue should have worked")
+	assert.Empty(t, "", f, "Getting a non-existing flag should return an empty string")
+
+	// Try to insert invalid flags
+	assert.Error(t, UpdateFlag("test", ""), "It should not accept a flag with an empty name or value")
+	assert.Error(t, UpdateFlag("", "test"), "It should not accept a flag with an empty name or value")
+	assert.Error(t, UpdateFlag("", ""), "It should not accept a flag with an empty name or value")
+
+	// Insert a flag and verify its value
+	assert.Nil(t, UpdateFlag("test", "test1"))
+	f, err = GetFlagValue("test")
+	assert.Nil(t, err, "GetFlagValue should have worked")
+	assert.Equal(t, "test1", f, "GetFlagValue did not return the expected value")
+
+	// Update a flag and verify its value
+	assert.Nil(t, UpdateFlag("test", "test2"))
+	f, err = GetFlagValue("test")
+	assert.Nil(t, err, "GetFlagValue should have worked")
+	assert.Equal(t, "test2", f, "GetFlagValue did not return the expected value")
+}
diff --git a/database/layer.go b/database/layer.go
new file mode 100644
index 00000000..1ee9613c
--- /dev/null
+++ b/database/layer.go
@@ -0,0 +1,377 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"strconv"
+
+	"github.com/coreos/clair/utils"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/google/cayley"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/path"
+)
+
+const (
+	FieldLayerIsValue           = "layer"
+	FieldLayerID                = "id"
+	FieldLayerParent            = "parent"
+	FieldLayerSuccessors        = "successors"
+	FieldLayerOS                = "os"
+	FieldLayerInstalledPackages = "adds"
+	FieldLayerRemovedPackages   = "removes"
+	FieldLayerEngineVersion     = "engineVersion"
+
+	FieldLayerPackages = "adds/removes"
+)
+
+var FieldLayerAll = []string{FieldLayerID, FieldLayerParent, FieldLayerSuccessors, FieldLayerOS, FieldLayerPackages, FieldLayerEngineVersion}
+
+// Layer represents an unique container layer
+type Layer struct {
+	Node                   string `json:"-"`
+	ID                     string
+	ParentNode             string   `json:"-"`
+	SuccessorsNodes        []string `json:"-"`
+	OS                     string
+	InstalledPackagesNodes []string `json:"-"`
+	RemovedPackagesNodes   []string `json:"-"`
+	EngineVersion          int
+}
+
+// GetNode returns the node name of a Layer
+// Requires the key field: ID
+func (l *Layer) GetNode() string {
+	return FieldLayerIsValue + ":" + utils.Hash(l.ID)
+}
+
+// InsertLayer insert a single layer in the database
+//
+// ID, and EngineVersion fields are required.
+// ParentNode, OS, InstalledPackagesNodes and RemovedPackagesNodes are optional,
+// SuccessorsNodes is unnecessary.
+//
+// The ID MUST be unique for two different layers.
+//
+//
+// If the Layer already exists, nothing is done, except if the provided engine
+// version is higher than the existing one, in which case, the OS,
+// InstalledPackagesNodes and RemovedPackagesNodes fields will be replaced.
+//
+// The layer should only contains the newly installed/removed packages
+// There is no safeguard that prevents from marking a package as newly installed
+// while it has already been installed in one of its parent.
+func InsertLayer(layer *Layer) error {
+	// Verify parameters
+	if layer.ID == "" {
+		log.Warning("could not insert a layer which has an empty ID")
+		return cerrors.NewBadRequestError("could not insert a layer which has an empty ID")
+	}
+
+	// Create required data structures
+	t := cayley.NewTransaction()
+	layer.Node = layer.GetNode()
+
+	// Try to find an existing layer
+	existingLayer, err := FindOneLayerByNode(layer.Node, FieldLayerAll)
+	if err != nil && err != cerrors.ErrNotFound {
+		return err
+	}
+
+	if existingLayer != nil && existingLayer.EngineVersion >= layer.EngineVersion {
+		// The layer exists and has an equal or higher engine verison, do nothing
+		return nil
+	}
+
+	if existingLayer == nil {
+		// Create case: add permanent nodes
+		t.AddQuad(cayley.Quad(layer.Node, FieldIs, FieldLayerIsValue, ""))
+		t.AddQuad(cayley.Quad(layer.Node, FieldLayerID, layer.ID, ""))
+		t.AddQuad(cayley.Quad(layer.Node, FieldLayerParent, layer.ParentNode, ""))
+	} else {
+		// Update case: remove everything before we add updated data
+		t.RemoveQuad(cayley.Quad(layer.Node, FieldLayerOS, existingLayer.OS, ""))
+		for _, pkg := range existingLayer.InstalledPackagesNodes {
+			t.RemoveQuad(cayley.Quad(layer.Node, FieldLayerInstalledPackages, pkg, ""))
+		}
+		for _, pkg := range existingLayer.RemovedPackagesNodes {
+			t.RemoveQuad(cayley.Quad(layer.Node, FieldLayerRemovedPackages, pkg, ""))
+		}
+		t.RemoveQuad(cayley.Quad(layer.Node, FieldLayerEngineVersion, strconv.Itoa(existingLayer.EngineVersion), ""))
+	}
+
+	// Add OS/Packages
+	t.AddQuad(cayley.Quad(layer.Node, FieldLayerOS, layer.OS, ""))
+	for _, pkg := range layer.InstalledPackagesNodes {
+		t.AddQuad(cayley.Quad(layer.Node, FieldLayerInstalledPackages, pkg, ""))
+	}
+	for _, pkg := range layer.RemovedPackagesNodes {
+		t.AddQuad(cayley.Quad(layer.Node, FieldLayerRemovedPackages, pkg, ""))
+	}
+	t.AddQuad(cayley.Quad(layer.Node, FieldLayerEngineVersion, strconv.Itoa(layer.EngineVersion), ""))
+
+	// Apply transaction
+	if err = store.ApplyTransaction(t); err != nil {
+		log.Errorf("failed transaction (InsertLayer): %s", err)
+		return ErrTransaction
+	}
+
+	return nil
+}
+
+// FindOneLayerByID finds and returns a single layer having the given ID,
+// selecting the specified fields and hardcoding its ID
+func FindOneLayerByID(ID string, selectedFields []string) (*Layer, error) {
+	t := &Layer{ID: ID}
+	l, err := FindOneLayerByNode(t.GetNode(), selectedFields)
+	if err != nil {
+		return nil, err
+	}
+	l.ID = ID
+	return l, nil
+}
+
+// FindOneLayerByNode finds and returns a single package by its node, selecting the specified fields
+func FindOneLayerByNode(node string, selectedFields []string) (*Layer, error) {
+	l, err := toLayers(cayley.StartPath(store, node).Has(FieldIs, FieldLayerIsValue), selectedFields)
+	if err != nil {
+		return nil, err
+	}
+	if len(l) == 1 {
+		return l[0], nil
+	}
+	if len(l) > 1 {
+		log.Errorf("found multiple layers with identical node [Node: %s]", node)
+		return nil, ErrInconsistent
+	}
+
+	return nil, cerrors.ErrNotFound
+}
+
+// FindAllLayersByAddedPackageNodes finds and returns all layers that add the
+// given packages (by their nodes), selecting the specified fields
+func FindAllLayersByAddedPackageNodes(nodes []string, selectedFields []string) ([]*Layer, error) {
+	layers, err := toLayers(cayley.StartPath(store, nodes...).In(FieldLayerInstalledPackages), selectedFields)
+	if err != nil {
+		return []*Layer{}, err
+	}
+	return layers, nil
+}
+
+// FindAllLayersByPackageNode finds and returns all layers that have the given package (by its node), selecting the specified fields
+// func FindAllLayersByPackageNode(node string, only map[string]struct{}) ([]*Layer, error) {
+// 	var layers []*Layer
+//
+// 	// We need the successors field
+// 	if only != nil {
+// 		only[FieldLayerSuccessors] = struct{}{}
+// 	}
+//
+// 	// Get all the layers which remove the package
+// 	layersNodesRemoving, err := toValues(cayley.StartPath(store, node).In(FieldLayerRemovedPackages).Has(FieldIs, FieldLayerIsValue))
+// 	if err != nil {
+// 		return []*Layer{}, err
+// 	}
+// 	layersNodesRemovingMap := make(map[string]struct{})
+// 	for _, l := range layersNodesRemoving {
+// 		layersNodesRemovingMap[l] = struct{}{}
+// 	}
+//
+// 	layersToBrowse, err := toLayers(cayley.StartPath(store, node).In(FieldLayerInstalledPackages).Has(FieldIs, FieldLayerIsValue), only)
+// 	if err != nil {
+// 		return []*Layer{}, err
+// 	}
+// 	for len(layersToBrowse) > 0 {
+// 		var newLayersToBrowse []*Layer
+// 		for _, layerToBrowse := range layersToBrowse {
+// 			if _, layerRemovesPackage := layersNodesRemovingMap[layerToBrowse.Node]; !layerRemovesPackage {
+// 				layers = append(layers, layerToBrowse)
+// 				successors, err := layerToBrowse.Successors(only)
+// 				if err != nil {
+// 					return []*Layer{}, err
+// 				}
+// 				newLayersToBrowse = append(newLayersToBrowse, successors...)
+// 			}
+// 			layersToBrowse = newLayersToBrowse
+// 		}
+// 	}
+//
+// 	return layers, nil
+// }
+
+// toLayers converts a path leading to one or multiple layers to Layer structs,
+// selecting the specified fields
+func toLayers(path *path.Path, selectedFields []string) ([]*Layer, error) {
+	var layers []*Layer
+
+	saveFields(path, selectedFields, []string{FieldLayerSuccessors, FieldLayerPackages, FieldLayerInstalledPackages, FieldLayerRemovedPackages})
+	it, _ := path.BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		layer := Layer{Node: store.NameOf(it.Result())}
+		for _, selectedField := range selectedFields {
+			switch selectedField {
+			case FieldLayerID:
+				layer.ID = store.NameOf(tags[FieldLayerID])
+			case FieldLayerParent:
+				layer.ParentNode = store.NameOf(tags[FieldLayerParent])
+			case FieldLayerSuccessors:
+				var err error
+				layer.SuccessorsNodes, err = toValues(cayley.StartPath(store, layer.Node).In(FieldLayerParent))
+				if err != nil {
+					log.Errorf("could not get successors of layer %s: %s.", layer.Node, err.Error())
+					return nil, err
+				}
+			case FieldLayerOS:
+				layer.OS = store.NameOf(tags[FieldLayerOS])
+			case FieldLayerPackages:
+				var err error
+				it, _ := cayley.StartPath(store, layer.Node).OutWithTags([]string{"predicate"}, FieldLayerInstalledPackages, FieldLayerRemovedPackages).BuildIterator().Optimize()
+				defer it.Close()
+				for cayley.RawNext(it) {
+					tags := make(map[string]graph.Value)
+					it.TagResults(tags)
+
+					predicate := store.NameOf(tags["predicate"])
+					if predicate == FieldLayerInstalledPackages {
+						layer.InstalledPackagesNodes = append(layer.InstalledPackagesNodes, store.NameOf(it.Result()))
+					} else if predicate == FieldLayerRemovedPackages {
+						layer.RemovedPackagesNodes = append(layer.RemovedPackagesNodes, store.NameOf(it.Result()))
+					}
+				}
+				if it.Err() != nil {
+					log.Errorf("could not get installed/removed packages of layer %s: %s.", layer.Node, it.Err())
+					return nil, err
+				}
+			case FieldLayerEngineVersion:
+				layer.EngineVersion, _ = strconv.Atoi(store.NameOf(tags[FieldLayerEngineVersion]))
+			default:
+				panic("unknown selectedField")
+			}
+		}
+		layers = append(layers, &layer)
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in toLayers: %s", it.Err())
+		return []*Layer{}, ErrBackendException
+	}
+
+	return layers, nil
+}
+
+// Successors find and returns all layers that define l as their parent,
+// selecting the specified fields
+// It requires that FieldLayerSuccessors field has been selected on l
+// func (l *Layer) Successors(selectedFields []string) ([]*Layer, error) {
+// 	if len(l.SuccessorsNodes) == 0 {
+// 		return []*Layer{}, nil
+// 	}
+//
+// 	return toLayers(cayley.StartPath(store, l.SuccessorsNodes...), only)
+// }
+
+// Parent find and returns the parent layer of l, selecting the specified fields
+// It requires that FieldLayerParent field has been selected on l
+func (l *Layer) Parent(selectedFields []string) (*Layer, error) {
+	if l.ParentNode == "" {
+		return nil, nil
+	}
+
+	parent, err := toLayers(cayley.StartPath(store, l.ParentNode), selectedFields)
+	if err != nil {
+		return nil, err
+	}
+	if len(parent) == 1 {
+		return parent[0], nil
+	}
+	if len(parent) > 1 {
+		log.Errorf("found multiple layers when getting parent layer of layer %s", l.ParentNode)
+		return nil, ErrInconsistent
+	}
+	return nil, nil
+}
+
+// Sublayers find and returns all layers that compose l, selecting the specified
+// fields
+// It requires that FieldLayerParent field has been selected on l
+// The base image comes first, and l is last
+// func (l *Layer) Sublayers(selectedFields []string) ([]*Layer, error) {
+// 	var sublayers []*Layer
+//
+// 	// We need the parent field
+// 	if only != nil {
+// 		only[FieldLayerParent] = struct{}{}
+// 	}
+//
+// 	parent, err := l.Parent(only)
+// 	if err != nil {
+// 		return []*Layer{}, err
+// 	}
+// 	if parent != nil {
+// 		parentSublayers, err := parent.Sublayers(only)
+// 		if err != nil {
+// 			return []*Layer{}, err
+// 		}
+// 		sublayers = append(sublayers, parentSublayers...)
+// 	}
+//
+// 	sublayers = append(sublayers, l)
+//
+// 	return sublayers, nil
+// }
+
+// AllPackages computes the full list of packages that l has and return them as
+// nodes.
+// It requires that FieldLayerParent, FieldLayerContentInstalledPackages,
+// FieldLayerContentRemovedPackages fields has been selected on l
+func (l *Layer) AllPackages() ([]string, error) {
+	var allPackages []string
+
+	parent, err := l.Parent([]string{FieldLayerParent, FieldLayerPackages})
+	if err != nil {
+		return []string{}, err
+	}
+	if parent != nil {
+		allPackages, err = parent.AllPackages()
+		if err != nil {
+			return []string{}, err
+		}
+	}
+
+	return append(utils.CompareStringLists(allPackages, l.RemovedPackagesNodes), l.InstalledPackagesNodes...), nil
+}
+
+// OperatingSystem tries to find the Operating System of a layer using its
+// parents.
+// It requires that FieldLayerParent and FieldLayerOS fields has been
+// selected on l
+func (l *Layer) OperatingSystem() (string, error) {
+	if l.OS != "" {
+		return l.OS, nil
+	}
+
+	// Try from the parent
+	parent, err := l.Parent([]string{FieldLayerParent, FieldLayerOS})
+	if err != nil {
+		return "", err
+	}
+	if parent != nil {
+		return parent.OperatingSystem()
+	}
+	return "", nil
+}
diff --git a/database/layer_test.go b/database/layer_test.go
new file mode 100644
index 00000000..96415446
--- /dev/null
+++ b/database/layer_test.go
@@ -0,0 +1,162 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"testing"
+
+	"github.com/coreos/clair/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestInvalidLayers tries to insert invalid layers
+func TestInvalidLayers(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	assert.Error(t, InsertLayer(&Layer{ID: ""})) // No ID
+}
+
+// TestLayerSimple inserts a single layer and ensures it can be retrieved and
+// that methods works
+func TestLayerSimple(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	// Insert a layer and find it back
+	l1 := &Layer{ID: "l1", OS: "os1", InstalledPackagesNodes: []string{"p1", "p2"}, EngineVersion: 1}
+	if assert.Nil(t, InsertLayer(l1)) {
+		fl1, err := FindOneLayerByID("l1", FieldLayerAll)
+		if assert.Nil(t, err) && assert.NotNil(t, fl1) {
+			// Saved = found
+			assert.True(t, layerEqual(l1, fl1), "layers are not equal, expected %v, have %s", l1, fl1)
+
+			// No parent
+			p, err := fl1.Parent(FieldLayerAll)
+			assert.Nil(t, err)
+			assert.Nil(t, p)
+
+			// AllPackages()
+			pk, err := fl1.AllPackages()
+			assert.Nil(t, err)
+			if assert.Len(t, pk, 2) {
+				assert.Contains(t, pk, l1.InstalledPackagesNodes[0])
+				assert.Contains(t, pk, l1.InstalledPackagesNodes[1])
+			}
+			// OS()
+			o, err := fl1.OperatingSystem()
+			assert.Nil(t, err)
+			assert.Equal(t, l1.OS, o)
+		}
+
+		// FindAllLayersByAddedPackageNodes
+		al1, err := FindAllLayersByAddedPackageNodes([]string{"p1", "p3"}, FieldLayerAll)
+		if assert.Nil(t, err) && assert.Len(t, al1, 1) {
+			assert.Equal(t, al1[0].Node, l1.Node)
+		}
+	}
+}
+
+// TestLayerTree inserts a tree of layers and ensure that the tree lgoic works
+func TestLayerTree(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	var layers []*Layer
+	layers = append(layers, &Layer{ID: "l1"})
+	layers = append(layers, &Layer{ID: "l2", ParentNode: layers[0].GetNode(), OS: "os2", InstalledPackagesNodes: []string{"p1", "p2"}})
+	layers = append(layers, &Layer{ID: "l3", ParentNode: layers[1].GetNode()})                                                                                      // Repeat an empty layer archive (l1)
+	layers = append(layers, &Layer{ID: "l4a", ParentNode: layers[2].GetNode(), InstalledPackagesNodes: []string{"p3"}, RemovedPackagesNodes: []string{"p1", "p4"}}) // p4 does not exists and thu can't actually be removed
+	layers = append(layers, &Layer{ID: "l4b", ParentNode: layers[2].GetNode(), InstalledPackagesNodes: []string{}, RemovedPackagesNodes: []string{"p2", "p1"}})
+
+	var flayers []*Layer
+	ok := true
+	for _, l := range layers {
+		ok = ok && assert.Nil(t, InsertLayer(l))
+
+		fl, err := FindOneLayerByID(l.ID, FieldLayerAll)
+		ok = ok && assert.Nil(t, err)
+		ok = ok && assert.NotNil(t, fl)
+		flayers = append(flayers, fl)
+	}
+	if assert.True(t, ok) {
+		// Start testing
+
+		// l4a
+		// Parent()
+		fl4ap, err := flayers[3].Parent(FieldLayerAll)
+		assert.Nil(t, err, "l4a should has l3 as parent")
+		if assert.NotNil(t, fl4ap, "l4a should has l3 as parent") {
+			assert.Equal(t, "l3", fl4ap.ID, "l4a should has l3 as parent")
+		}
+
+		// OS()
+		fl4ao, err := flayers[3].OperatingSystem()
+		assert.Nil(t, err, "l4a should inherits its OS from l2")
+		assert.Equal(t, "os2", fl4ao, "l4a should inherits its OS from l2")
+		// AllPackages()
+		fl4apkg, err := flayers[3].AllPackages()
+		assert.Nil(t, err)
+		if assert.Len(t, fl4apkg, 2) {
+			assert.Contains(t, fl4apkg, "p2")
+			assert.Contains(t, fl4apkg, "p3")
+		}
+
+		// l4b
+		// AllPackages()
+		fl4bpkg, err := flayers[4].AllPackages()
+		assert.Nil(t, err)
+		assert.Len(t, fl4bpkg, 0)
+	}
+}
+
+func TestLayerUpdate(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	l1 := &Layer{ID: "l1", OS: "os1", InstalledPackagesNodes: []string{"p1", "p2"}, RemovedPackagesNodes: []string{"p3", "p4"}, EngineVersion: 1}
+	if assert.Nil(t, InsertLayer(l1)) {
+		// Do not update layer content if the engine versions are equals
+		l1b := &Layer{ID: "l1", OS: "os2", InstalledPackagesNodes: []string{"p1"}, RemovedPackagesNodes: []string{""}, EngineVersion: 1}
+		if assert.Nil(t, InsertLayer(l1b)) {
+			fl1b, err := FindOneLayerByID(l1.ID, FieldLayerAll)
+			if assert.Nil(t, err) && assert.NotNil(t, fl1b) {
+				assert.True(t, layerEqual(l1, fl1b), "layer contents are not equal, expected %v, have %s", l1, fl1b)
+			}
+		}
+
+		// Update the layer content with new data and a higher engine version
+		l1c := &Layer{ID: "l1", OS: "os2", InstalledPackagesNodes: []string{"p1", "p5"}, RemovedPackagesNodes: []string{"p6", "p7"}, EngineVersion: 2}
+		if assert.Nil(t, InsertLayer(l1c)) {
+			fl1c, err := FindOneLayerByID(l1c.ID, FieldLayerAll)
+			if assert.Nil(t, err) && assert.NotNil(t, fl1c) {
+				assert.True(t, layerEqual(l1c, fl1c), "layer contents are not equal, expected %v, have %s", l1c, fl1c)
+			}
+		}
+	}
+}
+
+func layerEqual(expected, actual *Layer) bool {
+	eq := true
+	eq = eq && expected.Node == actual.Node
+	eq = eq && expected.ID == actual.ID
+	eq = eq && expected.ParentNode == actual.ParentNode
+	eq = eq && expected.OS == actual.OS
+	eq = eq && expected.EngineVersion == actual.EngineVersion
+	eq = eq && len(utils.CompareStringLists(actual.SuccessorsNodes, expected.SuccessorsNodes)) == 0 && len(utils.CompareStringLists(expected.SuccessorsNodes, actual.SuccessorsNodes)) == 0
+	eq = eq && len(utils.CompareStringLists(actual.RemovedPackagesNodes, expected.RemovedPackagesNodes)) == 0 && len(utils.CompareStringLists(expected.RemovedPackagesNodes, actual.RemovedPackagesNodes)) == 0
+	eq = eq && len(utils.CompareStringLists(actual.InstalledPackagesNodes, expected.InstalledPackagesNodes)) == 0 && len(utils.CompareStringLists(expected.InstalledPackagesNodes, actual.InstalledPackagesNodes)) == 0
+	return eq
+}
diff --git a/database/lock.go b/database/lock.go
new file mode 100644
index 00000000..caab4931
--- /dev/null
+++ b/database/lock.go
@@ -0,0 +1,137 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/barakmich/glog"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/google/cayley"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/path"
+)
+
+// Lock tries to set a temporary lock in the database.
+// If a lock already exists with the given name/owner, then the lock is renewed
+//
+// Lock does not block, instead, it returns true and its expiration time
+// is the lock has been successfully acquired or false otherwise
+func Lock(name string, duration time.Duration, owner string) (bool, time.Time) {
+	pruneLocks()
+
+	until := time.Now().Add(duration)
+	untilString := strconv.FormatInt(until.Unix(), 10)
+
+	// Try to get the expiration time of a lock with the same name/owner
+	currentExpiration, err := toValue(cayley.StartPath(store, name).Has("locked_by", owner).Out("locked_until"))
+	if err == nil && currentExpiration != "" {
+		// Renew our lock
+		if currentExpiration == untilString {
+			return true, until
+		}
+
+		t := cayley.NewTransaction()
+		t.RemoveQuad(cayley.Quad(name, "locked_until", currentExpiration, ""))
+		t.AddQuad(cayley.Quad(name, "locked_until", untilString, ""))
+		// It is not necessary to verify if the lock is ours again in the transaction
+		// because if someone took it, the lock's current expiration probably changed and the transaction will fail
+		return store.ApplyTransaction(t) == nil, until
+	}
+
+	t := cayley.NewTransaction()
+	t.AddQuad(cayley.Quad(name, "locked", "locked", "")) // Necessary to make the transaction fails if the lock already exists (and has not been pruned)
+	t.AddQuad(cayley.Quad(name, "locked_until", untilString, ""))
+	t.AddQuad(cayley.Quad(name, "locked_by", owner, ""))
+
+	glog.SetStderrThreshold("FATAL")
+	success := store.ApplyTransaction(t) == nil
+	glog.SetStderrThreshold("ERROR")
+
+	return success, until
+}
+
+// Unlock unlocks a lock specified by its name if I own it
+func Unlock(name, owner string) {
+	pruneLocks()
+
+	t := cayley.NewTransaction()
+	it, _ := cayley.StartPath(store, name).Has("locked", "locked").Has("locked_by", owner).Save("locked_until", "locked_until").BuildIterator().Optimize()
+	defer it.Close()
+
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		t.RemoveQuad(cayley.Quad(name, "locked", "locked", ""))
+		t.RemoveQuad(cayley.Quad(name, "locked_until", store.NameOf(tags["locked_until"]), ""))
+		t.RemoveQuad(cayley.Quad(name, "locked_by", owner, ""))
+	}
+
+	store.ApplyTransaction(t)
+}
+
+// LockInfo returns the owner of a lock specified by its name and its
+// expiration time
+func LockInfo(name string) (string, time.Time, error) {
+	it, _ := cayley.StartPath(store, name).Has("locked", "locked").Save("locked_until", "locked_until").Save("locked_by", "locked_by").BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		tt, _ := strconv.ParseInt(store.NameOf(tags["locked_until"]), 10, 64)
+		return store.NameOf(tags["locked_by"]), time.Unix(tt, 0), nil
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in LockInfo: %s", it.Err())
+		return "", time.Time{}, ErrBackendException
+	}
+
+	return "", time.Time{}, cerrors.ErrNotFound
+}
+
+// pruneLocks removes every expired locks from the database
+func pruneLocks() {
+	now := time.Now()
+
+	// Delete every expired locks
+	tr := cayley.NewTransaction()
+	it, _ := cayley.StartPath(store, "locked").In("locked").Save("locked_until", "locked_until").Save("locked_by", "locked_by").BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		n := store.NameOf(it.Result())
+		t := store.NameOf(tags["locked_until"])
+		o := store.NameOf(tags["locked_by"])
+		tt, _ := strconv.ParseInt(t, 10, 64)
+
+		if now.Unix() > tt {
+			log.Debugf("Lock %s owned by %s has expired.", n, o)
+			tr.RemoveQuad(cayley.Quad(n, "locked", "locked", ""))
+			tr.RemoveQuad(cayley.Quad(n, "locked_until", t, ""))
+			tr.RemoveQuad(cayley.Quad(n, "locked_by", o, ""))
+		}
+	}
+	store.ApplyTransaction(tr)
+}
+
+// getLockedNodes returns every nodes that are currently locked
+func getLockedNodes() *path.Path {
+	return cayley.StartPath(store, "locked").In("locked")
+}
diff --git a/database/lock_test.go b/database/lock_test.go
new file mode 100644
index 00000000..cf8916b8
--- /dev/null
+++ b/database/lock_test.go
@@ -0,0 +1,56 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLock(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	var l bool
+	var et time.Time
+
+	// Create a first lock
+	l, _ = Lock("test1", time.Minute, "owner1")
+	assert.True(t, l)
+	// Try to lock the same lock with another owner
+	l, _ = Lock("test1", time.Minute, "owner2")
+	assert.False(t, l)
+	// Renew the lock
+	l, _ = Lock("test1", time.Minute, "owner1")
+	assert.True(t, l)
+	// Unlock and then relock by someone else
+	Unlock("test1", "owner1")
+	l, et = Lock("test1", time.Minute, "owner2")
+	assert.True(t, l)
+	// LockInfo
+	o, et2, err := LockInfo("test1")
+	assert.Nil(t, err)
+	assert.Equal(t, "owner2", o)
+	assert.Equal(t, et.Second(), et2.Second())
+
+	// Create a second lock which is actually already expired ...
+	l, _ = Lock("test2", -time.Minute, "owner1")
+	assert.True(t, l)
+	// Take over the lock
+	l, _ = Lock("test2", time.Minute, "owner2")
+	assert.True(t, l)
+}
diff --git a/database/notification.go b/database/notification.go
new file mode 100644
index 00000000..447bcee8
--- /dev/null
+++ b/database/notification.go
@@ -0,0 +1,402 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"github.com/coreos/clair/utils"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils/types"
+	"github.com/google/cayley"
+	"github.com/google/cayley/graph"
+	"github.com/pborman/uuid"
+)
+
+// maxNotifications is the number of notifications that InsertNotifications
+// will accept at the same time. Above this number, notifications are ignored.
+const maxNotifications = 100
+
+// A Notification defines an interface to a message that can be sent by a
+// notifier.Notifier.
+// A NotificationWrapper has to be used to convert it into a NotificationWrap,
+// which can be stored in the database.
+type Notification interface {
+	// GetName returns the explicit (humanly meaningful) name of a notification.
+	GetName() string
+	// GetType returns the type of a notification, which is used by a
+	// NotificationWrapper to determine the concrete type of a Notification.
+	GetType() string
+	// GetContent returns the content of the notification.
+	GetContent() (interface{}, error)
+}
+
+// NotificationWrapper is an interface defined how to convert a Notification to
+// a NotificationWrap object and vice-versa.
+type NotificationWrapper interface {
+	// Wrap packs a Notification instance into a new NotificationWrap.
+	Wrap(n Notification) (*NotificationWrap, error)
+	// Unwrap unpacks an instance of NotificationWrap into a new Notification.
+	Unwrap(nw *NotificationWrap) (Notification, error)
+}
+
+// A NotificationWrap wraps a Notification into something that can be stored in
+// the database. A NotificationWrapper has to be used to convert it into a
+// Notification.
+type NotificationWrap struct {
+	Type string
+	Data string
+}
+
+// DefaultWrapper is an implementation of NotificationWrapper that supports
+// NewVulnerabilityNotification notifications.
+type DefaultWrapper struct{}
+
+func (w *DefaultWrapper) Wrap(n Notification) (*NotificationWrap, error) {
+	data, err := json.Marshal(n)
+	if err != nil {
+		log.Warningf("could not marshal notification [ID: %s, Type: %s]: %s", n.GetName(), n.GetType(), err)
+		return nil, cerrors.NewBadRequestError("could not marshal notification with DefaultWrapper")
+	}
+
+	return &NotificationWrap{Type: n.GetType(), Data: string(data)}, nil
+}
+
+func (w *DefaultWrapper) Unwrap(nw *NotificationWrap) (Notification, error) {
+	var v Notification
+
+	// Create struct depending on the type
+	switch nw.Type {
+	case "NewVulnerabilityNotification":
+		v = &NewVulnerabilityNotification{}
+	case "VulnerabilityPriorityIncreasedNotification":
+		v = &VulnerabilityPriorityIncreasedNotification{}
+	case "VulnerabilityPackageChangedNotification":
+		v = &VulnerabilityPackageChangedNotification{}
+	default:
+		log.Warningf("could not unwrap notification [Type: %s]: unknown type for DefaultWrapper", nw.Type)
+		return nil, cerrors.NewBadRequestError("could not unwrap notification")
+	}
+
+	// Unmarshal notification
+	err := json.Unmarshal([]byte(nw.Data), v)
+	if err != nil {
+		log.Warningf("could not unmarshal notification with DefaultWrapper [Type: %s]: %s", nw.Type, err)
+		return nil, cerrors.NewBadRequestError("could not unmarshal notification")
+	}
+
+	return v, nil
+}
+
+// GetDefaultNotificationWrapper returns the default wrapper
+func GetDefaultNotificationWrapper() NotificationWrapper {
+	return &DefaultWrapper{}
+}
+
+// A NewVulnerabilityNotification is a notification that informs about a new
+// vulnerability and contains all the layers that introduce that vulnerability
+type NewVulnerabilityNotification struct {
+	VulnerabilityID string
+}
+
+func (n *NewVulnerabilityNotification) GetName() string {
+	return n.VulnerabilityID
+}
+
+func (n *NewVulnerabilityNotification) GetType() string {
+	return "NewVulnerabilityNotification"
+}
+
+func (n *NewVulnerabilityNotification) GetContent() (interface{}, error) {
+	// This notification is about a new vulnerability
+	// Returns the list of layers that introduce this vulnerability
+
+	// Find vulnerability.
+	vulnerability, err := FindOneVulnerability(n.VulnerabilityID, []string{FieldVulnerabilityID, FieldVulnerabilityLink, FieldVulnerabilityPriority, FieldVulnerabilityDescription, FieldVulnerabilityFixedIn})
+	if err != nil {
+		return []byte{}, err
+	}
+	abstractVulnerability, err := vulnerability.ToAbstractVulnerability()
+	if err != nil {
+		return []byte{}, err
+	}
+
+	layers, err := FindAllLayersIntroducingVulnerability(n.VulnerabilityID, []string{FieldLayerID})
+
+	if err != nil {
+		return []byte{}, err
+	}
+
+	layersIDs := []string{} // empty slice, not null
+	for _, l := range layers {
+		layersIDs = append(layersIDs, l.ID)
+	}
+
+	return struct {
+		Vulnerability        *AbstractVulnerability
+		IntroducingLayersIDs []string
+	}{
+		Vulnerability:        abstractVulnerability,
+		IntroducingLayersIDs: layersIDs,
+	}, nil
+}
+
+// A VulnerabilityPriorityIncreasedNotification is a notification that informs
+// about the fact that the priority of a vulnerability increased
+// vulnerability and contains all the layers that introduce that vulnerability.
+type VulnerabilityPriorityIncreasedNotification struct {
+	VulnerabilityID          string
+	OldPriority, NewPriority types.Priority
+}
+
+func (n *VulnerabilityPriorityIncreasedNotification) GetName() string {
+	return n.VulnerabilityID
+}
+
+func (n *VulnerabilityPriorityIncreasedNotification) GetType() string {
+	return "VulnerabilityPriorityIncreasedNotification"
+}
+
+func (n *VulnerabilityPriorityIncreasedNotification) GetContent() (interface{}, error) {
+	// Returns the list of layers that introduce this vulnerability
+	// And both the old and new priorities
+
+	// Find vulnerability.
+	vulnerability, err := FindOneVulnerability(n.VulnerabilityID, []string{FieldVulnerabilityID, FieldVulnerabilityLink, FieldVulnerabilityPriority, FieldVulnerabilityDescription, FieldVulnerabilityFixedIn})
+	if err != nil {
+		return []byte{}, err
+	}
+	abstractVulnerability, err := vulnerability.ToAbstractVulnerability()
+	if err != nil {
+		return []byte{}, err
+	}
+
+	layers, err := FindAllLayersIntroducingVulnerability(n.VulnerabilityID, []string{FieldLayerID})
+
+	if err != nil {
+		return []byte{}, err
+	}
+
+	layersIDs := []string{} // empty slice, not null
+	for _, l := range layers {
+		layersIDs = append(layersIDs, l.ID)
+	}
+
+	return struct {
+		Vulnerability            *AbstractVulnerability
+		OldPriority, NewPriority types.Priority
+		IntroducingLayersIDs     []string
+	}{
+		Vulnerability:        abstractVulnerability,
+		OldPriority:          n.OldPriority,
+		NewPriority:          n.NewPriority,
+		IntroducingLayersIDs: layersIDs,
+	}, nil
+}
+
+// A VulnerabilityPackageChangedNotification is a notification that informs that
+// an existing vulnerability's fixed package list has been updated and may not
+// affect some layers anymore or may affect new layers.
+type VulnerabilityPackageChangedNotification struct {
+	VulnerabilityID                        string
+	AddedFixedInNodes, RemovedFixedInNodes []string
+}
+
+func (n *VulnerabilityPackageChangedNotification) GetName() string {
+	return n.VulnerabilityID
+}
+
+func (n *VulnerabilityPackageChangedNotification) GetType() string {
+	return "VulnerabilityPackageChangedNotification"
+}
+
+func (n *VulnerabilityPackageChangedNotification) GetContent() (interface{}, error) {
+	// Returns the removed and added packages as well as the layers that
+	// introduced the vulnerability in the past but don't anymore because of the
+	// removed packages and the layers that now introduce the vulnerability
+	// because of the added packages
+
+	// Find vulnerability.
+	vulnerability, err := FindOneVulnerability(n.VulnerabilityID, []string{FieldVulnerabilityID, FieldVulnerabilityLink, FieldVulnerabilityPriority, FieldVulnerabilityDescription, FieldVulnerabilityFixedIn})
+	if err != nil {
+		return []byte{}, err
+	}
+	abstractVulnerability, err := vulnerability.ToAbstractVulnerability()
+	if err != nil {
+		return []byte{}, err
+	}
+
+	// First part of the answer : added/removed packages
+	addedPackages, err := FindAllPackagesByNodes(n.AddedFixedInNodes, []string{FieldPackageOS, FieldPackageName, FieldPackageVersion, FieldPackagePreviousVersion})
+	if err != nil {
+		return []byte{}, err
+	}
+	removedPackages, err := FindAllPackagesByNodes(n.RemovedFixedInNodes, []string{FieldPackageOS, FieldPackageName, FieldPackageVersion, FieldPackagePreviousVersion})
+	if err != nil {
+		return []byte{}, err
+	}
+
+	// Second part of the answer
+	var addedPackagesPreviousVersions []string
+	for _, pkg := range addedPackages {
+		previousVersions, err := pkg.PreviousVersions([]string{})
+		if err != nil {
+			return []*Layer{}, err
+		}
+		for _, version := range previousVersions {
+			addedPackagesPreviousVersions = append(addedPackagesPreviousVersions, version.Node)
+		}
+	}
+	var removedPackagesPreviousVersions []string
+	for _, pkg := range removedPackages {
+		previousVersions, err := pkg.PreviousVersions([]string{})
+		if err != nil {
+			return []*Layer{}, err
+		}
+		for _, version := range previousVersions {
+			removedPackagesPreviousVersions = append(removedPackagesPreviousVersions, version.Node)
+		}
+	}
+
+	newIntroducingLayers, err := FindAllLayersByAddedPackageNodes(addedPackagesPreviousVersions, []string{FieldLayerID})
+	if err != nil {
+		return []byte{}, err
+	}
+	formerIntroducingLayers, err := FindAllLayersByAddedPackageNodes(removedPackagesPreviousVersions, []string{FieldLayerID})
+	if err != nil {
+		return []byte{}, err
+	}
+
+	newIntroducingLayersIDs := []string{} // empty slice, not null
+	for _, l := range newIntroducingLayers {
+		newIntroducingLayersIDs = append(newIntroducingLayersIDs, l.ID)
+	}
+	formerIntroducingLayersIDs := []string{} // empty slice, not null
+	for _, l := range formerIntroducingLayers {
+		formerIntroducingLayersIDs = append(formerIntroducingLayersIDs, l.ID)
+	}
+
+	// Remove layers which appears both in new and former lists (eg. case of updated packages but still vulnerable)
+	filteredNewIntroducingLayersIDs := utils.CompareStringLists(newIntroducingLayersIDs, formerIntroducingLayersIDs)
+	filteredFormerIntroducingLayersIDs := utils.CompareStringLists(formerIntroducingLayersIDs, newIntroducingLayersIDs)
+
+	return struct {
+		Vulnerability                                      *AbstractVulnerability
+		AddedAffectedPackages, RemovedAffectedPackages     []*AbstractPackage
+		NewIntroducingLayersIDs, FormerIntroducingLayerIDs []string
+	}{
+		Vulnerability:             abstractVulnerability,
+		AddedAffectedPackages:     PackagesToAbstractPackages(addedPackages),
+		RemovedAffectedPackages:   PackagesToAbstractPackages(removedPackages),
+		NewIntroducingLayersIDs:   filteredNewIntroducingLayersIDs,
+		FormerIntroducingLayerIDs: filteredFormerIntroducingLayersIDs,
+	}, nil
+}
+
+// InsertNotifications stores multiple Notification in the database
+// It uses the given NotificationWrapper to convert these notifications to
+// something that can be stored in the database.
+func InsertNotifications(notifications []Notification, wrapper NotificationWrapper) error {
+	if len(notifications) == 0 {
+		return nil
+	}
+
+	// Do not send notifications if there are too many of them (first update for example)
+	if len(notifications) > maxNotifications {
+		log.Noticef("Ignoring %d notifications", len(notifications))
+		return nil
+	}
+
+	// Initialize transaction
+	t := cayley.NewTransaction()
+
+	// Iterate over all the vulnerabilities we need to insert
+	for _, notification := range notifications {
+		// Wrap notification
+		wrappedNotification, err := wrapper.Wrap(notification)
+		if err != nil {
+			return err
+		}
+
+		node := "notification:" + uuid.New()
+		t.AddQuad(cayley.Quad(node, FieldIs, "notification", ""))
+		t.AddQuad(cayley.Quad(node, "type", wrappedNotification.Type, ""))
+		t.AddQuad(cayley.Quad(node, "data", wrappedNotification.Data, ""))
+		t.AddQuad(cayley.Quad(node, "isSent", strconv.FormatBool(false), ""))
+	}
+
+	// Apply transaction
+	if err := store.ApplyTransaction(t); err != nil {
+		log.Errorf("failed transaction (InsertNotifications): %s", err)
+		return ErrTransaction
+	}
+
+	return nil
+}
+
+// FindOneNotificationToSend finds and returns a notification that is not sent
+// yet and not locked. Returns nil if there is none.
+func FindOneNotificationToSend(wrapper NotificationWrapper) (string, Notification, error) {
+	it, _ := cayley.StartPath(store, "notification").In(FieldIs).Has("isSent", strconv.FormatBool(false)).Except(getLockedNodes()).Save("type", "type").Save("data", "data").BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		notification, err := wrapper.Unwrap(&NotificationWrap{Type: store.NameOf(tags["type"]), Data: store.NameOf(tags["data"])})
+		if err != nil {
+			return "", nil, err
+		}
+
+		return store.NameOf(it.Result()), notification, nil
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in FindOneNotificationToSend: %s", it.Err())
+		return "", nil, ErrBackendException
+	}
+
+	return "", nil, nil
+}
+
+// CountNotificationsToSend returns the number of pending notifications
+// Note that it also count the locked notifications.
+func CountNotificationsToSend() (int, error) {
+	c := 0
+
+	it, _ := cayley.StartPath(store, "notification").In(FieldIs).Has("isSent", strconv.FormatBool(false)).BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		c = c + 1
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in CountNotificationsToSend: %s", it.Err())
+		return 0, ErrBackendException
+	}
+
+	return c, nil
+}
+
+// MarkNotificationAsSent marks a notification as sent.
+func MarkNotificationAsSent(node string) {
+	// Initialize transaction
+	t := cayley.NewTransaction()
+
+	t.RemoveQuad(cayley.Quad(node, "isSent", strconv.FormatBool(false), ""))
+	t.AddQuad(cayley.Quad(node, "isSent", strconv.FormatBool(true), ""))
+
+	// Apply transaction
+	store.ApplyTransaction(t)
+}
diff --git a/database/notification_test.go b/database/notification_test.go
new file mode 100644
index 00000000..65bf3629
--- /dev/null
+++ b/database/notification_test.go
@@ -0,0 +1,144 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type TestWrapper struct{}
+
+func (w *TestWrapper) Wrap(n Notification) (*NotificationWrap, error) {
+	data, err := json.Marshal(n)
+	if err != nil {
+		return nil, err
+	}
+
+	return &NotificationWrap{Type: n.GetType(), Data: string(data)}, nil
+}
+
+func (w *TestWrapper) Unwrap(nw *NotificationWrap) (Notification, error) {
+	var v Notification
+
+	switch nw.Type {
+	case "ntest1":
+		v = &NotificationTest1{}
+	case "ntest2":
+		v = &NotificationTest2{}
+	default:
+		return nil, fmt.Errorf("Could not Unwrap NotificationWrapper [Type: %s, Data: %s]: Unknown notification type.", nw.Type, nw.Data)
+	}
+
+	err := json.Unmarshal([]byte(nw.Data), v)
+	return v, err
+}
+
+type NotificationTest1 struct {
+	Test1 string
+}
+
+func (n NotificationTest1) GetName() string {
+	return n.Test1
+}
+
+func (n NotificationTest1) GetType() string {
+	return "ntest1"
+}
+
+func (n NotificationTest1) GetContent() (interface{}, error) {
+	return struct{ Test1 string }{Test1: n.Test1}, nil
+}
+
+type NotificationTest2 struct {
+	Test2 string
+}
+
+func (n NotificationTest2) GetName() string {
+	return n.Test2
+}
+
+func (n NotificationTest2) GetType() string {
+	return "ntest2"
+}
+
+func (n NotificationTest2) GetContent() (interface{}, error) {
+	return struct{ Test2 string }{Test2: n.Test2}, nil
+}
+
+func TestNotification(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	wrapper := &TestWrapper{}
+
+	// Insert two notifications of different types
+	n1 := &NotificationTest1{Test1: "test1"}
+	n2 := &NotificationTest2{Test2: "test2"}
+	err := InsertNotifications([]Notification{n1, n2}, &TestWrapper{})
+	assert.Nil(t, err)
+
+	// Count notifications to send
+	c, err := CountNotificationsToSend()
+	assert.Nil(t, err)
+	assert.Equal(t, 2, c)
+
+	foundN1 := false
+	foundN2 := false
+
+	// Select the first one
+	node, n, err := FindOneNotificationToSend(wrapper)
+	assert.Nil(t, err)
+	if assert.NotNil(t, n) {
+		if reflect.DeepEqual(n1, n) {
+			foundN1 = true
+		} else if reflect.DeepEqual(n2, n) {
+			foundN2 = true
+		} else {
+			assert.Fail(t, "did not find any expected notification")
+			return
+		}
+	}
+
+	// Mark the first one as sent
+	MarkNotificationAsSent(node)
+
+	// Count notifications to send
+	c, err = CountNotificationsToSend()
+	assert.Nil(t, err)
+	assert.Equal(t, 1, c)
+
+	// Select again
+	node, n, err = FindOneNotificationToSend(wrapper)
+	assert.Nil(t, err)
+	if foundN1 {
+		assert.Equal(t, n2, n)
+	} else if foundN2 {
+		assert.Equal(t, n1, n)
+	}
+
+	// Lock the second one
+	Lock(node, time.Minute, "TestNotification")
+
+	// Select again
+	_, n, err = FindOneNotificationToSend(wrapper)
+	assert.Nil(t, err)
+	assert.Equal(t, nil, n)
+}
diff --git a/database/os_mapping.go b/database/os_mapping.go
new file mode 100644
index 00000000..e66d2289
--- /dev/null
+++ b/database/os_mapping.go
@@ -0,0 +1,44 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+// DebianReleasesMapping translates Debian code names and class names to version numbers
+// TODO That should probably be stored in the database or in a file
+var DebianReleasesMapping = map[string]string{
+	// Code names
+	"squeeze": "6",
+	"wheezy":  "7",
+	"jessie":  "8",
+	"stretch": "9",
+	"sid":     "unstable",
+
+	// Class names
+	"oldstable": "7",
+	"stable":    "8",
+	"testing":   "9",
+	"unstable":  "unstable",
+}
+
+// UbuntuReleasesMapping translates Ubuntu code names to version numbers
+// TODO That should probably be stored in the database or in a file
+var UbuntuReleasesMapping = map[string]string{
+	"precise": "12.04",
+	"quantal": "12.10",
+	"raring":  "13.04",
+	"trusty":  "14.04",
+	"utopic":  "14.10",
+	"vivid":   "15.04",
+	"wily":    "15.10",
+}
diff --git a/database/package.go b/database/package.go
new file mode 100644
index 00000000..5ecae975
--- /dev/null
+++ b/database/package.go
@@ -0,0 +1,485 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"sort"
+
+	"github.com/coreos/clair/utils"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils/types"
+	"github.com/google/cayley"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/path"
+)
+
+const (
+	FieldPackageIsValue         = "package"
+	FieldPackageOS              = "os"
+	FieldPackageName            = "name"
+	FieldPackageVersion         = "version"
+	FieldPackageNextVersion     = "nextVersion"
+	FieldPackagePreviousVersion = "previousVersion"
+
+	insertPackagesBatchSize = 5
+)
+
+var FieldPackageAll = []string{FieldPackageOS, FieldPackageName, FieldPackageVersion, FieldPackageNextVersion, FieldPackagePreviousVersion}
+
+// Package represents a package
+type Package struct {
+	Node                string `json:"-"`
+	OS                  string
+	Name                string
+	Version             types.Version
+	NextVersionNode     string `json:"-"`
+	PreviousVersionNode string `json:"-"`
+}
+
+// GetNode returns an unique identifier for the graph node
+// Requires the key fields: OS, Name, Version
+func (p *Package) GetNode() string {
+	return FieldPackageIsValue + ":" + utils.Hash(p.Key())
+}
+
+// Key returns an unique string defining p
+// Requires the key fields: OS, Name, Version
+func (p *Package) Key() string {
+	return p.OS + ":" + p.Name + ":" + p.Version.String()
+}
+
+// Branch returns an unique string defined the Branch of p (os, name)
+// Requires the key fields: OS, Name
+func (p *Package) Branch() string {
+	return p.OS + ":" + p.Name
+}
+
+// AbstractPackage is a package that abstract types.MaxVersion by modifying
+// using a AllVersion boolean field and renaming Version to BeforeVersion
+// which makes more sense for an usage with a Vulnerability
+type AbstractPackage struct {
+	OS   string
+	Name string
+
+	AllVersions   bool
+	BeforeVersion types.Version
+}
+
+// PackagesToAbstractPackages converts several Packages to AbstractPackages
+func PackagesToAbstractPackages(packages []*Package) (abstractPackages []*AbstractPackage) {
+	for _, p := range packages {
+		ap := &AbstractPackage{OS: p.OS, Name: p.Name}
+		if p.Version != types.MaxVersion {
+			ap.BeforeVersion = p.Version
+		} else {
+			ap.AllVersions = true
+		}
+		abstractPackages = append(abstractPackages, ap)
+	}
+	return
+}
+
+// AbstractPackagesToPackages converts several AbstractPackages to Packages
+func AbstractPackagesToPackages(abstractPackages []*AbstractPackage) (packages []*Package) {
+	for _, ap := range abstractPackages {
+		p := &Package{OS: ap.OS, Name: ap.Name}
+		if ap.AllVersions {
+			p.Version = types.MaxVersion
+		} else {
+			p.Version = ap.BeforeVersion
+		}
+		packages = append(packages, p)
+	}
+	return
+}
+
+// InsertPackages inserts several packages in the database in one transaction
+// Packages are stored in linked lists, one per Branch. Each linked list has a start package and an end package defined with types.MinVersion/types.MaxVersion versions
+//
+// OS, Name and Version fields have to be specified.
+// If the insertion is successfull, the Node field is filled and represents the graph node identifier.
+func InsertPackages(packageParameters []*Package) error {
+	if len(packageParameters) == 0 {
+		return nil
+	}
+
+	// Verify parameters
+	for _, pkg := range packageParameters {
+		if pkg.OS == "" || pkg.Name == "" || pkg.Version.String() == "" {
+			log.Warningf("could not insert an incomplete package [OS: %s, Name: %s, Version: %s]", pkg.OS, pkg.Name, pkg.Version)
+			return cerrors.NewBadRequestError("could not insert an incomplete package")
+		}
+	}
+
+	// Create required data structures
+	t := cayley.NewTransaction()
+	packagesInTransaction := 0
+	cachedPackagesByBranch := make(map[string]map[string]*Package)
+
+	// Iterate over all the packages we need to insert
+	for _, packageParameter := range packageParameters {
+		branch := packageParameter.Branch()
+
+		// Is the package already existing ?
+		if _, branchExistsLocally := cachedPackagesByBranch[branch]; branchExistsLocally {
+			if pkg, _ := cachedPackagesByBranch[branch][packageParameter.Key()]; pkg != nil {
+				packageParameter.Node = pkg.Node
+				continue
+			}
+		} else {
+			cachedPackagesByBranch[branch] = make(map[string]*Package)
+		}
+		pkg, err := FindOnePackage(packageParameter.OS, packageParameter.Name, packageParameter.Version, []string{})
+		if err != nil && err != cerrors.ErrNotFound {
+			return err
+		}
+		if pkg != nil {
+			packageParameter.Node = pkg.Node
+			continue
+		}
+
+		// Get all packages of the same branch (both from local cache and database)
+		branchPackages, err := FindAllPackagesByBranch(packageParameter.OS, packageParameter.Name, []string{FieldPackageOS, FieldPackageName, FieldPackageVersion, FieldPackageNextVersion})
+		if err != nil {
+			return err
+		}
+		for _, p := range cachedPackagesByBranch[branch] {
+			branchPackages = append(branchPackages, p)
+		}
+
+		if len(branchPackages) == 0 {
+			// The branch does not exist yet
+			insertingStartPackage := packageParameter.Version == types.MinVersion
+			insertingEndPackage := packageParameter.Version == types.MaxVersion
+
+			// Create and insert a end package
+			endPackage := &Package{
+				OS:      packageParameter.OS,
+				Name:    packageParameter.Name,
+				Version: types.MaxVersion,
+			}
+			endPackage.Node = endPackage.GetNode()
+			cachedPackagesByBranch[branch][endPackage.Key()] = endPackage
+
+			t.AddQuad(cayley.Quad(endPackage.Node, FieldIs, FieldPackageIsValue, ""))
+			t.AddQuad(cayley.Quad(endPackage.Node, FieldPackageOS, endPackage.OS, ""))
+			t.AddQuad(cayley.Quad(endPackage.Node, FieldPackageName, endPackage.Name, ""))
+			t.AddQuad(cayley.Quad(endPackage.Node, FieldPackageVersion, endPackage.Version.String(), ""))
+			t.AddQuad(cayley.Quad(endPackage.Node, FieldPackageNextVersion, "", ""))
+
+			// Create the inserted package if it is different than a start/end package
+			var newPackage *Package
+			if !insertingStartPackage && !insertingEndPackage {
+				newPackage = &Package{
+					OS:      packageParameter.OS,
+					Name:    packageParameter.Name,
+					Version: packageParameter.Version,
+				}
+				newPackage.Node = newPackage.GetNode()
+				cachedPackagesByBranch[branch][newPackage.Key()] = newPackage
+
+				t.AddQuad(cayley.Quad(newPackage.Node, FieldIs, FieldPackageIsValue, ""))
+				t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageOS, newPackage.OS, ""))
+				t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageName, newPackage.Name, ""))
+				t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageVersion, newPackage.Version.String(), ""))
+				t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageNextVersion, endPackage.Node, ""))
+
+				packageParameter.Node = newPackage.Node
+			}
+
+			// Create and insert a start package
+			startPackage := &Package{
+				OS:      packageParameter.OS,
+				Name:    packageParameter.Name,
+				Version: types.MinVersion,
+			}
+			startPackage.Node = startPackage.GetNode()
+			cachedPackagesByBranch[branch][startPackage.Key()] = startPackage
+
+			t.AddQuad(cayley.Quad(startPackage.Node, FieldIs, FieldPackageIsValue, ""))
+			t.AddQuad(cayley.Quad(startPackage.Node, FieldPackageOS, startPackage.OS, ""))
+			t.AddQuad(cayley.Quad(startPackage.Node, FieldPackageName, startPackage.Name, ""))
+			t.AddQuad(cayley.Quad(startPackage.Node, FieldPackageVersion, startPackage.Version.String(), ""))
+			if !insertingStartPackage && !insertingEndPackage {
+				t.AddQuad(cayley.Quad(startPackage.Node, FieldPackageNextVersion, newPackage.Node, ""))
+			} else {
+				t.AddQuad(cayley.Quad(startPackage.Node, FieldPackageNextVersion, endPackage.Node, ""))
+			}
+
+			// Set package node
+			if insertingEndPackage {
+				packageParameter.Node = endPackage.Node
+			} else if insertingStartPackage {
+				packageParameter.Node = startPackage.Node
+			}
+		} else {
+			// The branch already exists
+
+			// Create the package
+			newPackage := &Package{OS: packageParameter.OS, Name: packageParameter.Name, Version: packageParameter.Version}
+			newPackage.Node = "package:" + utils.Hash(newPackage.Key())
+			cachedPackagesByBranch[branch][newPackage.Key()] = newPackage
+			packageParameter.Node = newPackage.Node
+
+			t.AddQuad(cayley.Quad(newPackage.Node, FieldIs, FieldPackageIsValue, ""))
+			t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageOS, newPackage.OS, ""))
+			t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageName, newPackage.Name, ""))
+			t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageVersion, newPackage.Version.String(), ""))
+
+			// Sort branchPackages by version (including the new package)
+			branchPackages = append(branchPackages, newPackage)
+			sort.Sort(ByVersion(branchPackages))
+
+			// Find my prec/succ GraphID in the sorted slice now
+			newPackageKey := newPackage.Key()
+			var pred, succ *Package
+			var found bool
+			for _, p := range branchPackages {
+				equal := p.Key() == newPackageKey
+				if !equal && !found {
+					pred = p
+				} else if found {
+					succ = p
+					break
+				} else if equal {
+					found = true
+					continue
+				}
+			}
+			if pred == nil || succ == nil {
+				log.Warningf("could not find any package predecessor/successor of: [OS: %s, Name: %s, Version: %s].", packageParameter.OS, packageParameter.Name, packageParameter.Version)
+				return cerrors.NewBadRequestError("could not find package predecessor/successor")
+			}
+
+			// Link the new packages with the branch
+			t.RemoveQuad(cayley.Quad(pred.Node, FieldPackageNextVersion, succ.Node, ""))
+
+			pred.NextVersionNode = newPackage.Node
+			t.AddQuad(cayley.Quad(pred.Node, FieldPackageNextVersion, newPackage.Node, ""))
+
+			newPackage.NextVersionNode = succ.Node
+			t.AddQuad(cayley.Quad(newPackage.Node, FieldPackageNextVersion, succ.Node, ""))
+		}
+
+		packagesInTransaction = packagesInTransaction + 1
+
+		// Apply transaction
+		if packagesInTransaction >= insertPackagesBatchSize {
+			if err := store.ApplyTransaction(t); err != nil {
+				log.Errorf("failed transaction (InsertPackages): %s", err)
+				return ErrTransaction
+			}
+
+			t = cayley.NewTransaction()
+			cachedPackagesByBranch = make(map[string]map[string]*Package)
+			packagesInTransaction = 0
+		}
+	}
+
+	// Apply transaction
+	if packagesInTransaction > 0 {
+		if err := store.ApplyTransaction(t); err != nil {
+			log.Errorf("failed transaction (InsertPackages): %s", err)
+			return ErrTransaction
+		}
+	}
+
+	// Return
+	return nil
+}
+
+// FindOnePackage finds and returns a single package having the given OS, name and version, selecting the specified fields
+func FindOnePackage(OS, name string, version types.Version, selectedFields []string) (*Package, error) {
+	packageParameter := Package{OS: OS, Name: name, Version: version}
+	p, err := toPackages(cayley.StartPath(store, packageParameter.GetNode()).Has(FieldIs, FieldPackageIsValue), selectedFields)
+
+	if err != nil {
+		return nil, err
+	}
+	if len(p) == 1 {
+		return p[0], nil
+	}
+	if len(p) > 1 {
+		log.Errorf("found multiple packages with identical data [OS: %s, Name: %s, Version: %s]", OS, name, version)
+		return nil, ErrInconsistent
+	}
+	return nil, cerrors.ErrNotFound
+}
+
+// FindAllPackagesByNodes finds and returns all packages given by their nodes, selecting the specified fields
+func FindAllPackagesByNodes(nodes []string, selectedFields []string) ([]*Package, error) {
+	if len(nodes) == 0 {
+		log.Warning("could not FindAllPackagesByNodes with an empty nodes array.")
+		return []*Package{}, nil
+	}
+
+	return toPackages(cayley.StartPath(store, nodes...).Has(FieldIs, FieldPackageIsValue), selectedFields)
+}
+
+// FindAllPackagesByBranch finds and returns all packages that belong to the given Branch, selecting the specified fields
+func FindAllPackagesByBranch(OS, name string, selectedFields []string) ([]*Package, error) {
+	return toPackages(cayley.StartPath(store, name).In(FieldPackageName).Has(FieldPackageOS, OS), selectedFields)
+}
+
+// toPackages converts a path leading to one or multiple packages to Package structs, selecting the specified fields
+func toPackages(path *path.Path, selectedFields []string) ([]*Package, error) {
+	var packages []*Package
+	var err error
+
+	saveFields(path, selectedFields, []string{FieldPackagePreviousVersion})
+	it, _ := path.BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		pkg := Package{Node: store.NameOf(it.Result())}
+		for _, selectedField := range selectedFields {
+			switch selectedField {
+			case FieldPackageOS:
+				pkg.OS = store.NameOf(tags[FieldPackageOS])
+			case FieldPackageName:
+				pkg.Name = store.NameOf(tags[FieldPackageName])
+			case FieldPackageVersion:
+				pkg.Version, err = types.NewVersion(store.NameOf(tags[FieldPackageVersion]))
+				if err != nil {
+					log.Warningf("could not parse version of package %s: %s", pkg.Node, err.Error())
+				}
+			case FieldPackageNextVersion:
+				pkg.NextVersionNode = store.NameOf(tags[FieldPackageNextVersion])
+			case FieldPackagePreviousVersion:
+				pkg.PreviousVersionNode, err = toValue(cayley.StartPath(store, pkg.Node).In(FieldPackageNextVersion))
+				if err != nil {
+					log.Warningf("could not get previousVersion on package %s: %s.", pkg.Node, err.Error())
+					return []*Package{}, ErrInconsistent
+				}
+			default:
+				panic("unknown selectedField")
+			}
+		}
+		packages = append(packages, &pkg)
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in toPackages: %s", it.Err())
+		return []*Package{}, ErrBackendException
+	}
+
+	return packages, nil
+}
+
+// NextVersion find and returns the package of the same branch that has a higher version number, selecting the specified fields
+// It requires that FieldPackageNextVersion field has been selected on p
+func (p *Package) NextVersion(selectedFields []string) (*Package, error) {
+	if p.NextVersionNode == "" {
+		return nil, nil
+	}
+
+	v, err := FindAllPackagesByNodes([]string{p.NextVersionNode}, selectedFields)
+	if err != nil {
+		return nil, err
+	}
+	if len(v) != 1 {
+		log.Errorf("found multiple packages when getting next version of package %s", p.Node)
+		return nil, ErrInconsistent
+	}
+	return v[0], nil
+}
+
+// NextVersions find and returns all the packages of the same branch that have
+// a higher version number, selecting the specified fields
+// It requires that FieldPackageNextVersion field has been selected on p
+// The immediate higher version is listed first, and the special end-of-Branch package is last, p is not listed
+func (p *Package) NextVersions(selectedFields []string) ([]*Package, error) {
+	var nextVersions []*Package
+
+	if !utils.Contains(FieldPackageNextVersion, selectedFields) {
+		selectedFields = append(selectedFields, FieldPackageNextVersion)
+	}
+
+	nextVersion, err := p.NextVersion(selectedFields)
+	if err != nil {
+		return []*Package{}, err
+	}
+	if nextVersion != nil {
+		nextVersions = append(nextVersions, nextVersion)
+
+		nextNextVersions, err := nextVersion.NextVersions(selectedFields)
+		if err != nil {
+			return []*Package{}, err
+		}
+		nextVersions = append(nextVersions, nextNextVersions...)
+	}
+
+	return nextVersions, nil
+}
+
+// PreviousVersion find and returns the package of the same branch that has an
+// immediate lower version number, selecting the specified fields
+// It requires that FieldPackagePreviousVersion field has been selected on p
+func (p *Package) PreviousVersion(selectedFields []string) (*Package, error) {
+	if p.PreviousVersionNode == "" {
+		return nil, nil
+	}
+
+	v, err := FindAllPackagesByNodes([]string{p.PreviousVersionNode}, selectedFields)
+	if err != nil {
+		return nil, err
+	}
+	if len(v) == 0 {
+		return nil, nil
+	}
+	if len(v) != 1 {
+		log.Errorf("found multiple packages when getting previous version of package %s", p.Node)
+		return nil, ErrInconsistent
+	}
+	return v[0], nil
+}
+
+// PreviousVersions find and returns all the packages of the same branch that
+// have a lower version number, selecting the specified fields
+// It requires that FieldPackageNextVersion field has been selected on p
+// The immediate lower version is listed first, and the special start-of-Branch
+// package is last, p is not listed
+func (p *Package) PreviousVersions(selectedFields []string) ([]*Package, error) {
+	var previousVersions []*Package
+
+	if !utils.Contains(FieldPackagePreviousVersion, selectedFields) {
+		selectedFields = append(selectedFields, FieldPackagePreviousVersion)
+	}
+
+	previousVersion, err := p.PreviousVersion(selectedFields)
+	if err != nil {
+		return []*Package{}, err
+	}
+	if previousVersion != nil {
+		previousVersions = append(previousVersions, previousVersion)
+
+		previousPreviousVersions, err := previousVersion.PreviousVersions(selectedFields)
+		if err != nil {
+			return []*Package{}, err
+		}
+		previousVersions = append(previousVersions, previousPreviousVersions...)
+	}
+
+	return previousVersions, nil
+}
+
+// ByVersion implements sort.Interface for []*Package based on the Version field
+// It uses github.com/quentin-m/dpkgcomp internally and makes use of types.MinVersion/types.MaxVersion
+type ByVersion []*Package
+
+func (p ByVersion) Len() int           { return len(p) }
+func (p ByVersion) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p ByVersion) Less(i, j int) bool { return p[i].Version.Compare(p[j].Version) < 0 }
diff --git a/database/package_test.go b/database/package_test.go
new file mode 100644
index 00000000..2ec74f1c
--- /dev/null
+++ b/database/package_test.go
@@ -0,0 +1,193 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"math/rand"
+	"sort"
+	"testing"
+	"time"
+
+	"github.com/coreos/clair/utils/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPackage(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	// Try to insert invalid packages
+	for _, invalidPkg := range []*Package{
+		&Package{OS: "", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")},
+		&Package{OS: "testOS", Name: "", Version: types.NewVersionUnsafe("1.0")},
+		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("")},
+		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("bad version")},
+		&Package{OS: "", Name: "", Version: types.NewVersionUnsafe("")},
+	} {
+		err := InsertPackages([]*Package{invalidPkg})
+		assert.Error(t, err)
+	}
+
+	// Insert a package
+	pkg1 := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}
+	err := InsertPackages([]*Package{pkg1})
+	if assert.Nil(t, err) {
+		// Find the inserted package and verify its content
+		pkg1b, err := FindOnePackage(pkg1.OS, pkg1.Name, pkg1.Version, FieldPackageAll)
+		if assert.Nil(t, err) && assert.NotNil(t, pkg1b) {
+			assert.Equal(t, pkg1.Node, pkg1b.Node)
+			assert.Equal(t, pkg1.OS, pkg1b.OS)
+			assert.Equal(t, pkg1.Name, pkg1b.Name)
+			assert.Equal(t, pkg1.Version, pkg1b.Version)
+		}
+
+		// Find packages from the inserted branch and verify their content
+		// (the first one should be a start package, the second one the inserted one and the third one the end package)
+		pkgs1c, err := FindAllPackagesByBranch(pkg1.OS, pkg1.Name, FieldPackageAll)
+		if assert.Nil(t, err) && assert.Equal(t, 3, len(pkgs1c)) {
+			sort.Sort(ByVersion(pkgs1c))
+
+			assert.Equal(t, pkg1.OS, pkgs1c[0].OS)
+			assert.Equal(t, pkg1.Name, pkgs1c[0].Name)
+			assert.Equal(t, types.MinVersion, pkgs1c[0].Version)
+
+			assert.Equal(t, pkg1.OS, pkgs1c[1].OS)
+			assert.Equal(t, pkg1.Name, pkgs1c[1].Name)
+			assert.Equal(t, pkg1.Version, pkgs1c[1].Version)
+
+			assert.Equal(t, pkg1.OS, pkgs1c[2].OS)
+			assert.Equal(t, pkg1.Name, pkgs1c[2].Name)
+			assert.Equal(t, types.MaxVersion, pkgs1c[2].Version)
+		}
+	}
+
+	// Insert multiple packages in the same branch, one in another branch, insert local duplicates and database duplicates as well
+	pkg2 := []*Package{
+		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("0.8")},
+		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("0.9")},
+		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}, // Already present in the database
+		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.1")},
+		&Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}, // Another branch
+		&Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}, // Local duplicates
+	}
+	nbInSameBranch := 4 + 2 // (start/end packages)
+
+	err = InsertPackages(shuffle(pkg2))
+	if assert.Nil(t, err) {
+		// Find packages from the inserted branch, verify their order and NextVersion / PreviousVersion
+		pkgs2b, err := FindAllPackagesByBranch("testOS", "testpkg1", FieldPackageAll)
+		if assert.Nil(t, err) && assert.Equal(t, nbInSameBranch, len(pkgs2b)) {
+			sort.Sort(ByVersion(pkgs2b))
+
+			for i := 0; i < nbInSameBranch; i = i + 1 {
+				if i == 0 {
+					assert.Equal(t, types.MinVersion, pkgs2b[0].Version)
+				} else if i < nbInSameBranch-2 {
+					assert.Equal(t, pkg2[i].Version, pkgs2b[i+1].Version)
+
+					nv, err := pkgs2b[i+1].NextVersion(FieldPackageAll)
+					assert.Nil(t, err)
+					assert.Equal(t, pkgs2b[i+2], nv)
+
+					if i > 0 {
+						pv, err := pkgs2b[i].PreviousVersion(FieldPackageAll)
+						assert.Nil(t, err)
+						assert.Equal(t, pkgs2b[i-1], pv)
+					} else {
+						pv, err := pkgs2b[i].PreviousVersion(FieldPackageAll)
+						assert.Nil(t, err)
+						assert.Nil(t, pv)
+					}
+				} else {
+					assert.Equal(t, types.MaxVersion, pkgs2b[nbInSameBranch-1].Version)
+
+					nv, err := pkgs2b[nbInSameBranch-1].NextVersion(FieldPackageAll)
+					assert.Nil(t, err)
+					assert.Nil(t, nv)
+
+					pv, err := pkgs2b[i].PreviousVersion(FieldPackageAll)
+					assert.Nil(t, err)
+					assert.Equal(t, pkgs2b[i-1], pv)
+				}
+			}
+
+			// NextVersions
+			nv, err := pkgs2b[0].NextVersions(FieldPackageAll)
+			if assert.Nil(t, err) && assert.Len(t, nv, nbInSameBranch-1) {
+				for i := 0; i < nbInSameBranch-1; i = i + 1 {
+					if i < nbInSameBranch-2 {
+						assert.Equal(t, pkg2[i].Version, nv[i].Version)
+					} else {
+						assert.Equal(t, types.MaxVersion, nv[i].Version)
+					}
+				}
+			}
+
+			// PreviousVersions
+			pv, err := pkgs2b[nbInSameBranch-1].PreviousVersions(FieldPackageAll)
+			if assert.Nil(t, err) && assert.Len(t, pv, nbInSameBranch-1) {
+				for i := 0; i < len(pv); i = i + 1 {
+					assert.Equal(t, pkgs2b[len(pkgs2b)-i-2], pv[i])
+				}
+			}
+		}
+
+		// Verify that the one we added which was already present in the database has the same node value (meaning that we just fetched it actually)
+		assert.Contains(t, pkg2, pkg1)
+	}
+
+	// Insert duplicated latest packages directly, ensure only one is actually inserted. Then insert another package in the branch and ensure that its next version is the latest one
+	pkg3a := &Package{OS: "testOS", Name: "testpkg3", Version: types.MaxVersion}
+	pkg3b := &Package{OS: "testOS", Name: "testpkg3", Version: types.MaxVersion}
+	pkg3c := &Package{OS: "testOS", Name: "testpkg3", Version: types.MaxVersion}
+	err1 := InsertPackages([]*Package{pkg3a, pkg3b})
+	err2 := InsertPackages([]*Package{pkg3c})
+	if assert.Nil(t, err1) && assert.Nil(t, err2) {
+		assert.Equal(t, pkg3a, pkg3b)
+		assert.Equal(t, pkg3b, pkg3c)
+	}
+	pkg4 := Package{OS: "testOS", Name: "testpkg3", Version: types.NewVersionUnsafe("1.0")}
+	InsertPackages([]*Package{&pkg4})
+	pkgs34, _ := FindAllPackagesByBranch("testOS", "testpkg3", FieldPackageAll)
+	if assert.Len(t, pkgs34, 3) {
+		sort.Sort(ByVersion(pkgs34))
+		assert.Equal(t, pkg4.Node, pkgs34[1].Node)
+		assert.Equal(t, pkg3a.Node, pkgs34[2].Node)
+		assert.Equal(t, pkg3a.Node, pkgs34[1].NextVersionNode)
+	}
+
+	// Insert two identical packages but with "different" versions
+	// The second version should be simplified to the first one
+	// Therefore, we should just have three packages (the inserted one and the start/end packages of the branch)
+	InsertPackages([]*Package{&Package{OS: "testOS", Name: "testdirtypkg", Version: types.NewVersionUnsafe("0.1")}})
+	InsertPackages([]*Package{&Package{OS: "testOS", Name: "testdirtypkg", Version: types.NewVersionUnsafe("0:0.1")}})
+	dirtypkgs, err := FindAllPackagesByBranch("testOS", "testdirtypkg", FieldPackageAll)
+	assert.Nil(t, err)
+	assert.Len(t, dirtypkgs, 3)
+}
+
+func shuffle(packageParameters []*Package) []*Package {
+	rand.Seed(int64(time.Now().Nanosecond()))
+
+	sPackage := make([]*Package, len(packageParameters))
+	copy(sPackage, packageParameters)
+
+	for i := len(sPackage) - 1; i > 0; i-- {
+		j := rand.Intn(i)
+		sPackage[i], sPackage[j] = sPackage[j], sPackage[i]
+	}
+
+	return sPackage
+}
diff --git a/database/requests.go b/database/requests.go
new file mode 100644
index 00000000..57f2bd95
--- /dev/null
+++ b/database/requests.go
@@ -0,0 +1,51 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import cerrors "github.com/coreos/clair/utils/errors"
+
+// FindAllLayersIntroducingVulnerability finds and returns the list of layers
+// that introduce the given vulnerability (by its ID), selecting the specified fields
+func FindAllLayersIntroducingVulnerability(vulnerabilityID string, selectedFields []string) ([]*Layer, error) {
+	// Find vulnerability
+	vulnerability, err := FindOneVulnerability(vulnerabilityID, []string{FieldVulnerabilityFixedIn})
+	if err != nil {
+		return []*Layer{}, err
+	}
+	if vulnerability == nil {
+		return []*Layer{}, cerrors.ErrNotFound
+	}
+
+	// Find FixedIn packages
+	fixedInPackages, err := FindAllPackagesByNodes(vulnerability.FixedInNodes, []string{FieldPackagePreviousVersion})
+	if err != nil {
+		return []*Layer{}, err
+	}
+
+	// Find all FixedIn packages's ancestors packages (which are therefore vulnerable to the vulnerability)
+	var vulnerablePackagesNodes []string
+	for _, pkg := range fixedInPackages {
+		previousVersions, err := pkg.PreviousVersions([]string{})
+		if err != nil {
+			return []*Layer{}, err
+		}
+		for _, version := range previousVersions {
+			vulnerablePackagesNodes = append(vulnerablePackagesNodes, version.Node)
+		}
+	}
+
+	// Return all the layers that add these packages
+	return FindAllLayersByAddedPackageNodes(vulnerablePackagesNodes, selectedFields)
+}
diff --git a/database/vulnerability.go b/database/vulnerability.go
new file mode 100644
index 00000000..c8f7ae55
--- /dev/null
+++ b/database/vulnerability.go
@@ -0,0 +1,387 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"github.com/coreos/clair/utils"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils/types"
+	"github.com/google/cayley"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/path"
+)
+
+const (
+	FieldVulnerabilityIsValue     = "vulnerability"
+	FieldVulnerabilityID          = "id"
+	FieldVulnerabilityLink        = "link"
+	FieldVulnerabilityPriority    = "priority"
+	FieldVulnerabilityDescription = "description"
+	FieldVulnerabilityFixedIn     = "fixedIn"
+)
+
+var FieldVulnerabilityAll = []string{FieldVulnerabilityID, FieldVulnerabilityLink, FieldVulnerabilityPriority, FieldVulnerabilityDescription, FieldVulnerabilityFixedIn}
+
+// Vulnerability represents a vulnerability that is fixed in some Packages
+type Vulnerability struct {
+	Node         string `json:"-"`
+	ID           string
+	Link         string
+	Priority     types.Priority
+	Description  string   `json:",omitempty"`
+	FixedInNodes []string `json:"-"`
+}
+
+// GetNode returns an unique identifier for the graph node
+// Requires the key field: ID
+func (v *Vulnerability) GetNode() string {
+	return FieldVulnerabilityIsValue + ":" + utils.Hash(v.ID)
+}
+
+// ToAbstractVulnerability converts a Vulnerability into an
+// AbstractVulnerability.
+func (v *Vulnerability) ToAbstractVulnerability() (*AbstractVulnerability, error) {
+	// Find FixedIn packages.
+	fixedInPackages, err := FindAllPackagesByNodes(v.FixedInNodes, []string{FieldPackageOS, FieldPackageName, FieldPackageVersion})
+	if err != nil {
+		return nil, err
+	}
+
+	return &AbstractVulnerability{
+		ID:               v.ID,
+		Link:             v.Link,
+		Priority:         v.Priority,
+		Description:      v.Description,
+		AffectedPackages: PackagesToAbstractPackages(fixedInPackages),
+	}, nil
+}
+
+// AbstractVulnerability represents a Vulnerability as it is defined in the database
+// package but exposes directly a list of AbstractPackage instead of
+// nodes to packages.
+type AbstractVulnerability struct {
+	ID               string
+	Link             string
+	Priority         types.Priority
+	Description      string
+	AffectedPackages []*AbstractPackage
+}
+
+// ToVulnerability converts an abstractVulnerability into
+// a Vulnerability
+func (av *AbstractVulnerability) ToVulnerability(fixedInNodes []string) *Vulnerability {
+	return &Vulnerability{
+		ID:           av.ID,
+		Link:         av.Link,
+		Priority:     av.Priority,
+		Description:  av.Description,
+		FixedInNodes: fixedInNodes,
+	}
+}
+
+// InsertVulnerabilities inserts or updates several vulnerabilities in the database in one transaction
+// It ensures that a vulnerability can't be fixed by two packages belonging the same Branch.
+// During an update, if the vulnerability was previously fixed by a version in a branch and a new package of that branch is specified, the previous one is deleted
+// Otherwise, it simply adds the defined packages, there is currently no way to delete affected packages.
+//
+// ID, Link, Priority and FixedInNodes fields have to be specified. Description is optionnal.
+func InsertVulnerabilities(vulnerabilities []*Vulnerability) ([]Notification, error) {
+	if len(vulnerabilities) == 0 {
+		return []Notification{}, nil
+	}
+
+	// Create required data structure
+	var err error
+	t := cayley.NewTransaction()
+	cachedVulnerabilities := make(map[string]*Vulnerability)
+	newVulnerabilityNotifications := make(map[string]*NewVulnerabilityNotification)
+	vulnerabilityPriorityIncreasedNotifications := make(map[string]*VulnerabilityPriorityIncreasedNotification)
+	vulnerabilityPackageChangedNotifications := make(map[string]*VulnerabilityPackageChangedNotification)
+
+	// Iterate over all the vulnerabilities we need to insert/update
+	for _, vulnerability := range vulnerabilities {
+		// Is the vulnerability already existing ?
+		existingVulnerability, _ := cachedVulnerabilities[vulnerability.ID]
+		if existingVulnerability == nil {
+			existingVulnerability, err = FindOneVulnerability(vulnerability.ID, FieldVulnerabilityAll)
+			if err != nil && err != cerrors.ErrNotFound {
+				return []Notification{}, err
+			}
+			if existingVulnerability != nil {
+				cachedVulnerabilities[vulnerability.ID] = existingVulnerability
+			}
+		}
+
+		// Don't allow inserting/updating a vulnerability which is fixed in two packages of the same branch
+		if len(vulnerability.FixedInNodes) > 0 {
+			fixedInPackages, err := FindAllPackagesByNodes(vulnerability.FixedInNodes, []string{FieldPackageOS, FieldPackageName})
+			if err != nil {
+				return []Notification{}, err
+			}
+			fixedInBranches := make(map[string]struct{})
+			for _, fixedInPackage := range fixedInPackages {
+				branch := fixedInPackage.Branch()
+				if _, branchExists := fixedInBranches[branch]; branchExists {
+					log.Warningf("could not insert vulnerability %s because it is fixed in two packages of the same branch", vulnerability.ID)
+					return []Notification{}, cerrors.NewBadRequestError("could not insert a vulnerability which is fixed in two packages of the same branch")
+				}
+				fixedInBranches[branch] = struct{}{}
+			}
+		}
+
+		// Insert/Update vulnerability
+		if existingVulnerability == nil {
+			// The vulnerability does not exist, create it
+
+			// Verify parameters
+			if vulnerability.ID == "" || vulnerability.Link == "" || vulnerability.Priority == "" {
+				log.Warningf("could not insert an incomplete vulnerability [ID: %s, Link: %s, Priority: %s]", vulnerability.ID, vulnerability.Link, vulnerability.Priority)
+				return []Notification{}, cerrors.NewBadRequestError("Could not insert an incomplete vulnerability")
+			}
+			if !vulnerability.Priority.IsValid() {
+				log.Warningf("could not insert a vulnerability which has an invalid priority [ID: %s, Link: %s, Priority: %s]. Valid priorities are: %v.", vulnerability.ID, vulnerability.Link, vulnerability.Priority, types.Priorities)
+				return []Notification{}, cerrors.NewBadRequestError("Could not insert a vulnerability which has an invalid priority")
+			}
+			if len(vulnerability.FixedInNodes) == 0 {
+				log.Warningf("could not insert a vulnerability which doesn't affect any package [ID: %s].", vulnerability.ID)
+				return []Notification{}, cerrors.NewBadRequestError("could not insert a vulnerability which doesn't affect any package")
+			}
+
+			// Insert it
+			vulnerability.Node = vulnerability.GetNode()
+			cachedVulnerabilities[vulnerability.ID] = vulnerability
+
+			t.AddQuad(cayley.Quad(vulnerability.Node, FieldIs, FieldVulnerabilityIsValue, ""))
+			t.AddQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityID, vulnerability.ID, ""))
+			t.AddQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityLink, vulnerability.Link, ""))
+			t.AddQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityPriority, string(vulnerability.Priority), ""))
+			t.AddQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityDescription, vulnerability.Description, ""))
+			for _, p := range vulnerability.FixedInNodes {
+				t.AddQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityFixedIn, p, ""))
+			}
+
+			// Add a notification
+			newVulnerabilityNotifications[vulnerability.ID] = &NewVulnerabilityNotification{VulnerabilityID: vulnerability.ID}
+		} else {
+			// The vulnerability already exists, update it
+			if vulnerability.Link != "" && existingVulnerability.Link != vulnerability.Link {
+				t.RemoveQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityLink, existingVulnerability.Link, ""))
+				t.AddQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityLink, vulnerability.Link, ""))
+				existingVulnerability.Link = vulnerability.Link
+			}
+			if vulnerability.Priority != "" && vulnerability.Priority != types.Unknown && existingVulnerability.Priority != vulnerability.Priority {
+				if !vulnerability.Priority.IsValid() {
+					log.Warningf("could not update a vulnerability which has an invalid priority [ID: %s, Link: %s, Priority: %s]. Valid priorities are: %v.", vulnerability.ID, vulnerability.Link, vulnerability.Priority, types.Priorities)
+					return []Notification{}, cerrors.NewBadRequestError("Could not update a vulnerability which has an invalid priority")
+				}
+
+				// Add a notification about the priority change if the new priority is higher and the vulnerability is not new
+				if vulnerability.Priority.Compare(existingVulnerability.Priority) > 0 {
+					if _, newVulnerabilityNotificationExists := newVulnerabilityNotifications[vulnerability.ID]; !newVulnerabilityNotificationExists {
+						// Any priorityChangeNotification already ?
+						if existingPriorityNotification, _ := vulnerabilityPriorityIncreasedNotifications[vulnerability.ID]; existingPriorityNotification != nil {
+							// There is a priority change notification, replace it but keep the old priority field
+							vulnerabilityPriorityIncreasedNotifications[vulnerability.ID] = &VulnerabilityPriorityIncreasedNotification{OldPriority: existingPriorityNotification.OldPriority, NewPriority: vulnerability.Priority, VulnerabilityID: existingVulnerability.ID}
+						} else {
+							// No previous notification, just add a new one
+							vulnerabilityPriorityIncreasedNotifications[vulnerability.ID] = &VulnerabilityPriorityIncreasedNotification{OldPriority: existingVulnerability.Priority, NewPriority: vulnerability.Priority, VulnerabilityID: existingVulnerability.ID}
+						}
+					}
+				}
+
+				t.RemoveQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityPriority, string(existingVulnerability.Priority), ""))
+				t.AddQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityPriority, string(vulnerability.Priority), ""))
+				existingVulnerability.Priority = vulnerability.Priority
+			}
+			if vulnerability.Description != "" && existingVulnerability.Description != vulnerability.Description {
+				t.RemoveQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityDescription, existingVulnerability.Description, ""))
+				t.AddQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityDescription, vulnerability.Description, ""))
+				existingVulnerability.Description = vulnerability.Description
+			}
+			if len(vulnerability.FixedInNodes) > 0 && len(utils.CompareStringLists(vulnerability.FixedInNodes, existingVulnerability.FixedInNodes)) != 0 {
+				var removedNodes []string
+				var addedNodes []string
+
+				existingVulnerabilityFixedInPackages, err := FindAllPackagesByNodes(existingVulnerability.FixedInNodes, []string{FieldPackageOS, FieldPackageName, FieldPackageVersion})
+				if err != nil {
+					return []Notification{}, err
+				}
+				vulnerabilityFixedInPackages, err := FindAllPackagesByNodes(vulnerability.FixedInNodes, []string{FieldPackageOS, FieldPackageName, FieldPackageVersion})
+				if err != nil {
+					return []Notification{}, err
+				}
+
+				for _, p := range vulnerabilityFixedInPackages {
+					// Any already existing link ?
+					fixedInLinkAlreadyExists := false
+					for _, ep := range existingVulnerabilityFixedInPackages {
+						if *p == *ep {
+							// This exact link already exists, we won't insert it again
+							fixedInLinkAlreadyExists = true
+						} else if p.Branch() == ep.Branch() {
+							// A link to this package branch already exist and is not the same version, we will delete it
+							t.RemoveQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityFixedIn, ep.Node, ""))
+
+							var index int
+							for i, n := range existingVulnerability.FixedInNodes {
+								if n == ep.Node {
+									index = i
+									break
+								}
+							}
+							existingVulnerability.FixedInNodes = append(existingVulnerability.FixedInNodes[index:], existingVulnerability.FixedInNodes[index+1:]...)
+							removedNodes = append(removedNodes, ep.Node)
+						}
+					}
+
+					if fixedInLinkAlreadyExists == false {
+						t.AddQuad(cayley.Quad(existingVulnerability.Node, FieldVulnerabilityFixedIn, p.Node, ""))
+						existingVulnerability.FixedInNodes = append(existingVulnerability.FixedInNodes, p.Node)
+						addedNodes = append(addedNodes, p.Node)
+					}
+				}
+
+				// Add notification about the FixedIn modification if the vulnerability is not new
+				if len(removedNodes) > 0 || len(addedNodes) > 0 {
+					if _, newVulnerabilityNotificationExists := newVulnerabilityNotifications[vulnerability.ID]; !newVulnerabilityNotificationExists {
+						// Any VulnerabilityPackageChangedNotification already ?
+						if existingPackageNotification, _ := vulnerabilityPackageChangedNotifications[vulnerability.ID]; existingPackageNotification != nil {
+							// There is a priority change notification, add the packages modifications to it
+							existingPackageNotification.AddedFixedInNodes = append(existingPackageNotification.AddedFixedInNodes, addedNodes...)
+							existingPackageNotification.RemovedFixedInNodes = append(existingPackageNotification.RemovedFixedInNodes, removedNodes...)
+						} else {
+							// No previous notification, just add a new one
+							vulnerabilityPackageChangedNotifications[vulnerability.ID] = &VulnerabilityPackageChangedNotification{VulnerabilityID: vulnerability.ID, AddedFixedInNodes: addedNodes, RemovedFixedInNodes: removedNodes}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Apply transaction
+	if err = store.ApplyTransaction(t); err != nil {
+		log.Errorf("failed transaction (InsertVulnerabilities): %s", err)
+		return []Notification{}, ErrTransaction
+	}
+
+	// Group all notifications
+	var allNotifications []Notification
+	for _, notification := range newVulnerabilityNotifications {
+		allNotifications = append(allNotifications, notification)
+	}
+	for _, notification := range vulnerabilityPriorityIncreasedNotifications {
+		allNotifications = append(allNotifications, notification)
+	}
+	for _, notification := range vulnerabilityPackageChangedNotifications {
+		allNotifications = append(allNotifications, notification)
+	}
+
+	return allNotifications, nil
+}
+
+// DeleteVulnerability deletes the vulnerability having the given ID
+func DeleteVulnerability(id string) error {
+	vulnerability, err := FindOneVulnerability(id, FieldVulnerabilityAll)
+	if err != nil {
+		return err
+	}
+
+	t := cayley.NewTransaction()
+	t.RemoveQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityID, vulnerability.ID, ""))
+	t.RemoveQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityLink, vulnerability.Link, ""))
+	t.RemoveQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityPriority, string(vulnerability.Priority), ""))
+	t.RemoveQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityDescription, vulnerability.Description, ""))
+	for _, p := range vulnerability.FixedInNodes {
+		t.RemoveQuad(cayley.Quad(vulnerability.Node, FieldVulnerabilityFixedIn, p, ""))
+	}
+
+	if err := store.ApplyTransaction(t); err != nil {
+		log.Errorf("failed transaction (DeleteVulnerability): %s", err)
+		return ErrTransaction
+	}
+
+	return nil
+}
+
+// FindOneVulnerability finds and returns a single vulnerability having the given ID selecting the specified fields
+func FindOneVulnerability(id string, selectedFields []string) (*Vulnerability, error) {
+	t := &Vulnerability{ID: id}
+	v, err := toVulnerabilities(cayley.StartPath(store, t.GetNode()).Has(FieldIs, FieldVulnerabilityIsValue), selectedFields)
+
+	if err != nil {
+		return nil, err
+	}
+	if len(v) == 1 {
+		return v[0], nil
+	}
+	if len(v) > 1 {
+		log.Errorf("found multiple vulnerabilities with identical ID [ID: %s]", id)
+		return nil, ErrInconsistent
+	}
+	return nil, cerrors.ErrNotFound
+}
+
+// FindAllVulnerabilitiesByFixedIn finds and returns all vulnerabilities that are fixed in the given packages (speficied by their nodes), selecting the specified fields
+func FindAllVulnerabilitiesByFixedIn(nodes []string, selectedFields []string) ([]*Vulnerability, error) {
+	if len(nodes) == 0 {
+		log.Warning("Could not FindAllVulnerabilitiesByFixedIn with an empty nodes array.")
+		return []*Vulnerability{}, nil
+	}
+	return toVulnerabilities(cayley.StartPath(store, nodes...).In(FieldVulnerabilityFixedIn), selectedFields)
+}
+
+// toVulnerabilities converts a path leading to one or multiple vulnerabilities to Vulnerability structs, selecting the specified fields
+func toVulnerabilities(path *path.Path, selectedFields []string) ([]*Vulnerability, error) {
+	var vulnerabilities []*Vulnerability
+
+	saveFields(path, selectedFields, []string{FieldVulnerabilityFixedIn})
+	it, _ := path.BuildIterator().Optimize()
+	defer it.Close()
+	for cayley.RawNext(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+
+		vulnerability := Vulnerability{Node: store.NameOf(it.Result())}
+		for _, selectedField := range selectedFields {
+			switch selectedField {
+			case FieldVulnerabilityID:
+				vulnerability.ID = store.NameOf(tags[FieldVulnerabilityID])
+			case FieldVulnerabilityLink:
+				vulnerability.Link = store.NameOf(tags[FieldVulnerabilityLink])
+			case FieldVulnerabilityPriority:
+				vulnerability.Priority = types.Priority(store.NameOf(tags[FieldVulnerabilityPriority]))
+			case FieldVulnerabilityDescription:
+				vulnerability.Description = store.NameOf(tags[FieldVulnerabilityDescription])
+			case FieldVulnerabilityFixedIn:
+				var err error
+				vulnerability.FixedInNodes, err = toValues(cayley.StartPath(store, vulnerability.Node).Out(FieldVulnerabilityFixedIn))
+				if err != nil {
+					log.Errorf("could not get fixedIn on vulnerability %s: %s.", vulnerability.Node, err.Error())
+					return []*Vulnerability{}, err
+				}
+			default:
+				panic("unknown selectedField")
+			}
+		}
+		vulnerabilities = append(vulnerabilities, &vulnerability)
+	}
+	if it.Err() != nil {
+		log.Errorf("failed query in toVulnerabilities: %s", it.Err())
+		return []*Vulnerability{}, ErrBackendException
+	}
+
+	return vulnerabilities, nil
+}
diff --git a/database/vulnerability_test.go b/database/vulnerability_test.go
new file mode 100644
index 00000000..18dfa4c2
--- /dev/null
+++ b/database/vulnerability_test.go
@@ -0,0 +1,243 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package database
+
+import (
+	"testing"
+
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestVulnerability(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	// Insert invalid vulnerabilities
+	for _, vulnerability := range []Vulnerability{
+		Vulnerability{ID: "", Link: "link1", Priority: types.Medium, FixedInNodes: []string{"pkg1"}},
+		Vulnerability{ID: "test1", Link: "", Priority: types.Medium, FixedInNodes: []string{"pkg1"}},
+		Vulnerability{ID: "test1", Link: "link1", Priority: "InvalidPriority", FixedInNodes: []string{"pkg1"}},
+		Vulnerability{ID: "test1", Link: "link1", Priority: types.Medium, FixedInNodes: []string{}},
+	} {
+		_, err := InsertVulnerabilities([]*Vulnerability{&vulnerability})
+		assert.Error(t, err)
+	}
+
+	// Some data
+	vuln1 := &Vulnerability{ID: "test1", Link: "link1", Priority: types.Medium, Description: "testDescription1", FixedInNodes: []string{"pkg1"}}
+	vuln2 := &Vulnerability{ID: "test2", Link: "link2", Priority: types.High, Description: "testDescription2", FixedInNodes: []string{"pkg1", "pkg2"}}
+	vuln3 := &Vulnerability{ID: "test3", Link: "link3", Priority: types.High, FixedInNodes: []string{"pkg3"}} // Empty description
+
+	// Insert some vulnerabilities
+	_, err := InsertVulnerabilities([]*Vulnerability{vuln1, vuln2, vuln3})
+	if assert.Nil(t, err) {
+		// Find one of the vulnerabilities we just inserted and verify its content
+		v1, err := FindOneVulnerability(vuln1.ID, FieldVulnerabilityAll)
+		if assert.Nil(t, err) && assert.NotNil(t, v1) {
+			assert.Equal(t, vuln1.ID, v1.ID)
+			assert.Equal(t, vuln1.Link, v1.Link)
+			assert.Equal(t, vuln1.Priority, v1.Priority)
+			assert.Equal(t, vuln1.Description, v1.Description)
+			if assert.Len(t, v1.FixedInNodes, 1) {
+				assert.Equal(t, vuln1.FixedInNodes[0], v1.FixedInNodes[0])
+			}
+		}
+
+		// Ensure that vulnerabilities with empty descriptions work as well
+		v3, err := FindOneVulnerability(vuln3.ID, FieldVulnerabilityAll)
+		if assert.Nil(t, err) && assert.NotNil(t, v3) {
+			assert.Equal(t, vuln3.Description, v3.Description)
+		}
+
+		// Find vulnerabilities by fixed packages
+		vulnsFixedInPkg1AndPkg3, err := FindAllVulnerabilitiesByFixedIn([]string{"pkg2", "pkg3"}, FieldVulnerabilityAll)
+		assert.Nil(t, err)
+		assert.Len(t, vulnsFixedInPkg1AndPkg3, 2)
+
+		// Delete vulnerability
+		if assert.Nil(t, DeleteVulnerability(vuln1.ID)) {
+			v1, err := FindOneVulnerability(vuln1.ID, FieldVulnerabilityAll)
+			assert.Equal(t, cerrors.ErrNotFound, err)
+			assert.Nil(t, v1)
+		}
+	}
+
+	// Update a vulnerability and verify its new content
+	pkg1 := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}
+	InsertPackages([]*Package{pkg1})
+	vuln5 := &Vulnerability{ID: "test5", Link: "link5", Priority: types.Medium, Description: "testDescription5", FixedInNodes: []string{pkg1.Node}}
+
+	_, err = InsertVulnerabilities([]*Vulnerability{vuln5})
+	if assert.Nil(t, err) {
+		// Partial updates
+		// # Just a field update
+		vuln5b := &Vulnerability{ID: "test5", Priority: types.High}
+		_, err := InsertVulnerabilities([]*Vulnerability{vuln5b})
+		if assert.Nil(t, err) {
+			v5b, err := FindOneVulnerability(vuln5b.ID, FieldVulnerabilityAll)
+			if assert.Nil(t, err) && assert.NotNil(t, v5b) {
+				assert.Equal(t, vuln5b.ID, v5b.ID)
+				assert.Equal(t, vuln5b.Priority, v5b.Priority)
+
+				if assert.Len(t, v5b.FixedInNodes, 1) {
+					assert.Contains(t, v5b.FixedInNodes, pkg1.Node)
+				}
+			}
+		}
+
+		// # Just a field update, twice in the same transaction
+		vuln5b1 := &Vulnerability{ID: "test5", Link: "http://foo.bar"}
+		vuln5b2 := &Vulnerability{ID: "test5", Link: "http://bar.foo"}
+		_, err = InsertVulnerabilities([]*Vulnerability{vuln5b1, vuln5b2})
+		if assert.Nil(t, err) {
+			v5b2, err := FindOneVulnerability(vuln5b2.ID, FieldVulnerabilityAll)
+			if assert.Nil(t, err) && assert.NotNil(t, v5b2) {
+				assert.Equal(t, vuln5b2.Link, v5b2.Link)
+			}
+		}
+
+		// # All fields except fixedIn update
+		vuln5c := &Vulnerability{ID: "test5", Link: "link5c", Priority: types.Critical, Description: "testDescription5c"}
+		_, err = InsertVulnerabilities([]*Vulnerability{vuln5c})
+		if assert.Nil(t, err) {
+			v5c, err := FindOneVulnerability(vuln5c.ID, FieldVulnerabilityAll)
+			if assert.Nil(t, err) && assert.NotNil(t, v5c) {
+				assert.Equal(t, vuln5c.ID, v5c.ID)
+				assert.Equal(t, vuln5c.Link, v5c.Link)
+				assert.Equal(t, vuln5c.Priority, v5c.Priority)
+				assert.Equal(t, vuln5c.Description, v5c.Description)
+
+				if assert.Len(t, v5c.FixedInNodes, 1) {
+					assert.Contains(t, v5c.FixedInNodes, pkg1.Node)
+				}
+			}
+		}
+
+		// Complete update
+		pkg2 := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.1")}
+		pkg3 := &Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}
+		InsertPackages([]*Package{pkg2, pkg3})
+		vuln5d := &Vulnerability{ID: "test5", Link: "link5d", Priority: types.Low, Description: "testDescription5d", FixedInNodes: []string{pkg2.Node, pkg3.Node}}
+
+		_, err = InsertVulnerabilities([]*Vulnerability{vuln5d})
+		if assert.Nil(t, err) {
+			v5d, err := FindOneVulnerability(vuln5d.ID, FieldVulnerabilityAll)
+			if assert.Nil(t, err) && assert.NotNil(t, v5d) {
+				assert.Equal(t, vuln5d.ID, v5d.ID)
+				assert.Equal(t, vuln5d.Link, v5d.Link)
+				assert.Equal(t, vuln5d.Priority, v5d.Priority)
+				assert.Equal(t, vuln5d.Description, v5d.Description)
+
+				// Here, we ensure that a vulnerability can only be fixed by one package of a given branch at a given time
+				// And that we can add new fixed packages as well
+				if assert.Len(t, v5d.FixedInNodes, 2) {
+					assert.NotContains(t, v5d.FixedInNodes, pkg1.Node)
+				}
+			}
+		}
+	}
+
+	// Create and update a vulnerability's packages (and from the same branch) in the same batch
+	pkg1 = &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}
+	pkg1b := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.1")}
+	InsertPackages([]*Package{pkg1, pkg1b})
+	// # A vulnerability can't be inserted if fixed by two packages of the same branch
+	_, err = InsertVulnerabilities([]*Vulnerability{&Vulnerability{ID: "test6", Link: "link6", Priority: types.Medium, Description: "testDescription6", FixedInNodes: []string{pkg1.Node, pkg1b.Node}}})
+	assert.Error(t, err)
+	// # Two updates of the same vulnerability in the same batch with packages of the same branch
+	pkg0 := &Package{OS: "testOS", Name: "testpkg0", Version: types.NewVersionUnsafe("1.0")}
+	InsertPackages([]*Package{pkg0})
+	_, err = InsertVulnerabilities([]*Vulnerability{&Vulnerability{ID: "test7", Link: "link7", Priority: types.Medium, Description: "testDescription7", FixedInNodes: []string{pkg0.Node}}})
+	if assert.Nil(t, err) {
+		vuln7b := &Vulnerability{ID: "test7", FixedInNodes: []string{pkg1.Node}}
+		vuln7c := &Vulnerability{ID: "test7", FixedInNodes: []string{pkg1b.Node}}
+		_, err = InsertVulnerabilities([]*Vulnerability{vuln7b, vuln7c})
+		if assert.Nil(t, err) {
+			v7, err := FindOneVulnerability("test7", FieldVulnerabilityAll)
+			if assert.Nil(t, err) && assert.Len(t, v7.FixedInNodes, 2) {
+				assert.Contains(t, v7.FixedInNodes, pkg0.Node)
+				assert.NotContains(t, v7.FixedInNodes, pkg1.Node)
+				assert.Contains(t, v7.FixedInNodes, pkg1b.Node)
+			}
+
+			// # A vulnerability can't be updated if fixed by two packages of the same branch
+			_, err = InsertVulnerabilities([]*Vulnerability{&Vulnerability{ID: "test7", FixedInNodes: []string{pkg1.Node, pkg1b.Node}}})
+			assert.Error(t, err)
+		}
+	}
+}
+
+func TestInsertVulnerabilityNotifications(t *testing.T) {
+	Open("memstore", "")
+	defer Close()
+
+	pkg1 := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}
+	pkg1b := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.2")}
+	pkg2 := &Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}
+	InsertPackages([]*Package{pkg1, pkg1b, pkg2})
+
+	// NewVulnerabilityNotification
+	vuln1 := &Vulnerability{ID: "test1", Link: "link1", Priority: types.Medium, Description: "testDescription1", FixedInNodes: []string{pkg1.Node}}
+	vuln2 := &Vulnerability{ID: "test2", Link: "link2", Priority: types.High, Description: "testDescription2", FixedInNodes: []string{pkg1.Node, pkg2.Node}}
+	vuln1b := &Vulnerability{ID: "test1", Priority: types.High, FixedInNodes: []string{"pkg3"}}
+	notifications, err := InsertVulnerabilities([]*Vulnerability{vuln1, vuln2, vuln1b})
+	if assert.Nil(t, err) {
+		// We should only have two NewVulnerabilityNotification notifications: one for test1 and one for test2
+		// We should not have a VulnerabilityPriorityIncreasedNotification or a VulnerabilityPackageChangedNotification
+		// for test1 because it is in the same batch
+		if assert.Len(t, notifications, 2) {
+			for _, n := range notifications {
+				_, ok := n.(*NewVulnerabilityNotification)
+				assert.True(t, ok)
+			}
+		}
+	}
+
+	// VulnerabilityPriorityIncreasedNotification
+	vuln1c := &Vulnerability{ID: "test1", Priority: types.Critical}
+	notifications, err = InsertVulnerabilities([]*Vulnerability{vuln1c})
+	if assert.Nil(t, err) {
+		if assert.Len(t, notifications, 1) {
+			if nn, ok := notifications[0].(*VulnerabilityPriorityIncreasedNotification); assert.True(t, ok) {
+				assert.Equal(t, vuln1b.Priority, nn.OldPriority)
+				assert.Equal(t, vuln1c.Priority, nn.NewPriority)
+			}
+		}
+	}
+
+	notifications, err = InsertVulnerabilities([]*Vulnerability{&Vulnerability{ID: "test1", Priority: types.Low}})
+	assert.Nil(t, err)
+	assert.Len(t, notifications, 0)
+
+	// VulnerabilityPackageChangedNotification
+	vuln1e := &Vulnerability{ID: "test1", FixedInNodes: []string{pkg1b.Node}}
+	vuln1f := &Vulnerability{ID: "test1", FixedInNodes: []string{pkg2.Node}}
+	notifications, err = InsertVulnerabilities([]*Vulnerability{vuln1e, vuln1f})
+	if assert.Nil(t, err) {
+		if assert.Len(t, notifications, 1) {
+			if nn, ok := notifications[0].(*VulnerabilityPackageChangedNotification); assert.True(t, ok) {
+				// Here, we say that pkg1b fixes the vulnerability, but as pkg1b is in
+				// the same branch as pkg1, pkg1 should be removed and pkg1b added
+				// We also add pkg2 as fixed
+				assert.Contains(t, nn.AddedFixedInNodes, pkg1b.Node)
+				assert.Contains(t, nn.RemovedFixedInNodes, pkg1.Node)
+
+				assert.Contains(t, nn.AddedFixedInNodes, pkg2.Node)
+			}
+		}
+	}
+}
diff --git a/docs/API.md b/docs/API.md
new file mode 100644
index 00000000..d955c842
--- /dev/null
+++ b/docs/API.md
@@ -0,0 +1,760 @@
+# General
+
+## Fetch API Version
+
+It returns the versions of the API and the layer processing engine.
+
+	GET /v1/versions
+
+* The versions are integers.
+* The API version number is raised each time there is an structural change.
+* The Engine version is increased when the a new layer analysis could find new
+relevant data.
+
+### Example
+
+```
+curl -s 127.0.0.1:6060/v1/versions | python -m json.tool
+```
+
+### Response
+
+```
+HTTP/1.1 200 OK
+{
+  "APIVersion": "1",
+  "EngineVersion": "1"
+}
+```
+
+## Fetch Health status
+
+	GET /v1/health
+
+Returns 200 if essential services are healthy (ie. database) and 503 otherwise.
+
+This call is also available on the API port + 1, without any security, allowing
+external monitoring systems to easily access it.
+
+### Example
+
+```
+curl -s 127.0.0.1:6060/v1/health | python -m json.tool
+```
+
+```
+curl -s 127.0.0.1:6061/ | python -m json.tool
+```
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{  
+   "database":{  
+      "IsHealthy":true
+   },
+   "notifier":{  
+      "IsHealthy":true,
+      "Details":{  
+         "QueueSize":0
+      }
+   },
+   "updater":{  
+      "IsHealthy":true,
+      "Details":{  
+         "HealthIdentifier":"cf65a8f6-425c-4a9c-87fe-f59ddf75fc87",
+         "HealthLockOwner":"1e7fce65-ee67-4ca5-b2e9-61e9f5e0d3ed",
+         "LatestSuccessfulUpdate":"2015-09-30T14:47:47Z",
+         "ConsecutiveLocalFailures":0
+      }
+   }
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 503 Service unavailable
+{  
+   "database":{  
+      "IsHealthy":false
+   },
+   "notifier":{  
+      "IsHealthy":true,
+      "Details":{  
+         "QueueSize":0
+      }
+   },
+   "updater":{  
+      "IsHealthy":true,
+      "Details":{  
+         "HealthIdentifier":"cf65a8f6-425c-4a9c-87fe-f59ddf75fc87",
+         "HealthLockOwner":"1e7fce65-ee67-4ca5-b2e9-61e9f5e0d3ed",
+         "LatestSuccessfulUpdate":"2015-09-30T14:47:47Z",
+         "ConsecutiveLocalFailures":0
+      }
+   }
+}
+```
+
+# Layers
+
+## Insert a new Layer
+
+It processes and inserts a new Layer in the database.
+
+	POST /v1/layers
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+|Path|String|Absolute path or HTTP link pointing to the Layer's tar file|
+|ParentID|String|(Optionnal) Unique ID of the Layer's parent
+
+If the Layer has not parent, the ParentID field should be omitted or empty.
+
+### Example
+
+```
+curl -s -H "Content-Type: application/json" -X POST -d \
+'{
+	"ID": "39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8",
+	"Path": "https://layers_storage/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8.tar",
+	"ParentID": "df2a0347c9d081fa05ecb83669dcae5830c67b0676a6d6358218e55d8a45969c"
+}' \
+127.0.0.1:6060/v1/layers
+```
+
+### Success Response
+
+If the layer has been successfully processed, the version of the engine which processed it is returned.
+
+```
+HTTP/1.1 201 Created
+{
+    "Version": "1"
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 400 Bad Request
+{
+    "Message": "Layer 39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8's parent (df2a0347c9d081fa05ecb83669dcae5830c67b0676a6d6358218e55d8a45969c) is unknown."
+}
+```
+
+It could also return a `415 Unsupported Media Type` response with a `Message` if the request content is not valid JSON.
+
+## Get a Layer's operating system
+
+It returns the operating system a given Layer.
+
+	GET /v1/layers/{ID}/os
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+
+### Example
+
+	curl -s 127.0.0.1:6060/v1/layers/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8/os | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "OS": "debian:8",
+}
+```
+
+### Error Response
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+## Get a Layer's parent
+
+It returns the parent's ID of a given Layer.
+It returns an empty ID string when the layer has no parent.
+
+	GET /v1/layers/{ID}/parent
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+
+### Example
+
+	curl -s 127.0.0.1:6060/v1/layers/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8/parent | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "ID": "df2a0347c9d081fa05ecb83669dcae5830c67b0676a6d6358218e55d8a45969c",
+}
+```
+
+### Error Response
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+## Get a Layer's package list
+
+It returns the package list of a given Layer.
+
+	GET /v1/layers/{ID}/packages
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+
+### Example
+
+	curl -s 127.0.0.1:6060/v1/layers/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8/packages | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "Packages": [
+        {
+            "Name": "gcc-4.9",
+            "OS": "debian:8",
+            "Version": "4.9.2-10"
+        },
+        [...]
+    ]
+}
+```
+
+### Error Response
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+## Get a Layer's package diff
+
+It returns the lists of packages a given Layer installs and removes.
+
+	GET /v1/layers/{ID}/packages/diff
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+
+### Example
+
+	curl -s 127.0.0.1:6060/v1/layers/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8/packages/diff | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "InstalledPackages": [
+        {
+            "Name": "gcc-4.9",
+            "OS": "debian:8",
+            "Version": "4.9.2-10"
+        },
+        [...]
+    ],
+    "RemovedPackages": null
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+## Get a Layer's vulnerabilities
+
+It returns the lists of vulnerabilities which affect a given Layer.
+
+	GET /v1/layers/{ID}/vulnerabilities(?minimumPriority=Low)
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+|minimumPriority|Priority|(Optionnal) The minimum priority of the returned vulnerabilities. Defaults to High|
+
+### Example
+
+	curl -s "127.0.0.1:6060/v1/layers/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8/vulnerabilities?minimumPriority=Negligible" | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "Vulnerabilities": [
+        {
+            "ID": "CVE-2014-2583",
+            "Link": "http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-2583",
+            "Priority": "Low",
+            "Description": "Multiple directory traversal vulnerabilities in pam_timestamp.c in the pam_timestamp module for Linux-PAM (aka pam) 1.1.8 allow local users to create aribitrary files or possibly bypass authentication via a .. (dot dot) in the (1) PAM_RUSER value to the get_ruser function or (2) PAM_TTY value to the check_tty funtion, which is used by the format_timestamp_name function."
+        },
+        [...]
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+## Get vulnerabilities that a layer introduces and removes
+
+It returns the lists of vulnerabilities which are introduced and removed by the given Layer.
+
+	GET /v1/layers/{ID}/vulnerabilities/diff(?minimumPriority=Low)
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Layer|
+|minimumPriority|Priority|(Optionnal) The minimum priority of the returned vulnerabilities|
+
+### Example
+
+	curl -s "127.0.0.1:6060/v1/layers/39bb80489af75406073b5364c9c326134015140e1f7976a370a8bd446889e6f8/vulnerabilities?minimumPriority=Negligible" | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "Adds": [
+        {
+            "ID": "CVE-2014-2583",
+            "Link": "http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-2583",
+            "Priority": "Low",
+            "Description": "Multiple directory traversal vulnerabilities in pam_timestamp.c in the pam_timestamp module for Linux-PAM (aka pam) 1.1.8 allow local users to create aribitrary files or possibly bypass authentication via a .. (dot dot) in the (1) PAM_RUSER value to the get_ruser function or (2) PAM_TTY value to the check_tty funtion, which is used by the format_timestamp_name function."
+        },
+        [...]
+    ],
+    "Removes": null
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+## Get a Layers' vulnerabilities (Batch)
+
+It returns the lists of vulnerabilities which affect the given Layers.
+
+	POST /v1/batch/layers/vulnerabilities(?minimumPriority=Low)
+
+Counterintuitively, this request is actually a POST to be able to pass a lot of parameters.
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|LayersIDs|Array of strings|Unique IDs of Layers|
+|minimumPriority|Priority|(Optionnal) The minimum priority of the returned vulnerabilities. Defaults to High|
+
+### Example
+
+```
+curl -s -H "Content-Type: application/json" -X POST -d \
+'{
+		"LayersIDs": [
+				"a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329",
+				"f1b10cd842498c23d206ee0cbeaa9de8d2ae09ff3c7af2723a9e337a6965d639"
+		]
+}' \
+127.0.0.1:6060/v1/batch/layers/vulnerabilities
+```
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329": {
+        "Vulnerabilities": [
+            {
+                "ID": "CVE-2014-2583",
+                "Link": "http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-2583",
+                "Priority": "Low",
+                "Description": "Multiple directory traversal vulnerabilities in pam_timestamp.c in the pam_timestamp module for Linux-PAM (aka pam) 1.1.8 allow local users to create aribitrary files or possibly bypass authentication via a .. (dot dot) in the (1) PAM_RUSER value to the get_ruser function or (2) PAM_TTY value to the check_tty funtion, which is used by the format_timestamp_name function."
+            },
+            [...]
+					]
+		},
+		[...]
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
+
+# Vulnerabilities
+
+## Get a vulnerability's informations
+
+It returns all known informations about a Vulnerability and its fixes.
+
+	GET /v1/vulnerabilities/{ID}
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Vulnerability|
+
+### Example
+
+	curl -s 127.0.0.1:6060/v1/vulnerabilities/CVE-2015-0235 | python -m json.tool
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+    "ID": "CVE-2015-0235",
+    "Link": "https://security-tracker.debian.org/tracker/CVE-2015-0235",
+    "Priority": "High",
+    "Description": "Heap-based buffer overflow in the __nss_hostname_digits_dots function in glibc 2.2, and other 2.x versions before 2.18, allows context-dependent attackers to execute arbitrary code via vectors related to the (1) gethostbyname or (2) gethostbyname2 function, aka \"GHOST.\"",
+    "AffectedPackages": [
+        {
+            "Name": "eglibc",
+            "OS": "debian:7",
+            "AllVersions": false,
+            "BeforeVersion": "2.13-38+deb7u7"
+        },
+        {
+            "Name": "glibc",
+            "OS": "debian:8",
+            "AllVersions": false,
+            "BeforeVersion": "2.18-1"
+        },
+        {
+            "Name": "glibc",
+            "OS": "debian:9",
+            "AllVersions": false,
+            "BeforeVersion": "2.18-1"
+        },
+        {
+            "Name": "glibc",
+            "OS": "debian:unstable",
+            "AllVersions": false,
+            "BeforeVersion": "2.18-1"
+        },
+        {
+            "Name": "eglibc",
+            "OS": "debian:6",
+            "AllVersions": true,
+            "BeforeVersion": "",
+        }
+    ],
+}
+```
+
+The `AffectedPackages` array represents the list of affected packages and provides the first known versions in which the Vulnerability has been fixed - each previous versions may be vulnerable. If `AllVersions` is equal to `true`, no fix exists, thus, all versions may be vulnerable.
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message":"the resource cannot be found"
+}
+```
+
+## Insert a new Vulnerability
+
+It manually inserts a new Vulnerability.
+
+	POST /v1/vulnerabilities
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Vulnerability|
+|Link|String|Link to the Vulnerability tracker|
+|Priority|Priority|Priority of the Vulnerability|
+|AffectedPackages|Array of Package|Affected packages (Name, OS) and fixed version (or all versions)|
+
+If no fix exists for a package, `AllVersions` should be set to `true`.
+
+Valid Priorities are based on [Ubuntu CVE Tracker/README](http://bazaar.launchpad.net/~ubuntu-security/ubuntu-cve-tracker/master/view/head:/README)
+
+* **Unknown** is either a security problem that has not been ssigned to a priority yet or a priority that our system did not recognize
+* **Negligible** is technically a security problem, but is only theoretical in nature, requires a very special situation, has almost no install base, or does no real damage. These tend not to get backport from upstreams, and will likely not be included in security updates unless there is an easy fix and some other issue causes an update.
+* **Low** is a security problem, but is hard to exploit due to environment, requires a user-assisted attack, a small install base, or does very little damage. These tend to be included in security updates only when higher priority issues require an update, or if many low priority issues have built up.
+* **Medium** is a real security problem, and is exploitable for many people. Includes network daemon denial of service attacks, cross-site scripting, and gaining user privileges. Updates should be made soon for this priority of issue.
+* **High** is a real problem, exploitable for many people in a default installation. Includes serious remote denial of services, local root privilege escalations, or data loss.
+* **Critical** is a world-burning problem, exploitable for nearly all people in a default installation of Ubuntu. Includes remote root privilege escalations, or massive data loss.
+* **Defcon1** is a **Critical** problem which has been manually highlighted by the team. It requires an immediate attention.
+
+### Example
+
+```
+curl -s -H "Content-Type: application/json" -X POST -d \
+'{
+ "ID": "CVE-2015-0235",
+ "Link": "https:security-tracker.debian.org/tracker/CVE-2015-0235",
+ "Priority": "High",
+ "Description": "Heap-based buffer overflow in the __nss_hostname_digits_dots function in glibc 2.2, and other 2.x versions before 2.18, allows context-dependent attackers to execute arbitrary code via vectors related to the (1) gethostbyname or (2) gethostbyname2 function, aka \"GHOST.\"",
+ "AffectedPackages": [
+   {
+       "Name": "eglibc",
+       "OS": "debian:7",
+       "BeforeVersion": "2.13-38+deb7u7"
+   },
+   {
+       "Name": "glibc",
+       "OS": "debian:8",
+       "BeforeVersion": "2.18-1"
+   },
+   {
+       "Name": "glibc",
+       "OS": "debian:9",
+       "BeforeVersion": "2.18-1"
+   },
+   {
+       "Name": "glibc",
+       "OS": "debian:unstable",
+       "BeforeVersion": "2.18-1"
+   },
+   {
+       "Name": "eglibc",
+       "OS": "debian:6",
+       "AllVersions": true,
+       "BeforeVersion": ""
+   }
+ ]
+}' \
+127.0.0.1:6060/v1/vulnerabilities
+```
+
+### Success Response
+
+	HTTP/1.1 201 Created
+
+### Error Response
+
+```
+HTTP/1.1 400 Bad Request
+{
+	"Message":"Could not insert a vulnerability which has an invalid priority"
+}
+```
+
+It could also return a `415 Unsupported Media Type` response with a `Message` if the request content is not valid JSON.
+
+## Update a Vulnerability
+
+It updates an existing Vulnerability.
+
+	PUT /v1/vulnerabilities/{ID}
+
+The Link, Priority and Description fields can be updated. FixedIn packages are added to the vulnerability. However, as a vulnerability can be fixed by only one package on a given branch (OS, Name): old FixedIn packages, which belong to the same branch as a new added one, will be removed.
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|Link|String|Link to the Vulnerability tracker|
+|Priority|Priority|Priority of the Vulnerability|
+|FixedIn|Array of Package|Affected packages (Name, OS) and fixed version (or all versions)|
+
+If no fix exists for a package, `AllVersions` should be set to `true`.
+
+### Example
+
+	curl -s -H "Content-Type: application/json" -X PUT -d '{"Priority": "Critical" }' 127.0.0.1:6060/v1/vulnerabilities/CVE-2015-0235
+
+### Success Response
+
+```
+HTTP/1.1 204 No content
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message":"the resource cannot be found"
+}
+```
+
+It could also return a `415 Unsupported Media Type` response with a `Message` if the request content is not valid JSON.
+
+## Delete a Vulnerability
+
+It deletes an existing Vulnerability.
+
+	DEL /v1/vulnerabilities/{ID}
+
+Be aware that it does not prevent fetcher's to re-create it. Therefore it is only useful to remove manually inserted vulnerabilities.
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Vulnerability|
+
+### Example
+
+	curl -s -X DEL 127.0.0.1:6060/v1/vulnerabilities/CVE-2015-0235
+
+### Success Response
+
+```
+HTTP/1.1 204 No content
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message":"the resource cannot be found"
+}
+```
+
+## Get layers introducing a vulnerability
+
+It gets all the layers (their IDs) that introduce the given vulnerability.
+
+	GET /v1/vulnerabilities/:id/introducing-layers
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Vulnerability|
+
+### Example
+
+	curl -s -X GET 127.0.0.1:6060/v1/vulnerabilities/CVE-2015-0235/introducing-layers
+
+### Success Response
+
+```
+HTTP/1.1 200
+{
+	"IntroducingLayers":[
+		"fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f"
+	]
+}
+```
+
+### Error Response
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message":"the resource cannot be found"
+}
+```
+
+## Get layers affected by a vulnerability
+
+It returns whether the specified Layers are vulnerable to the given Vulnerability or not.
+
+	POST /v1/vulnerabilities/{ID}/affected-layers
+
+Counterintuitively, this request is actually a POST to be able to pass a lot of parameters.
+
+### Parameters
+
+|Name|Type|Description|
+|------|-----|-------------|
+|ID|String|Unique ID of the Vulnerability|
+|LayersIDs|Array of strings|Unique IDs of Layers|
+
+### Example
+
+```
+curl -s -H "Content-Type: application/json" -X POST -d \
+'{
+		"LayersIDs": [
+				"a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329",
+				"f1b10cd842498c23d206ee0cbeaa9de8d2ae09ff3c7af2723a9e337a6965d639"
+		]
+}' \
+127.0.0.1:6060/v1/vulnerabilities/CVE-2015-0235/affected-layers
+```
+
+### Success Response
+
+```
+HTTP/1.1 200 OK
+{
+   "f1b10cd842498c23d206ee0cbeaa9de8d2ae09ff3c7af2723a9e337a6965d639": {
+        "Vulnerable": false
+   },
+   "fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f": {
+        "Vulnerable": true
+   }
+}
+```
+
+### Error Response
+
+Returned when the Layer or the Vulnerability does not exist.
+
+```
+HTTP/1.1 404 Not Found
+{
+    "Message": "the resource cannot be found"
+}
+```
diff --git a/docs/Model.graffle b/docs/Model.graffle
new file mode 100644
index 00000000..ff76b62f
Binary files /dev/null and b/docs/Model.graffle differ
diff --git a/docs/Model.md b/docs/Model.md
new file mode 100644
index 00000000..9ed52460
--- /dev/null
+++ b/docs/Model.md
@@ -0,0 +1,70 @@
+# Legend
+    -> outbound edges
+    <- inbound edges
+
+# Layer
+
+    Key: "layer:" + Hash(id)
+
+    -> is = "layer"
+    -> id
+    -> parent (my ancestor is)
+
+    -> os
+    -> adds*
+    -> removes*
+    -> engineVersion
+
+    <- parent* (is ancestor of)
+
+# Package
+
+    Key: "package:" + Hash(os + ":" + name + ":" + version)
+
+    -> is = "package"
+    -> os
+    -> name
+    -> version
+    -> nextVersion
+
+    <- nextVersion
+    <- adds*
+    <- removes*
+    <- fixed_in*
+
+Packages are organized in linked lists : there is one linked list for one os/name couple. Each linked list has a tail and a head with special versions.
+
+# Vulnerability
+
+    Key: "vulnerability:" + Hash(name)
+
+    -> is = "vulnerability"
+    -> name
+    -> priority
+    -> link
+    -> fixed_in*
+
+# Notification
+
+    Key: "notification:" + random uuid
+
+    -> is = "notification"
+    -> type
+    -> data
+    -> isSent
+
+# Flag
+
+    Key: "flag:" + name
+
+    -> value
+
+# Lock
+
+    Key: name
+
+    -> locked = "locked"
+    -> locked_until (timestamp)
+    -> locked_by
+
+A lock can be used to lock a specific graph node by using the node Key as the lock name.
diff --git a/docs/Model.png b/docs/Model.png
new file mode 100644
index 00000000..1a8636af
Binary files /dev/null and b/docs/Model.png differ
diff --git a/docs/Notifications.md b/docs/Notifications.md
new file mode 100644
index 00000000..7d0b1666
--- /dev/null
+++ b/docs/Notifications.md
@@ -0,0 +1,131 @@
+# Notifications
+
+This tool can send notifications to external services when specific events happen, such as vulnerability updates.
+
+For now, it only supports transmitting them to an HTTP endpoint using POST requests, but it may be extended quite easily.
+To enable the notification system, specify the following command-line arguments:
+
+    --notifier-type=http --notifier-http-url="http://your-notification-endpoint"
+
+# Types of notifications
+
+## A new vulnerability has been released
+
+A notification of this kind is sent as soon as a new vulnerability is added in the system, via the updater or the API.
+
+### Example
+
+```
+{  
+   "Name":"CVE-2016-0001",
+   "Type":"NewVulnerabilityNotification",
+   "Content":{  
+      "Vulnerability":{  
+         "ID":"CVE-2016-0001",
+         "Link":"https:security-tracker.debian.org/tracker/CVE-2016-0001",
+         "Priority":"Medium",
+         "Description":"A futurist vulnerability",
+         "AffectedPackages":[  
+            {  
+               "OS":"centos:6",
+               "Name":"bash",
+               "AllVersions":true,
+               "BeforeVersion":""
+            }
+         ]
+      },
+      "IntroducingLayersIDs":[  
+         "fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f"
+      ]
+   }
+}
+```
+
+The `IntroducingLayersIDs` array contains every layers that install at least one affected package.
+
+## A vulnerability's priority has increased
+
+This notification is sent when a vulnerability's priority has increased.
+
+### Example
+
+```
+{  
+   "Name":"CVE-2016-0001",
+   "Type":"VulnerabilityPriorityIncreasedNotification",
+   "Content":{  
+      "Vulnerability":{  
+         "ID":"CVE-2016-0001",
+         "Link":"https:security-tracker.debian.org/tracker/CVE-2016-0001",
+         "Priority":"Critical",
+         "Description":"A futurist vulnerability",
+         "AffectedPackages":[  
+            {  
+               "OS":"centos:6",
+               "Name":"bash",
+               "AllVersions":true,
+               "BeforeVersion":""
+            }
+         ]
+      },
+      "OldPriority":"Medium",
+      "NewPriority":"Critical",
+      "IntroducingLayersIDs":[  
+         "fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f"
+      ]
+   }
+}
+```
+
+The `IntroducingLayersIDs` array contains every layers that install at least one affected package.
+
+## A vulnerability's affected package list changed
+
+This notification is sent when the affected packages of a vulnerability changes.
+
+### Example
+
+```
+{  
+   "Name":"CVE-2016-0001",
+   "Type":"VulnerabilityPackageChangedNotification",
+   "Content":{  
+      "Vulnerability":{  
+         "ID":"CVE-2016-0001",
+         "Link":"https:security-tracker.debian.org/tracker/CVE-2016-0001",
+         "Priority":"Critical",
+         "Description":"A futurist vulnerability",
+         "AffectedPackages":[  
+            {  
+               "OS":"centos:6",
+               "Name":"bash",
+               "AllVersions":false,
+               "BeforeVersion":"4.0"
+            }
+         ]
+      },
+      "AddedAffectedPackages":[  
+         {  
+            "OS":"centos:6",
+            "Name":"bash",
+            "AllVersions":false,
+            "BeforeVersion":"4.0"
+         }
+      ],
+      "RemovedAffectedPackages":[  
+         {  
+            "OS":"centos:6",
+            "Name":"bash",
+            "AllVersions":true,
+            "BeforeVersion":""
+         }
+      ],
+      "NewIntroducingLayersIDs": [],
+      "FormerIntroducingLayerIDs":[  
+         "fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f",
+      ]
+   }
+}
+```
+
+The `NewIntroducingLayersIDs` array contains the layers that install at least one of the newly affected package, and thus which are now vulnerable because of this change. In the other hand, the `FormerIntroducingLayerIDs` array contains the layers that are not introducing the vulnerability anymore.
diff --git a/docs/Run.md b/docs/Run.md
new file mode 100644
index 00000000..529adaa7
--- /dev/null
+++ b/docs/Run.md
@@ -0,0 +1,21 @@
+# Build and Run with Docker
+
+The easiest way to run this tool is to deploy it using Docker.
+If you prefer to run it locally, reading the Dockerfile will tell you how.
+
+To deploy it from the latest sources, follow this procedure:
+* Clone the repository and change your current directory
+* Build the container: `docker build -t <TAG> .`
+* Run it like this to see the available commands: `docker run -it <TAG>`. To get help about a specific command, use `docker run -it <TAG> help <COMMAND>`
+
+## Command-Line examples
+
+When running multiple instances is not desired, using BoltDB backend is the best choice as it is lightning fast:
+
+    docker run -it <TAG> --db-type=bolt --db-path=/db/database
+
+Using PostgreSQL enables running multiple instances concurrently. Here is a command line example:
+
+    docker run -it <TAG> --db-type=sql --db-path='host=awesome-database.us-east-1.rds.amazonaws.com port=5432 user=SuperSheep password=SuperSecret' --update-interval=2h --notifier-type=http --notifier-http-url="http://your-notification-endpoint"
+
+The default API port is 6060, read the [API Documentation](API.md) to learn more.
diff --git a/docs/Security.md b/docs/Security.md
new file mode 100644
index 00000000..01723816
--- /dev/null
+++ b/docs/Security.md
@@ -0,0 +1,54 @@
+# Security
+
+# Enabling HTTPS
+HTTPS provides clients the ability to verify the server identity and provide transport security.
+
+For this you need your CA certificate (ca.crt) and signed key pair (server.crt, server.key) ready.
+To enable it, provide signed key pair using `--api-cert-file` and `--api-key-file` arguments.
+
+To test it, you want to use curl like this:
+
+	curl --cacert ca.crt -L https://127.0.0.1:6060/v1/versions
+
+You should be able to see the handshake succeed. Because we use self-signed certificates with our own certificate authorities you need to provide the CA to curl using the --cacert option. Another possibility would be to add your CA certificate to the trusted certificates on your system (usually in /etc/ssl/certs).
+
+**OSX 10.9+ Users**: curl 7.30.0 on OSX 10.9+ doesn't understand certificates passed in on the command line. Instead you must import the dummy ca.crt directly into the keychain or add the -k flag to curl to ignore errors. If you want to test without the -k flag run open ca.crt and follow the prompts. Please remove this certificate after you are done testing!
+
+# Enabling Client Certificate Auth
+
+We can also use client certificates to prevent unauthorized access to the API.
+
+The clients will provide their certificates to the server and the server will check whether the cert is signed by the supplied CA and decide whether to serve the request.
+
+You need the same files mentioned in the HTTPS section, as well as a key pair for the client (client.crt, client.key) signed by the same certificate authority. To enable it, use the same arguments as above for HTTPS and the additional `--api-ca-file` parameter with the CA certificate.
+
+The test command from the HTTPS section should be rejected, instead we need to provide the client key pair:
+
+    curl --cacert ca.crt --cert client.crt --key client.key -L https://127.0.0.1:6060/v1/versions
+
+**OSX 10.10+ Users**: A bundle in P12 (PKCS#12) format must be used. To convert your key pair, the following command should be used, in which the password is mandatory. Then, `--cert client.p12` along with `--password pass` replace `--cert client.crt --key client.key`. You may also import the P12 certificate into your Keychain and specify its name as it appears in the Keychain instead of the path to the file.
+
+    openssl pkcs12 -export -in client.crt -inkey client1.key -out certs/client.p12 -password pass:pass
+
+# Generating self-signed certificates
+[etcd-ca](https://github.com/coreos/etcd-ca) is a great tool when it comes to easily generate certificates. Below is an example to generate a new CA, server and client key pairs, inspired by their example.
+
+```
+git clone https://github.com/coreos/etcd-ca
+cd etcd-ca
+./build
+
+# Create CA
+./bin/etcd-ca init
+./bin/etcd-ca export | tar xvf -
+
+# Create certificate for server
+./bin/etcd-ca new-cert --passphrase $passphrase --ip $server1ip --domain $server1hostname server1
+./bin/etcd-ca sign --passphrase $passphrase server1
+./bin/etcd-ca export --insecure --passphrase $passphrase server1 | tar xvf -
+
+# Create certificate for client
+./bin/etcd-ca new-cert --passphrase $passphrase client1
+./bin/etcd-ca sign --passphrase $passphrase client1
+./bin/etcd-ca export --insecure --passphrase $passphrase client1 | tar xvf -
+```
diff --git a/health/health.go b/health/health.go
new file mode 100644
index 00000000..0ec34725
--- /dev/null
+++ b/health/health.go
@@ -0,0 +1,80 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package health defines a standard healthcheck response format and expose
+// a function that summarizes registered healthchecks.
+package health
+
+import (
+	"fmt"
+	"sync"
+)
+
+// Status defines a way to know the health status of a service
+type Status struct {
+	// IsEssential determines if the service is essential to the app, which can't
+	// run in case of a failure
+	IsEssential bool
+	// IsHealthy defines whether the service is working or not
+	IsHealthy bool
+	// Details gives informations specific to the service
+	Details interface{}
+}
+
+// A Healthchecker function is a method returning the Status of the tested service
+type Healthchecker func() Status
+
+var (
+	healthcheckersLock sync.Mutex
+	healthcheckers     = make(map[string]Healthchecker)
+)
+
+// RegisterHealthchecker registers a Healthchecker function which will be part of Healthchecks
+func RegisterHealthchecker(name string, f Healthchecker) {
+	if name == "" {
+		panic("Could not register a Healthchecker with an empty name")
+	}
+	if f == nil {
+		panic("Could not register a nil Healthchecker")
+	}
+
+	healthcheckersLock.Lock()
+	defer healthcheckersLock.Unlock()
+
+	if _, alreadyExists := healthcheckers[name]; alreadyExists {
+		panic(fmt.Sprintf("Healthchecker '%s' is already registered", name))
+	}
+	healthcheckers[name] = f
+}
+
+// Healthcheck calls every registered Healthchecker and summarize their output
+func Healthcheck() (bool, map[string]interface{}) {
+	globalHealth := true
+
+	statuses := make(map[string]interface{})
+	for serviceName, serviceChecker := range healthcheckers {
+		status := serviceChecker()
+
+		globalHealth = globalHealth && (!status.IsEssential || status.IsHealthy)
+		statuses[serviceName] = struct {
+			IsHealthy bool
+			Details   interface{} `json:",omitempty"`
+		}{
+			IsHealthy: status.IsHealthy,
+			Details:   status.Details,
+		}
+	}
+
+	return globalHealth, statuses
+}
diff --git a/main.go b/main.go
new file mode 100644
index 00000000..cfaccbd3
--- /dev/null
+++ b/main.go
@@ -0,0 +1,148 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"math/rand"
+	"os"
+	"os/signal"
+	"runtime/pprof"
+	"strings"
+	"time"
+
+	"github.com/coreos/clair/api"
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/notifier"
+	"github.com/coreos/clair/updater"
+	"github.com/coreos/clair/utils"
+
+	"github.com/coreos/pkg/capnslog"
+	"gopkg.in/alecthomas/kingpin.v2"
+
+	// Register components
+	_ "github.com/coreos/clair/updater/fetchers"
+	_ "github.com/coreos/clair/worker/detectors/os"
+	_ "github.com/coreos/clair/worker/detectors/packages"
+)
+
+var (
+	log = capnslog.NewPackageLogger("github.com/coreos/clair", "main")
+
+	// Database configuration
+	cfgDbType = kingpin.Flag("db-type", "Type of the database to use").Default("bolt").Enum("bolt", "leveldb", "memstore", "mongo", "sql")
+	cfgDbPath = kingpin.Flag("db-path", "Path to the database to use").String()
+
+	// Notifier configuration
+	cfgNotifierType    = kingpin.Flag("notifier-type", "Type of the notifier to use").Default("none").Enum("none", "http")
+	cfgNotifierHTTPURL = kingpin.Flag("notifier-http-url", "URL that will receive POST notifications").String()
+
+	// Updater configuration
+	cfgUpdateInterval = kingpin.Flag("update-interval", "Frequency at which the vulnerability updater will run. Use 0 to disable the updater entirely.").Default("1h").Duration()
+
+	// API configuration
+	cfgAPIPort     = kingpin.Flag("api-port", "Port on which the API will listen").Default("6060").Int()
+	cfgAPITimeout  = kingpin.Flag("api-timeout", "Timeout of API calls").Default("900s").Duration()
+	cfgAPICertFile = kingpin.Flag("api-cert-file", "Path to TLS Cert file").ExistingFile()
+	cfgAPIKeyFile  = kingpin.Flag("api-key-file", "Path to TLS Key file").ExistingFile()
+	cfgAPICAFile   = kingpin.Flag("api-ca-file", "Path to CA for verifying TLS client certs").ExistingFile()
+
+	// Other flags
+	cfgCPUProfilePath = kingpin.Flag("cpu-profile-path", "Path to a write CPU profiling data").String()
+	cfgLogLevel       = kingpin.Flag("log-level", "How much console-spam do you want globally").Default("info").Enum("trace", "debug", "info", "notice", "warning", "error", "critical")
+)
+
+func main() {
+	rand.Seed(time.Now().UTC().UnixNano())
+
+	var err error
+	st := utils.NewStopper()
+
+	// Parse command-line arguments
+	kingpin.Parse()
+	if *cfgDbType != "memstore" && *cfgDbPath == "" {
+		kingpin.Errorf("required flag --db-path not provided, try --help")
+		os.Exit(1)
+	}
+	if *cfgNotifierType == "http" && *cfgNotifierHTTPURL == "" {
+		kingpin.Errorf("required flag --notifier-http-url not provided, try --help")
+		os.Exit(1)
+	}
+
+	// Initialize error/logging system
+	logLevel, err := capnslog.ParseLevel(strings.ToUpper(*cfgLogLevel))
+	capnslog.SetGlobalLogLevel(logLevel)
+	capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false))
+
+	// Enable CPU Profiling if specified
+	if *cfgCPUProfilePath != "" {
+		f, err := os.Create(*cfgCPUProfilePath)
+		if err != nil {
+			log.Fatalf("failed to create profile file: %s", err)
+		}
+		defer f.Close()
+
+		pprof.StartCPUProfile(f)
+		log.Info("started profiling")
+
+		defer func() {
+			pprof.StopCPUProfile()
+			log.Info("stopped profiling")
+		}()
+	}
+
+	// Open database
+	err = database.Open(*cfgDbType, *cfgDbPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer database.Close()
+
+	// Start notifier
+	var notifierService notifier.Notifier
+	switch *cfgNotifierType {
+	case "http":
+		notifierService, err = notifier.NewHTTPNotifier(*cfgNotifierHTTPURL)
+		if err != nil {
+			log.Fatalf("could not initialize HTTP notifier: %s", err)
+		}
+	}
+	if notifierService != nil {
+		st.Begin()
+		go notifierService.Run(st)
+	}
+
+	// Start Main API and Health API
+	st.Begin()
+	go api.RunMain(&api.Config{
+		Port:     *cfgAPIPort,
+		TimeOut:  *cfgAPITimeout,
+		CertFile: *cfgAPICertFile,
+		KeyFile:  *cfgAPIKeyFile,
+		CAFile:   *cfgAPICAFile,
+	}, st)
+	st.Begin()
+	go api.RunHealth(*cfgAPIPort+1, st)
+
+	// Start updater
+	st.Begin()
+	go updater.Run(*cfgUpdateInterval, st)
+
+	// This blocks the main goroutine which is required to keep all the other goroutines running
+	interrupts := make(chan os.Signal, 1)
+	signal.Notify(interrupts, os.Interrupt)
+	<-interrupts
+	log.Info("Received interruption, gracefully stopping ...")
+	st.Stop()
+}
diff --git a/notifier/notifier.go b/notifier/notifier.go
new file mode 100644
index 00000000..6793098d
--- /dev/null
+++ b/notifier/notifier.go
@@ -0,0 +1,173 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package notifier fetches notifications from the database and sends them
+// to the specified remote handler.
+package notifier
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/coreos/pkg/capnslog"
+	"github.com/coreos/pkg/timeutil"
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/health"
+	"github.com/coreos/clair/utils"
+	"github.com/pborman/uuid"
+)
+
+// A Notifier dispatches notifications
+type Notifier interface {
+	Run(*utils.Stopper)
+}
+
+var log = capnslog.NewPackageLogger("github.com/coreos/clair", "notifier")
+
+const (
+	maxBackOff    = 5 * time.Minute
+	checkInterval = 5 * time.Second
+
+	refreshLockAnticipation = time.Minute * 2
+	lockDuration            = time.Minute*8 + refreshLockAnticipation
+)
+
+// A HTTPNotifier dispatches notifications to an HTTP endpoint with POST requests
+type HTTPNotifier struct {
+	url string
+}
+
+// NewHTTPNotifier initializes a new HTTPNotifier
+func NewHTTPNotifier(URL string) (*HTTPNotifier, error) {
+	if _, err := url.Parse(URL); err != nil {
+		return nil, cerrors.NewBadRequestError("could not create a notifier with an invalid URL")
+	}
+
+	notifier := &HTTPNotifier{url: URL}
+	health.RegisterHealthchecker("notifier", notifier.Healthcheck)
+
+	return notifier, nil
+}
+
+// Run pops notifications from the database, lock them, send them, mark them as
+// send and unlock them
+//
+// It uses an exponential backoff when POST requests fail
+func (notifier *HTTPNotifier) Run(st *utils.Stopper) {
+	defer st.End()
+
+	whoAmI := uuid.New()
+	log.Infof("HTTP notifier started. URL: %s. Lock Identifier: %s", notifier.url, whoAmI)
+
+	for {
+		node, notification, err := database.FindOneNotificationToSend(database.GetDefaultNotificationWrapper())
+		if notification == nil || err != nil {
+			if err != nil {
+				log.Warningf("could not get notification to send: %s.", err)
+			}
+
+			if !st.Sleep(checkInterval) {
+				break
+			}
+
+			continue
+		}
+
+		// Try to lock the notification
+		hasLock, hasLockUntil := database.Lock(node, lockDuration, whoAmI)
+		if !hasLock {
+			continue
+		}
+
+		for backOff := time.Duration(0); ; backOff = timeutil.ExpBackoff(backOff, maxBackOff) {
+			// Backoff, it happens when an error occurs during the communication
+			// with the notification endpoint
+			if backOff > 0 {
+				// Renew lock before going to sleep if necessary
+				if time.Now().Add(backOff).After(hasLockUntil.Add(-refreshLockAnticipation)) {
+					hasLock, hasLockUntil = database.Lock(node, lockDuration, whoAmI)
+					if !hasLock {
+						log.Warning("lost lock ownership, aborting")
+						break
+					}
+				}
+
+				// Sleep
+				if !st.Sleep(backOff) {
+					return
+				}
+			}
+
+			// Get notification content
+			content, err := notification.GetContent()
+			if err != nil {
+				log.Warningf("could not get content of notification '%s': %s", notification.GetName(), err.Error())
+				break
+			}
+
+			// Marshal the notification content
+			jsonContent, err := json.Marshal(struct {
+				Name, Type string
+				Content    interface{}
+			}{
+				Name:    notification.GetName(),
+				Type:    notification.GetType(),
+				Content: content,
+			})
+			if err != nil {
+				log.Errorf("could not marshal content of notification '%s': %s", notification.GetName(), err.Error())
+				break
+			}
+
+			// Post notification
+			req, _ := http.NewRequest("POST", notifier.url, bytes.NewBuffer(jsonContent))
+			req.Header.Set("Content-Type", "application/json")
+
+			client := &http.Client{}
+			res, err := client.Do(req)
+			if err != nil {
+				log.Warningf("could not post notification '%s': %s", notification.GetName(), err.Error())
+				continue
+			}
+			res.Body.Close()
+
+			if res.StatusCode != 200 && res.StatusCode != 201 {
+				log.Warningf("could not post notification '%s': got status code %d", notification.GetName(), res.StatusCode)
+				continue
+			}
+
+			// Mark the notification as sent
+			database.MarkNotificationAsSent(node)
+
+			log.Infof("sent notification '%s' successfully", notification.GetName())
+			break
+		}
+
+		if hasLock {
+			database.Unlock(node, whoAmI)
+		}
+	}
+
+	log.Info("HTTP notifier stopped")
+}
+
+// Healthcheck returns the health of the notifier service
+func (notifier *HTTPNotifier) Healthcheck() health.Status {
+	queueSize, err := database.CountNotificationsToSend()
+	return health.Status{IsEssential: false, IsHealthy: err == nil, Details: struct{ QueueSize int }{QueueSize: queueSize}}
+}
diff --git a/updater/fetchers.go b/updater/fetchers.go
new file mode 100644
index 00000000..36f6f307
--- /dev/null
+++ b/updater/fetchers.go
@@ -0,0 +1,64 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package updater
+
+import (
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+)
+
+var fetchers = make(map[string]Fetcher)
+
+// Fetcher represents anything that can fetch vulnerabilities.
+type Fetcher interface {
+	FetchUpdate() (FetcherResponse, error)
+}
+
+// FetcherResponse represents the sum of results of an update.
+type FetcherResponse struct {
+	FlagName        string
+	FlagValue       string
+	Notes           []string
+	Vulnerabilities []FetcherVulnerability
+}
+
+// FetcherVulnerability represents an individual vulnerability processed from
+// an update.
+type FetcherVulnerability struct {
+	ID          string
+	Link        string
+	Description string
+	Priority    types.Priority
+	FixedIn     []*database.Package
+}
+
+// RegisterFetcher makes a Fetcher available by the provided name.
+// If Register is called twice with the same name or if driver is nil,
+// it panics.
+func RegisterFetcher(name string, f Fetcher) {
+	if name == "" {
+		panic("updater: could not register a Fetcher with an empty name")
+	}
+
+	if f == nil {
+		panic("updater: could not register a nil Fetcher")
+	}
+
+	if _, dup := fetchers[name]; dup {
+		panic("updater: RegisterFetcher called twice for " + name)
+	}
+
+	fetchers[name] = f
+}
diff --git a/updater/fetchers/debian.go b/updater/fetchers/debian.go
new file mode 100644
index 00000000..c653c3c5
--- /dev/null
+++ b/updater/fetchers/debian.go
@@ -0,0 +1,240 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fetchers
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/updater"
+	"github.com/coreos/clair/utils/types"
+)
+
+const (
+	url               = "https://security-tracker.debian.org/tracker/data/json"
+	cveURLPrefix      = "https://security-tracker.debian.org/tracker"
+	debianUpdaterFlag = "debianUpdater"
+)
+
+type jsonData map[string]map[string]jsonVuln
+
+type jsonVuln struct {
+	Description string             `json:"description"`
+	Releases    map[string]jsonRel `json:"releases"`
+}
+
+type jsonRel struct {
+	FixedVersion string `json:"fixed_version"`
+	Status       string `json:"status"`
+	Urgency      string `json:"urgency"`
+}
+
+// DebianFetcher implements updater.Fetcher for the Debian Security Tracker
+// (https://security-tracker.debian.org).
+type DebianFetcher struct{}
+
+func init() {
+	updater.RegisterFetcher("debian", &DebianFetcher{})
+}
+
+// FetchUpdate fetches vulnerability updates from the Debian Security Tracker.
+func (fetcher *DebianFetcher) FetchUpdate() (resp updater.FetcherResponse, err error) {
+	log.Info("fetching Debian vulneratibilities")
+
+	// Download JSON.
+	r, err := http.Get(url)
+	if err != nil {
+		log.Errorf("could not download Debian's update: %s", err)
+		return resp, cerrors.ErrCouldNotDownload
+	}
+
+	// Get the SHA-1 of the latest update's JSON data
+	latestHash, err := database.GetFlagValue(debianUpdaterFlag)
+	if err != nil {
+		return resp, err
+	}
+
+	// Parse the JSON.
+	resp, err = buildResponse(r.Body, latestHash)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+func buildResponse(jsonReader io.Reader, latestKnownHash string) (resp updater.FetcherResponse, err error) {
+	hash := latestKnownHash
+
+	// Defer the addition of flag information to the response.
+	defer func() {
+		if err == nil {
+			resp.FlagName = debianUpdaterFlag
+			resp.FlagValue = hash
+		}
+	}()
+
+	// Create a TeeReader so that we can unmarshal into JSON and write to a SHA-1
+	// digest at the same time.
+	jsonSHA := sha1.New()
+	teedJSONReader := io.TeeReader(jsonReader, jsonSHA)
+
+	// Unmarshal JSON.
+	var data jsonData
+	err = json.NewDecoder(teedJSONReader).Decode(&data)
+	if err != nil {
+		log.Errorf("could not unmarshal Debian's JSON: %s", err)
+		return resp, ErrCouldNotParse
+	}
+
+	// Calculate the hash and skip updating if the hash has been seen before.
+	hash = hex.EncodeToString(jsonSHA.Sum(nil))
+	if latestKnownHash == hash {
+		log.Debug("no Debian update")
+		return resp, nil
+	}
+
+	// Extract vulnerability data from Debian's JSON schema.
+	vulnerabilities, unknownReleases := parseDebianJSON(&data)
+
+	// Log unknown releases
+	for k := range unknownReleases {
+		note := fmt.Sprintf("Debian %s is not mapped to any version number (eg. Jessie->8). Please update me.", k)
+		resp.Notes = append(resp.Notes, note)
+		log.Warning(note)
+	}
+
+	// Convert the vulnerabilities map to a slice in the response
+	for _, v := range vulnerabilities {
+		resp.Vulnerabilities = append(resp.Vulnerabilities, v)
+	}
+
+	return resp, nil
+}
+
+func parseDebianJSON(data *jsonData) (vulnerabilities map[string]updater.FetcherVulnerability, unknownReleases map[string]struct{}) {
+	vulnerabilities = make(map[string]updater.FetcherVulnerability)
+	unknownReleases = make(map[string]struct{})
+
+	for pkgName, pkgNode := range *data {
+		for vulnName, vulnNode := range pkgNode {
+			for releaseName, releaseNode := range vulnNode.Releases {
+				// Attempt to detect the release number.
+				if _, isReleaseKnown := database.DebianReleasesMapping[releaseName]; !isReleaseKnown {
+					unknownReleases[releaseName] = struct{}{}
+					continue
+				}
+
+				// Skip if the release is not affected.
+				if releaseNode.FixedVersion == "0" || releaseNode.Status == "undetermined" {
+					continue
+				}
+
+				// Get or create the vulnerability.
+				vulnerability, vulnerabilityAlreadyExists := vulnerabilities[vulnName]
+				if !vulnerabilityAlreadyExists {
+					vulnerability = updater.FetcherVulnerability{
+						ID:          vulnName,
+						Link:        strings.Join([]string{cveURLPrefix, "/", vulnName}, ""),
+						Priority:    types.Unknown,
+						Description: vulnNode.Description,
+					}
+				}
+
+				// Set the priority of the vulnerability.
+				// In the JSON, a vulnerability has one urgency per package it affects.
+				// The highest urgency should be the one set.
+				urgency := urgencyToPriority(releaseNode.Urgency)
+				if urgency.Compare(vulnerability.Priority) > 0 {
+					vulnerability.Priority = urgency
+				}
+
+				// Determine the version of the package the vulnerability affects.
+				var version types.Version
+				var err error
+				if releaseNode.Status == "open" {
+					// Open means that the package is currently vulnerable in the latest
+					// version of this Debian release.
+					version = types.MaxVersion
+				} else if releaseNode.Status == "resolved" {
+					// Resolved means that the vulnerability has been fixed in
+					// "fixed_version" (if affected).
+					version, err = types.NewVersion(releaseNode.FixedVersion)
+					if err != nil {
+						log.Warningf("could not parse package version '%s': %s. skipping", releaseNode.FixedVersion, err.Error())
+						continue
+					}
+				}
+
+				// Create and add the package.
+				pkg := &database.Package{
+					OS:      "debian:" + database.DebianReleasesMapping[releaseName],
+					Name:    pkgName,
+					Version: version,
+				}
+				vulnerability.FixedIn = append(vulnerability.FixedIn, pkg)
+
+				// Store the vulnerability.
+				vulnerabilities[vulnName] = vulnerability
+			}
+		}
+	}
+
+	return
+}
+
+func urgencyToPriority(urgency string) types.Priority {
+	switch urgency {
+	case "not yet assigned":
+		return types.Unknown
+
+	case "end-of-life":
+		fallthrough
+	case "unimportant":
+		return types.Negligible
+
+	case "low":
+		fallthrough
+	case "low*":
+		fallthrough
+	case "low**":
+		return types.Low
+
+	case "medium":
+		fallthrough
+	case "medium*":
+		fallthrough
+	case "medium**":
+		return types.Medium
+
+	case "high":
+		fallthrough
+	case "high*":
+		fallthrough
+	case "high**":
+		return types.High
+
+	default:
+		log.Warningf("could not determine vulnerability priority from: %s", urgency)
+		return types.Unknown
+	}
+}
diff --git a/updater/fetchers/debian_test.go b/updater/fetchers/debian_test.go
new file mode 100644
index 00000000..e03c398c
--- /dev/null
+++ b/updater/fetchers/debian_test.go
@@ -0,0 +1,80 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fetchers
+
+import (
+	"os"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDebianParser(t *testing.T) {
+	_, filename, _, _ := runtime.Caller(0)
+
+	// Test parsing testdata/fetcher_debian_test.json
+	testFile, _ := os.Open(path.Join(path.Dir(filename)) + "/testdata/fetcher_debian_test.json")
+	response, err := buildResponse(testFile, "")
+	if assert.Nil(t, err) && assert.Len(t, response.Vulnerabilities, 2) {
+		for _, vulnerability := range response.Vulnerabilities {
+			if vulnerability.ID == "CVE-2015-1323" {
+				assert.Equal(t, "https://security-tracker.debian.org/tracker/CVE-2015-1323", vulnerability.Link)
+				assert.Equal(t, types.Low, vulnerability.Priority)
+				assert.Equal(t, "This vulnerability is not very dangerous.", vulnerability.Description)
+
+				if assert.Len(t, vulnerability.FixedIn, 2) {
+					assert.Contains(t, vulnerability.FixedIn, &database.Package{
+						OS:      "debian:8",
+						Name:    "aptdaemon",
+						Version: types.MaxVersion,
+					})
+					assert.Contains(t, vulnerability.FixedIn, &database.Package{
+						OS:      "debian:unstable",
+						Name:    "aptdaemon",
+						Version: types.NewVersionUnsafe("1.1.1+bzr982-1"),
+					})
+				}
+			} else if vulnerability.ID == "CVE-2003-0779" {
+				assert.Equal(t, "https://security-tracker.debian.org/tracker/CVE-2003-0779", vulnerability.Link)
+				assert.Equal(t, types.High, vulnerability.Priority)
+				assert.Equal(t, "But this one is very dangerous.", vulnerability.Description)
+
+				if assert.Len(t, vulnerability.FixedIn, 3) {
+					assert.Contains(t, vulnerability.FixedIn, &database.Package{
+						OS:      "debian:8",
+						Name:    "aptdaemon",
+						Version: types.NewVersionUnsafe("0.7.0"),
+					})
+					assert.Contains(t, vulnerability.FixedIn, &database.Package{
+						OS:      "debian:unstable",
+						Name:    "aptdaemon",
+						Version: types.NewVersionUnsafe("0.7.0"),
+					})
+					assert.Contains(t, vulnerability.FixedIn, &database.Package{
+						OS:      "debian:8",
+						Name:    "asterisk",
+						Version: types.NewVersionUnsafe("0.5.56"),
+					})
+				}
+			} else {
+				assert.Fail(t, "Wrong vulnerability name: ", vulnerability.ID)
+			}
+		}
+	}
+}
diff --git a/updater/fetchers/fetchers.go b/updater/fetchers/fetchers.go
new file mode 100644
index 00000000..7ed54770
--- /dev/null
+++ b/updater/fetchers/fetchers.go
@@ -0,0 +1,32 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package fetchers implements vulnerability fetchers for several sources.
+package fetchers
+
+import (
+	"errors"
+
+	"github.com/coreos/pkg/capnslog"
+)
+
+var (
+	log = capnslog.NewPackageLogger("github.com/coreos/clair", "updater/fetchers")
+
+	// ErrCouldNotParse is returned when a fetcher fails to parse the update data.
+	ErrCouldNotParse = errors.New("updater/fetchers: could not parse")
+
+	// ErrFilesystem is returned when a fetcher fails to interact with the local filesystem.
+	ErrFilesystem = errors.New("updater/fetchers: something went wrong when interacting with the fs")
+)
diff --git a/updater/fetchers/rhel.go b/updater/fetchers/rhel.go
new file mode 100644
index 00000000..21efc84d
--- /dev/null
+++ b/updater/fetchers/rhel.go
@@ -0,0 +1,353 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fetchers
+
+import (
+	"bufio"
+	"encoding/xml"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/updater"
+	"github.com/coreos/clair/utils/types"
+)
+
+const (
+	// Before this RHSA, it deals only with RHEL <= 4.
+	firstRHEL5RHSA      = 20070044
+	firstConsideredRHEL = 5
+
+	ovalURI         = "https://www.redhat.com/security/data/oval/"
+	rhsaFilePrefix  = "com.redhat.rhsa-"
+	rhelUpdaterFlag = "rhelUpdater"
+)
+
+var (
+	ignoredCriterions = []string{
+		" is signed with Red Hat ",
+		" Client is installed",
+		" Workstation is installed",
+		" ComputeNode is installed",
+	}
+
+	rhsaRegexp = regexp.MustCompile(`com.redhat.rhsa-(\d+).xml`)
+)
+
+type oval struct {
+	Definitions []definition `xml:"definitions>definition"`
+}
+
+type definition struct {
+	Title       string      `xml:"metadata>title"`
+	Description string      `xml:"metadata>description"`
+	References  []reference `xml:"metadata>reference"`
+	Criteria    criteria    `xml:"criteria"`
+}
+
+type reference struct {
+	Source string `xml:"source,attr"`
+	URI    string `xml:"ref_url,attr"`
+}
+
+type criteria struct {
+	Operator   string      `xml:"operator,attr"`
+	Criterias  []*criteria `xml:"criteria"`
+	Criterions []criterion `xml:"criterion"`
+}
+
+type criterion struct {
+	Comment string `xml:"comment,attr"`
+}
+
+// RHELFetcher implements updater.Fetcher and gets vulnerability updates from
+// the Red Hat OVAL definitions.
+type RHELFetcher struct{}
+
+func init() {
+	updater.RegisterFetcher("Red Hat", &RHELFetcher{})
+}
+
+// FetchUpdate gets vulnerability updates from the Red Hat OVAL definitions.
+func (f *RHELFetcher) FetchUpdate() (resp updater.FetcherResponse, err error) {
+	log.Info("fetching Red Hat vulneratibilities")
+
+	// Get the first RHSA we have to manage.
+	flagValue, err := database.GetFlagValue(rhelUpdaterFlag)
+	if err != nil {
+		return resp, err
+	}
+	firstRHSA, err := strconv.Atoi(flagValue)
+	if firstRHSA == 0 || err != nil {
+		firstRHSA = firstRHEL5RHSA
+	}
+
+	// Fetch the update list.
+	r, err := http.Get(ovalURI)
+	if err != nil {
+		log.Errorf("could not download RHEL's update list: %s", err)
+		return resp, cerrors.ErrCouldNotDownload
+	}
+
+	// Get the list of RHSAs that we have to process.
+	var rhsaList []int
+	scanner := bufio.NewScanner(r.Body)
+	for scanner.Scan() {
+		line := scanner.Text()
+		r := rhsaRegexp.FindStringSubmatch(line)
+		if len(r) == 2 {
+			rhsaNo, _ := strconv.Atoi(r[1])
+			if rhsaNo > firstRHSA {
+				rhsaList = append(rhsaList, rhsaNo)
+			}
+		}
+	}
+
+	for _, rhsa := range rhsaList {
+		// Download the RHSA's XML file.
+		r, err := http.Get(ovalURI + rhsaFilePrefix + strconv.Itoa(rhsa) + ".xml")
+		if err != nil {
+			log.Errorf("could not download RHEL's update file: %s", err)
+			return resp, cerrors.ErrCouldNotDownload
+		}
+
+		// Parse the XML.
+		vs, err := parseRHSA(r.Body)
+		if err != nil {
+			return resp, err
+		}
+
+		// Collect vulnerabilities.
+		for _, v := range vs {
+			if len(v.FixedIn) > 0 {
+				resp.Vulnerabilities = append(resp.Vulnerabilities, v)
+			}
+		}
+	}
+
+	// Set the flag if we found anything.
+	if len(rhsaList) > 0 {
+		resp.FlagName = rhelUpdaterFlag
+		resp.FlagValue = strconv.Itoa(rhsaList[len(rhsaList)-1])
+	} else {
+		log.Debug("no Red Hat update.")
+	}
+
+	return resp, nil
+}
+
+func parseRHSA(ovalReader io.Reader) (vulnerabilities []updater.FetcherVulnerability, err error) {
+	// Decode the XML.
+	var ov oval
+	err = xml.NewDecoder(ovalReader).Decode(&ov)
+	if err != nil {
+		log.Errorf("could not decode RHEL's XML: %s.", err)
+		err = ErrCouldNotParse
+		return
+	}
+
+	// Iterate over the definitions and collect any vulnerabilities that affect
+	// more than one package.
+	for _, definition := range ov.Definitions {
+		packages := toPackages(definition.Criteria)
+		if len(packages) > 0 {
+			vuln := updater.FetcherVulnerability{
+				ID:          name(definition),
+				Link:        link(definition),
+				Priority:    priority(definition),
+				Description: description(definition),
+				FixedIn:     packages,
+			}
+			vulnerabilities = append(vulnerabilities, vuln)
+		}
+	}
+
+	return
+}
+
+func getCriterions(node criteria) [][]criterion {
+	// Filter useless criterions.
+	var criterions []criterion
+	for _, c := range node.Criterions {
+		ignored := false
+
+		for _, ignoredItem := range ignoredCriterions {
+			if strings.Contains(c.Comment, ignoredItem) {
+				ignored = true
+				break
+			}
+		}
+
+		if !ignored {
+			criterions = append(criterions, c)
+		}
+	}
+
+	if node.Operator == "AND" {
+		return [][]criterion{criterions}
+	} else if node.Operator == "OR" {
+		var possibilities [][]criterion
+		for _, c := range criterions {
+			possibilities = append(possibilities, []criterion{c})
+		}
+		return possibilities
+	}
+
+	return [][]criterion{}
+}
+
+func getPossibilities(node criteria) [][]criterion {
+	if len(node.Criterias) == 0 {
+		return getCriterions(node)
+	}
+
+	var possibilitiesToCompose [][][]criterion
+	for _, criteria := range node.Criterias {
+		possibilitiesToCompose = append(possibilitiesToCompose, getPossibilities(*criteria))
+	}
+	if len(node.Criterions) > 0 {
+		possibilitiesToCompose = append(possibilitiesToCompose, getCriterions(node))
+	}
+
+	var possibilities [][]criterion
+	if node.Operator == "AND" {
+		for _, possibility := range possibilitiesToCompose[0] {
+			possibilities = append(possibilities, possibility)
+		}
+
+		for _, possibilityGroup := range possibilitiesToCompose[1:] {
+			var newPossibilities [][]criterion
+
+			for _, possibility := range possibilities {
+				for _, possibilityInGroup := range possibilityGroup {
+					var p []criterion
+					p = append(p, possibility...)
+					p = append(p, possibilityInGroup...)
+					newPossibilities = append(newPossibilities, p)
+				}
+			}
+
+			possibilities = newPossibilities
+		}
+	} else if node.Operator == "OR" {
+		for _, possibilityGroup := range possibilitiesToCompose {
+			for _, possibility := range possibilityGroup {
+				possibilities = append(possibilities, possibility)
+			}
+		}
+	}
+
+	return possibilities
+}
+
+func toPackages(criteria criteria) []*database.Package {
+	// There are duplicates in Red Hat .xml files.
+	// This map is for deduplication.
+	packagesParameters := make(map[string]*database.Package)
+
+	possibilities := getPossibilities(criteria)
+	for _, criterions := range possibilities {
+		var (
+			pkg       database.Package
+			osVersion int
+			err       error
+		)
+
+		// Attempt to parse package data from trees of criterions.
+		for _, c := range criterions {
+			if strings.Contains(c.Comment, " is installed") {
+				const prefixLen = len("Red Hat Enterprise Linux ")
+				osVersion, err = strconv.Atoi(strings.TrimSpace(c.Comment[prefixLen : prefixLen+strings.Index(c.Comment[prefixLen:], " ")]))
+				if err != nil {
+					log.Warningf("could not parse Red Hat release version from: '%s'.", c.Comment)
+				}
+			} else if strings.Contains(c.Comment, " is earlier than ") {
+				const prefixLen = len(" is earlier than ")
+				pkg.Name = strings.TrimSpace(c.Comment[:strings.Index(c.Comment, " is earlier than ")])
+				pkg.Version, err = types.NewVersion(c.Comment[strings.Index(c.Comment, " is earlier than ")+prefixLen:])
+				if err != nil {
+					log.Warningf("could not parse package version '%s': %s. skipping", c.Comment[strings.Index(c.Comment, " is earlier than ")+prefixLen:], err.Error())
+				}
+			}
+		}
+
+		if osVersion > firstConsideredRHEL {
+			pkg.OS = "centos" + ":" + strconv.Itoa(osVersion)
+		} else {
+			continue
+		}
+
+		if pkg.OS != "" && pkg.Name != "" && pkg.Version.String() != "" {
+			packagesParameters[pkg.Key()] = &pkg
+		} else {
+			log.Warningf("could not determine a valid package from criterions: %v", criterions)
+		}
+	}
+
+	// Convert the map to slice.
+	var packagesParametersArray []*database.Package
+	for _, p := range packagesParameters {
+		packagesParametersArray = append(packagesParametersArray, p)
+	}
+
+	return packagesParametersArray
+}
+
+func description(def definition) (desc string) {
+	// It is much more faster to proceed like this than using a Replacer.
+	desc = strings.Replace(def.Description, "\n\n\n", " ", -1)
+	desc = strings.Replace(desc, "\n\n", " ", -1)
+	desc = strings.Replace(desc, "\n", " ", -1)
+	return
+}
+
+func name(def definition) string {
+	return strings.TrimSpace(def.Title[:strings.Index(def.Title, ": ")])
+}
+
+func link(def definition) (link string) {
+	for _, reference := range def.References {
+		if reference.Source == "RHSA" {
+			link = reference.URI
+			break
+		}
+	}
+
+	return
+}
+
+func priority(def definition) types.Priority {
+	// Parse the priority.
+	priority := strings.TrimSpace(def.Title[strings.LastIndex(def.Title, "(")+1 : len(def.Title)-1])
+
+	// Normalize the priority.
+	switch priority {
+	case "Low":
+		return types.Low
+	case "Moderate":
+		return types.Medium
+	case "Important":
+		return types.High
+	case "Critical":
+		return types.Critical
+	default:
+		log.Warning("could not determine vulnerability priority from: %s.", priority)
+		return types.Unknown
+	}
+}
diff --git a/updater/fetchers/rhel_test.go b/updater/fetchers/rhel_test.go
new file mode 100644
index 00000000..0a18faec
--- /dev/null
+++ b/updater/fetchers/rhel_test.go
@@ -0,0 +1,82 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fetchers
+
+import (
+	"os"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRHELParser(t *testing.T) {
+	_, filename, _, _ := runtime.Caller(0)
+	path := path.Join(path.Dir(filename))
+
+	// Test parsing testdata/fetcher_rhel_test.1.xml
+	testFile, _ := os.Open(path + "/testdata/fetcher_rhel_test.1.xml")
+	vulnerabilities, err := parseRHSA(testFile)
+	if assert.Nil(t, err) && assert.Len(t, vulnerabilities, 1) {
+		assert.Equal(t, "RHSA-2015:1193", vulnerabilities[0].ID)
+		assert.Equal(t, "https://rhn.redhat.com/errata/RHSA-2015-1193.html", vulnerabilities[0].Link)
+		assert.Equal(t, types.Medium, vulnerabilities[0].Priority)
+		assert.Equal(t, `Xerces-C is a validating XML parser written in a portable subset of C++. A flaw was found in the way the Xerces-C XML parser processed certain XML documents. A remote attacker could provide specially crafted XML input that, when parsed by an application using Xerces-C, would cause that application to crash.`, vulnerabilities[0].Description)
+
+		if assert.Len(t, vulnerabilities[0].FixedIn, 3) {
+			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
+				OS:      "centos:7",
+				Name:    "xerces-c",
+				Version: types.NewVersionUnsafe("3.1.1-7.el7_1"),
+			})
+			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
+				OS:      "centos:7",
+				Name:    "xerces-c-devel",
+				Version: types.NewVersionUnsafe("3.1.1-7.el7_1"),
+			})
+			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
+				OS:      "centos:7",
+				Name:    "xerces-c-doc",
+				Version: types.NewVersionUnsafe("3.1.1-7.el7_1"),
+			})
+		}
+	}
+
+	// Test parsing testdata/fetcher_rhel_test.2.xml
+	testFile, _ = os.Open(path + "/testdata/fetcher_rhel_test.2.xml")
+	vulnerabilities, err = parseRHSA(testFile)
+	if assert.Nil(t, err) && assert.Len(t, vulnerabilities, 1) {
+		assert.Equal(t, "RHSA-2015:1207", vulnerabilities[0].ID)
+		assert.Equal(t, "https://rhn.redhat.com/errata/RHSA-2015-1207.html", vulnerabilities[0].Link)
+		assert.Equal(t, types.Critical, vulnerabilities[0].Priority)
+		assert.Equal(t, `Mozilla Firefox is an open source web browser. XULRunner provides the XUL Runtime environment for Mozilla Firefox. Several flaws were found in the processing of malformed web content. A web page containing malicious content could cause Firefox to crash or, potentially, execute arbitrary code with the privileges of the user running Firefox.`, vulnerabilities[0].Description)
+
+		if assert.Len(t, vulnerabilities[0].FixedIn, 2) {
+			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
+				OS:      "centos:6",
+				Name:    "firefox",
+				Version: types.NewVersionUnsafe("38.1.0-1.el6_6"),
+			})
+			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
+				OS:      "centos:7",
+				Name:    "firefox",
+				Version: types.NewVersionUnsafe("38.1.0-1.el7_1"),
+			})
+		}
+	}
+}
diff --git a/updater/fetchers/testdata/fetcher_debian_test.json b/updater/fetchers/testdata/fetcher_debian_test.json
new file mode 100644
index 00000000..740a44c0
--- /dev/null
+++ b/updater/fetchers/testdata/fetcher_debian_test.json
@@ -0,0 +1,99 @@
+{
+    "aptdaemon": {
+        "CVE-2015-1323": {
+            "_comment": "Two standard cases with a non-fixed package and a fixed one.",
+            "description": "This vulnerability is not very dangerous.",
+            "debianbug": 789162,
+            "releases": {
+               "wheezy": {
+                   "repositories": {
+                       "jessie": "bad version"
+                   },
+                   "status": "resolved",
+                   "urgency": "low**"
+                },
+                "jessie": {
+                    "repositories": {
+                        "jessie": "1.1.1-4"
+                    },
+                    "status": "open",
+                    "urgency": "low**"
+                },
+                "sid": {
+                    "fixed_version": "1.1.1+bzr982-1",
+                    "repositories": {
+                        "sid": "1.1.1+bzr982-1"
+                    },
+                    "status": "resolved",
+                    "urgency": "not yet assigned"
+                }
+            }
+        },
+        "CVE-2003-0779": {
+            "_comment": "Just another CVE affecting the same package.",
+            "description": "But this one is very dangerous.",
+            "releases": {
+                "jessie": {
+                    "fixed_version": "0.7.0",
+                    "repositories": {
+                        "jessie": "1:11.13.1~dfsg-2"
+                    },
+                    "status": "resolved",
+                    "urgency": "high**"
+                },
+                "sid": {
+                    "fixed_version": "0.7.0",
+                    "repositories": {
+                        "sid": "1:13.1.0~dfsg-1.1"
+                    },
+                    "status": "resolved",
+                    "urgency": "high**"
+                }
+            }
+        }
+    },
+    "asterisk": {
+        "CVE-2013-2685": {
+            "description": "Un-affected packages",
+            "releases": {
+                "jessie": {
+                    "fixed_version": "0",
+                    "repositories": {
+                        "jessie": "1:11.13.1~dfsg-2"
+                    },
+                    "status": "resolved",
+                    "urgency": "unimportant"
+                },
+                "wheezy": {
+                    "repositories": {
+                        "sid": "1:13.1.0~dfsg-1.1"
+                    },
+                    "status": "undetermined",
+                    "urgency": "unimportant"
+                },
+                "sid": {
+                    "fixed_version": "0",
+                    "repositories": {
+                        "sid": "1:13.1.0~dfsg-1.1"
+                    },
+                    "status": "resolved",
+                    "urgency": "unimportant"
+                }
+            }
+        },
+        "CVE-2003-0779": {
+            "_comment": "A CVE which affect aptdaemon, and which also affects asterisk",
+            "description": "But this one is very dangerous.",
+            "releases": {
+                "jessie": {
+                    "fixed_version": "0.5.56",
+                    "repositories": {
+                        "jessie": "1:1.17.2"
+                    },
+                    "status": "resolved",
+                    "urgency": "high"
+                }
+            }
+        }
+    }
+}
diff --git a/updater/fetchers/testdata/fetcher_rhel_test.1.xml b/updater/fetchers/testdata/fetcher_rhel_test.1.xml
new file mode 100644
index 00000000..0cfa8674
--- /dev/null
+++ b/updater/fetchers/testdata/fetcher_rhel_test.1.xml
@@ -0,0 +1,154 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<oval_definitions xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5" xmlns:oval="http://oval.mitre.org/XMLSchema/oval-common-5" xmlns:oval-def="http://oval.mitre.org/XMLSchema/oval-definitions-5" xmlns:unix-def="http://oval.mitre.org/XMLSchema/oval-definitions-5#unix" xmlns:red-def="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://oval.mitre.org/XMLSchema/oval-common-5 oval-common-schema.xsd http://oval.mitre.org/XMLSchema/oval-definitions-5 oval-definitions-schema.xsd http://oval.mitre.org/XMLSchema/oval-definitions-5#unix unix-definitions-schema.xsd http://oval.mitre.org/XMLSchema/oval-definitions-5#linux linux-definitions-schema.xsd">
+  <generator>
+    <oval:product_name>Red Hat Errata System</oval:product_name>
+    <oval:schema_version>5.10.1</oval:schema_version>
+    <oval:timestamp>2015-06-29T12:11:23</oval:timestamp>
+  </generator>
+
+  <definitions>
+    <definition id="oval:com.redhat.rhsa:def:20151193" version="601" class="patch">
+      <metadata>
+        <title>RHSA-2015:1193: xerces-c security update (Moderate)</title>
+    <affected family="unix">
+      <platform>Red Hat Enterprise Linux 7</platform>
+    </affected>
+    <reference source="RHSA" ref_id="RHSA-2015:1193-00" ref_url="https://rhn.redhat.com/errata/RHSA-2015-1193.html"/>
+      <reference source="CVE" ref_id="CVE-2015-0252" ref_url="https://access.redhat.com/security/cve/CVE-2015-0252"/>
+    <description>Xerces-C is a validating XML parser written in a portable subset of C++.
+
+A flaw was found in the way the Xerces-C XML parser processed certain XML
+documents. A remote attacker could provide specially crafted XML input
+that, when parsed by an application using Xerces-C, would cause that
+application to crash.</description>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~   advisory details   ~~~~~~~~~~~~~~~~~~~ -->
+
+<advisory from="secalert@redhat.com">
+        <severity>Moderate</severity>
+        <rights>Copyright 2015 Red Hat, Inc.</rights>
+        <issued date="2015-06-29"/>
+        <updated date="2015-06-29"/>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-0252">CVE-2015-0252</cve>
+        <bugzilla href="https://bugzilla.redhat.com/1199103" id="1199103">CVE-2015-0252 xerces-c: crashes on malformed input</bugzilla>
+    <affected_cpe_list>
+        <cpe>cpe:/o:redhat:enterprise_linux:7</cpe>
+    </affected_cpe_list>
+</advisory>
+      </metadata>
+      <criteria operator="AND">
+
+ <criteria operator="OR">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151193001" comment="Red Hat Enterprise Linux 7 Client is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193002" comment="Red Hat Enterprise Linux 7 Server is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193003" comment="Red Hat Enterprise Linux 7 Workstation is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193004" comment="Red Hat Enterprise Linux 7 ComputeNode is installed" />
+
+</criteria>
+<criteria operator="OR">
+
+ <criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151193005" comment="xerces-c is earlier than 0:3.1.1-7.el7_1" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193006" comment="xerces-c is signed with Red Hat redhatrelease2 key" />
+
+</criteria>
+<criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151193007" comment="xerces-c-devel is earlier than 0:3.1.1-7.el7_1" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193008" comment="xerces-c-devel is signed with Red Hat redhatrelease2 key" />
+
+</criteria>
+<criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151193009" comment="xerces-c-doc is earlier than 0:3.1.1-7.el7_1" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193010" comment="xerces-c-doc is signed with Red Hat redhatrelease2 key" />
+
+</criteria>
+<criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151193009" comment="xerces-c-x is earlier than invalid version" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151193010" comment="xerces-c-doc is signed with Red Hat redhatrelease2 key" />
+
+</criteria>
+
+</criteria>
+
+</criteria>
+
+    </definition>
+  </definitions>
+  <tests>
+    <!-- ~~~~~~~~~~~~~~~~~~~~~   rpminfo tests   ~~~~~~~~~~~~~~~~~~~~~ -->
+    <rpminfo_test id="oval:com.redhat.rhsa:tst:20151193001"  version="601" comment="Red Hat Enterprise Linux 7 Client is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193001" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193002" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193002"  version="601" comment="Red Hat Enterprise Linux 7 Server is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193002" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193002" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193003"  version="601" comment="Red Hat Enterprise Linux 7 Workstation is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193003" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193002" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193004"  version="601" comment="Red Hat Enterprise Linux 7 ComputeNode is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193004" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193002" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193005"  version="601" comment="xerces-c is earlier than 0:3.1.1-7.el7_1" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193005" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193003" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193006"  version="601" comment="xerces-c is signed with Red Hat redhatrelease2 key" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193005" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193001" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193007"  version="601" comment="xerces-c-devel is earlier than 0:3.1.1-7.el7_1" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193006" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193003" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193008"  version="601" comment="xerces-c-devel is signed with Red Hat redhatrelease2 key" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193006" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193001" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193009"  version="601" comment="xerces-c-doc is earlier than 0:3.1.1-7.el7_1" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193007" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193003" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151193010"  version="601" comment="xerces-c-doc is signed with Red Hat redhatrelease2 key" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151193007" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151193001" />
+</rpminfo_test>
+
+  </tests>
+
+  <objects>
+    <!-- ~~~~~~~~~~~~~~~~~~~~   rpminfo objects   ~~~~~~~~~~~~~~~~~~~~ -->
+    <rpminfo_object id="oval:com.redhat.rhsa:obj:20151193001"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-client</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151193004"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-computenode</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151193002"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-server</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151193003"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-workstation</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151193005"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>xerces-c</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151193006"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>xerces-c-devel</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151193007"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>xerces-c-doc</name>
+</rpminfo_object>
+
+  </objects>
+  <states>
+    <!-- ~~~~~~~~~~~~~~~~~~~~   rpminfo states   ~~~~~~~~~~~~~~~~~~~~~ -->
+    <rpminfo_state id="oval:com.redhat.rhsa:ste:20151193001"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <signature_keyid  operation="equals">199e2f91fd431d51</signature_keyid>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151193002"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <version  operation="pattern match">^7[^\d]</version>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151193003"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <evr datatype="evr_string" operation="less than">0:3.1.1-7.el7_1</evr>
+</rpminfo_state>
+
+  </states>
+</oval_definitions>
diff --git a/updater/fetchers/testdata/fetcher_rhel_test.2.xml b/updater/fetchers/testdata/fetcher_rhel_test.2.xml
new file mode 100644
index 00000000..32f5aa5d
--- /dev/null
+++ b/updater/fetchers/testdata/fetcher_rhel_test.2.xml
@@ -0,0 +1,224 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<oval_definitions xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5" xmlns:oval="http://oval.mitre.org/XMLSchema/oval-common-5" xmlns:oval-def="http://oval.mitre.org/XMLSchema/oval-definitions-5" xmlns:unix-def="http://oval.mitre.org/XMLSchema/oval-definitions-5#unix" xmlns:red-def="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://oval.mitre.org/XMLSchema/oval-common-5 oval-common-schema.xsd http://oval.mitre.org/XMLSchema/oval-definitions-5 oval-definitions-schema.xsd http://oval.mitre.org/XMLSchema/oval-definitions-5#unix unix-definitions-schema.xsd http://oval.mitre.org/XMLSchema/oval-definitions-5#linux linux-definitions-schema.xsd">
+  <generator>
+    <oval:product_name>Red Hat Errata System</oval:product_name>
+    <oval:schema_version>5.10.1</oval:schema_version>
+    <oval:timestamp>2015-07-03T01:12:29</oval:timestamp>
+  </generator>
+
+  <definitions>
+    <definition id="oval:com.redhat.rhsa:def:20151207" version="601" class="patch">
+      <metadata>
+        <title>RHSA-2015:1207: firefox security update (Critical)</title>
+    <affected family="unix">
+      <platform>Red Hat Enterprise Linux 7</platform>
+      <platform>Red Hat Enterprise Linux 6</platform>
+      <platform>Red Hat Enterprise Linux 5</platform>
+    </affected>
+    <reference source="RHSA" ref_id="RHSA-2015:1207-00" ref_url="https://rhn.redhat.com/errata/RHSA-2015-1207.html"/>
+      <reference source="CVE" ref_id="CVE-2015-2722" ref_url="https://access.redhat.com/security/cve/CVE-2015-2722"/>
+      <reference source="CVE" ref_id="CVE-2015-2724" ref_url="https://access.redhat.com/security/cve/CVE-2015-2724"/>
+      <reference source="CVE" ref_id="CVE-2015-2725" ref_url="https://access.redhat.com/security/cve/CVE-2015-2725"/>
+      <reference source="CVE" ref_id="CVE-2015-2727" ref_url="https://access.redhat.com/security/cve/CVE-2015-2727"/>
+      <reference source="CVE" ref_id="CVE-2015-2728" ref_url="https://access.redhat.com/security/cve/CVE-2015-2728"/>
+      <reference source="CVE" ref_id="CVE-2015-2729" ref_url="https://access.redhat.com/security/cve/CVE-2015-2729"/>
+      <reference source="CVE" ref_id="CVE-2015-2731" ref_url="https://access.redhat.com/security/cve/CVE-2015-2731"/>
+      <reference source="CVE" ref_id="CVE-2015-2733" ref_url="https://access.redhat.com/security/cve/CVE-2015-2733"/>
+      <reference source="CVE" ref_id="CVE-2015-2734" ref_url="https://access.redhat.com/security/cve/CVE-2015-2734"/>
+      <reference source="CVE" ref_id="CVE-2015-2735" ref_url="https://access.redhat.com/security/cve/CVE-2015-2735"/>
+      <reference source="CVE" ref_id="CVE-2015-2736" ref_url="https://access.redhat.com/security/cve/CVE-2015-2736"/>
+      <reference source="CVE" ref_id="CVE-2015-2737" ref_url="https://access.redhat.com/security/cve/CVE-2015-2737"/>
+      <reference source="CVE" ref_id="CVE-2015-2738" ref_url="https://access.redhat.com/security/cve/CVE-2015-2738"/>
+      <reference source="CVE" ref_id="CVE-2015-2739" ref_url="https://access.redhat.com/security/cve/CVE-2015-2739"/>
+      <reference source="CVE" ref_id="CVE-2015-2740" ref_url="https://access.redhat.com/security/cve/CVE-2015-2740"/>
+      <reference source="CVE" ref_id="CVE-2015-2741" ref_url="https://access.redhat.com/security/cve/CVE-2015-2741"/>
+      <reference source="CVE" ref_id="CVE-2015-2743" ref_url="https://access.redhat.com/security/cve/CVE-2015-2743"/>
+    <description>Mozilla Firefox is an open source web browser. XULRunner provides the XUL
+Runtime environment for Mozilla Firefox.
+
+
+Several flaws were found in the processing of malformed web content. A web
+page containing malicious content could cause Firefox to crash or,
+potentially, execute arbitrary code with the privileges of the user running
+Firefox.</description>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~   advisory details   ~~~~~~~~~~~~~~~~~~~ -->
+
+<advisory from="secalert@redhat.com">
+        <severity>Critical</severity>
+        <rights>Copyright 2015 Red Hat, Inc.</rights>
+        <issued date="2015-07-02"/>
+        <updated date="2015-07-02"/>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2722">CVE-2015-2722</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2724">CVE-2015-2724</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2725">CVE-2015-2725</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2727">CVE-2015-2727</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2728">CVE-2015-2728</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2729">CVE-2015-2729</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2731">CVE-2015-2731</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2733">CVE-2015-2733</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2734">CVE-2015-2734</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2735">CVE-2015-2735</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2736">CVE-2015-2736</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2737">CVE-2015-2737</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2738">CVE-2015-2738</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2739">CVE-2015-2739</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2740">CVE-2015-2740</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2741">CVE-2015-2741</cve>
+        <cve href="https://access.redhat.com/security/cve/CVE-2015-2743">CVE-2015-2743</cve>
+        <bugzilla href="https://bugzilla.redhat.com/1236947" id="1236947">CVE-2015-2724 CVE-2015-2725 Mozilla: Miscellaneous memory safety hazards (rv:31.8 / rv:38.1) (MFSA 2015-59)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236950" id="1236950">CVE-2015-2727 Mozilla: Local files or privileged URLs in pages can be opened into new tabs (MFSA 2015-60)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236951" id="1236951">CVE-2015-2728 Mozilla: Type confusion in Indexed Database Manager (MFSA 2015-61)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236952" id="1236952">CVE-2015-2729 Mozilla: Out-of-bound read while computing an oscillator rendering range in Web Audio (MFSA 2015-62)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236953" id="1236953">CVE-2015-2731 Mozilla: Use-after-free in Content Policy due to microtask execution error (MFSA 2015-63)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236955" id="1236955">CVE-2015-2722 CVE-2015-2733 Mozilla: Use-after-free in workers while using XMLHttpRequest (MFSA 2015-65)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236956" id="1236956">CVE-2015-2734 CVE-2015-2735 CVE-2015-2736 CVE-2015-2737 CVE-2015-2738 CVE-2015-2739 CVE-2015-2740 Mozilla: Vulnerabilities found through code inspection (MFSA 2015-66)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236963" id="1236963">CVE-2015-2741 Mozilla: Key pinning is ignored when overridable errors are encountered (MFSA 2015-67)</bugzilla>
+        <bugzilla href="https://bugzilla.redhat.com/1236964" id="1236964">CVE-2015-2743 Mozilla: Privilege escalation in PDF.js (MFSA 2015-69)</bugzilla>
+    <affected_cpe_list>
+        <cpe>cpe:/o:redhat:enterprise_linux:5</cpe>
+        <cpe>cpe:/o:redhat:enterprise_linux:6</cpe>
+        <cpe>cpe:/o:redhat:enterprise_linux:7</cpe>
+    </affected_cpe_list>
+</advisory>
+      </metadata>
+      <criteria operator="OR">
+
+ <criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151207001" comment="Red Hat Enterprise Linux 5 is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207002" comment="firefox is earlier than 0:38.1.0-1.el5_11" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207003" comment="firefox is signed with Red Hat redhatrelease key" />
+
+</criteria>
+<criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151207008" comment="firefox is earlier than 0:38.1.0-1.el6_6" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207009" comment="firefox is signed with Red Hat redhatrelease2 key" />
+ <criteria operator="OR">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151207004" comment="Red Hat Enterprise Linux 6 Client is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207005" comment="Red Hat Enterprise Linux 6 Server is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207006" comment="Red Hat Enterprise Linux 6 Workstation is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207007" comment="Red Hat Enterprise Linux 6 ComputeNode is installed" />
+
+</criteria>
+
+</criteria>
+<criteria operator="AND">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151207014" comment="firefox is earlier than 0:38.1.0-1.el7_1" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207009" comment="firefox is signed with Red Hat redhatrelease2 key" />
+ <criteria operator="OR">
+ <criterion test_ref="oval:com.redhat.rhsa:tst:20151207010" comment="Red Hat Enterprise Linux 7 Client is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207011" comment="Red Hat Enterprise Linux 7 Server is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207012" comment="Red Hat Enterprise Linux 7 Workstation is installed" /><criterion test_ref="oval:com.redhat.rhsa:tst:20151207013" comment="Red Hat Enterprise Linux 7 ComputeNode is installed" />
+
+</criteria>
+
+</criteria>
+
+</criteria>
+
+    </definition>
+  </definitions>
+  <tests>
+    <!-- ~~~~~~~~~~~~~~~~~~~~~   rpminfo tests   ~~~~~~~~~~~~~~~~~~~~~ -->
+    <rpminfo_test id="oval:com.redhat.rhsa:tst:20151207001"  version="601" comment="Red Hat Enterprise Linux 5 is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207001" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207003" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207002"  version="601" comment="firefox is earlier than 0:38.1.0-1.el5_11" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207002" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207004" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207003"  version="601" comment="firefox is signed with Red Hat redhatrelease key" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207002" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207002" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207004"  version="601" comment="Red Hat Enterprise Linux 6 Client is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207003" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207005" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207005"  version="601" comment="Red Hat Enterprise Linux 6 Server is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207004" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207005" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207006"  version="601" comment="Red Hat Enterprise Linux 6 Workstation is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207005" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207005" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207007"  version="601" comment="Red Hat Enterprise Linux 6 ComputeNode is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207006" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207005" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207008"  version="601" comment="firefox is earlier than 0:38.1.0-1.el6_6" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207002" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207006" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207009"  version="601" comment="firefox is signed with Red Hat redhatrelease2 key" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207002" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207001" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207010"  version="601" comment="Red Hat Enterprise Linux 7 Client is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207003" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207007" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207011"  version="601" comment="Red Hat Enterprise Linux 7 Server is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207004" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207007" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207012"  version="601" comment="Red Hat Enterprise Linux 7 Workstation is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207005" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207007" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207013"  version="601" comment="Red Hat Enterprise Linux 7 ComputeNode is installed" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207006" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207007" />
+</rpminfo_test>
+<rpminfo_test id="oval:com.redhat.rhsa:tst:20151207014"  version="601" comment="firefox is earlier than 0:38.1.0-1.el7_1" check="at least one" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <object object_ref="oval:com.redhat.rhsa:obj:20151207002" />
+  <state state_ref="oval:com.redhat.rhsa:ste:20151207008" />
+</rpminfo_test>
+
+  </tests>
+
+  <objects>
+    <!-- ~~~~~~~~~~~~~~~~~~~~   rpminfo objects   ~~~~~~~~~~~~~~~~~~~~ -->
+    <rpminfo_object id="oval:com.redhat.rhsa:obj:20151207002"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>firefox</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151207001"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151207003"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-client</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151207006"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-computenode</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151207004"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-server</name>
+</rpminfo_object>
+<rpminfo_object id="oval:com.redhat.rhsa:obj:20151207005"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <name>redhat-release-workstation</name>
+</rpminfo_object>
+
+  </objects>
+  <states>
+    <!-- ~~~~~~~~~~~~~~~~~~~~   rpminfo states   ~~~~~~~~~~~~~~~~~~~~~ -->
+    <rpminfo_state id="oval:com.redhat.rhsa:ste:20151207001"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <signature_keyid  operation="equals">199e2f91fd431d51</signature_keyid>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207002"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <signature_keyid  operation="equals">5326810137017186</signature_keyid>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207003"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <version  operation="pattern match">^5[^\d]</version>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207004"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <evr datatype="evr_string" operation="less than">0:38.1.0-1.el5_11</evr>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207005"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <version  operation="pattern match">^6[^\d]</version>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207006"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <evr datatype="evr_string" operation="less than">0:38.1.0-1.el6_6</evr>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207007"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <version  operation="pattern match">^7[^\d]</version>
+</rpminfo_state>
+<rpminfo_state id="oval:com.redhat.rhsa:ste:20151207008"  version="601" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#linux">
+  <evr datatype="evr_string" operation="less than">0:38.1.0-1.el7_1</evr>
+</rpminfo_state>
+
+  </states>
+</oval_definitions>
diff --git a/updater/fetchers/testdata/fetcher_ubuntu_test.txt b/updater/fetchers/testdata/fetcher_ubuntu_test.txt
new file mode 100644
index 00000000..952f1095
--- /dev/null
+++ b/updater/fetchers/testdata/fetcher_ubuntu_test.txt
@@ -0,0 +1,35 @@
+Candidate: CVE-2015-4471
+PublicDate: 2015-06-11
+References:
+ http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-4471
+ http://www.openwall.com/lists/oss-security/2015/02/03/11
+ https://github.com/kyz/libmspack/commit/18b6a2cc0b87536015bedd4f7763e6b02d5aa4f3
+ https://bugs.debian.org/775499
+ http://openwall.com/lists/oss-security/2015/02/03/11
+Description:
+ Off-by-one error in the lzxd_decompress function in lzxd.c in libmspack
+ before 0.5 allows remote attackers to cause a denial of service (buffer
+ under-read and application crash) via a crafted CAB archive.
+Ubuntu-Description:
+Notes:
+Bugs:
+ http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=775499
+Priority: medium (wrong-syntax)
+Discovered-by:
+Assigned-to:
+
+Patches_libmspack:
+upstream_libmspack: not-affected (0.5-1)
+precise_libmspack: DNE
+trusty_libmspack: needed
+utopic_libmspack: ignored (reached end-of-life)
+vivid_libmspack : released ( 0.4-3 )
+devel_libmspack: not-affected
+unknown_libmspack: needed
+
+Patches_libmspack-anotherpkg: wrong-syntax
+wily_libmspack-anotherpkg: released ((0.1)
+utopic_libmspack-anotherpkg: not-affected
+trusty_libmspack-anotherpkg: needs-triage
+precise_libmspack-anotherpkg: released
+saucy_libmspack-anotherpkg: needed
diff --git a/updater/fetchers/ubuntu.go b/updater/fetchers/ubuntu.go
new file mode 100644
index 00000000..5486ab3d
--- /dev/null
+++ b/updater/fetchers/ubuntu.go
@@ -0,0 +1,414 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fetchers
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/updater"
+	"github.com/coreos/clair/utils"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils/types"
+)
+
+const (
+	ubuntuTrackerURI  = "https://launchpad.net/ubuntu-cve-tracker"
+	ubuntuTracker     = "lp:ubuntu-cve-tracker"
+	ubuntuUpdaterFlag = "ubuntuUpdater"
+)
+
+var (
+	repositoryLocalPath string
+
+	ubuntuIgnoredReleases = map[string]struct{}{
+		"upstream": struct{}{},
+		"devel":    struct{}{},
+
+		"dapper":   struct{}{},
+		"edgy":     struct{}{},
+		"feisty":   struct{}{},
+		"gutsy":    struct{}{},
+		"hardy":    struct{}{},
+		"intrepid": struct{}{},
+		"jaunty":   struct{}{},
+		"karmic":   struct{}{},
+		"lucid":    struct{}{},
+		"maverick": struct{}{},
+		"natty":    struct{}{},
+		"oneiric":  struct{}{},
+		"saucy":    struct{}{},
+
+		// Syntax error
+		"Patches": struct{}{},
+		// Product
+		"product": struct{}{},
+	}
+
+	branchedRegexp            = regexp.MustCompile(`Branched (\d+) revisions.`)
+	revisionRegexp            = regexp.MustCompile(`Now on revision (\d+).`)
+	affectsCaptureRegexp      = regexp.MustCompile(`(?P<release>.*)_(?P<package>.*): (?P<status>[^\s]*)( \(+(?P<note>[^()]*)\)+)?`)
+	affectsCaptureRegexpNames = affectsCaptureRegexp.SubexpNames()
+)
+
+// UbuntuFetcher implements updater.Fetcher and get vulnerability updates from
+// the Ubuntu CVE Tracker.
+type UbuntuFetcher struct{}
+
+func init() {
+	updater.RegisterFetcher("Ubuntu", &UbuntuFetcher{})
+}
+
+// FetchUpdate gets vulnerability updates from the Ubuntu CVE Tracker.
+func (fetcher *UbuntuFetcher) FetchUpdate() (resp updater.FetcherResponse, err error) {
+	log.Info("fetching Ubuntu vulneratibilities")
+
+	// Check to see if the repository does not already exist.
+	var revisionNumber int
+	if _, pathExists := os.Stat(repositoryLocalPath); repositoryLocalPath == "" || os.IsNotExist(pathExists) {
+		// Create a temporary folder and download the repository.
+		p, err := ioutil.TempDir(os.TempDir(), "ubuntu-cve-tracker")
+		if err != nil {
+			return resp, ErrFilesystem
+		}
+
+		// bzr wants an empty target directory.
+		repositoryLocalPath = p + "/repository"
+
+		// Create the new repository.
+		revisionNumber, err = createRepository(repositoryLocalPath)
+		if err != nil {
+			return resp, err
+		}
+	} else {
+		// Update the repository that's already on disk.
+		revisionNumber, err = updateRepository(repositoryLocalPath)
+		if err != nil {
+			return resp, err
+		}
+	}
+
+	// Get the latest revision number we successfully applied in the database.
+	dbRevisionNumber, err := database.GetFlagValue("ubuntuUpdater")
+	if err != nil {
+		return resp, err
+	}
+
+	// Get the list of vulnerabilities that we have to update.
+	modifiedCVE, err := collectModifiedVulnerabilities(revisionNumber, dbRevisionNumber, repositoryLocalPath)
+	if err != nil {
+		return resp, err
+	}
+
+	// Parse and add the vulnerabilities.
+	for cvePath := range modifiedCVE {
+		file, err := os.Open(repositoryLocalPath + "/" + cvePath)
+		if err != nil {
+			// This can happen when a file is modified and then moved in another
+			// commit.
+			continue
+		}
+		defer file.Close()
+
+		v, unknownReleases, err := parseUbuntuCVE(file)
+		if err != nil {
+			return resp, err
+		}
+
+		if len(v.FixedIn) > 0 {
+			resp.Vulnerabilities = append(resp.Vulnerabilities, v)
+		}
+
+		// Log any unknown releases.
+		for k := range unknownReleases {
+			note := fmt.Sprintf("Ubuntu %s is not mapped to any version number (eg. trusty->14.04). Please update me.", k)
+			resp.Notes = append(resp.Notes, note)
+			log.Warning(note)
+
+			// If we encountered unknown Ubuntu release, we don't want the revision
+			// number to be considered as managed.
+			dbRevisionNumberInt, _ := strconv.Atoi(dbRevisionNumber)
+			revisionNumber = dbRevisionNumberInt
+		}
+	}
+
+	// Add flag information
+	resp.FlagName = ubuntuUpdaterFlag
+	resp.FlagValue = strconv.Itoa(revisionNumber)
+
+	return
+}
+
+func collectModifiedVulnerabilities(revision int, dbRevision, repositoryLocalPath string) (map[string]struct{}, error) {
+	modifiedCVE := make(map[string]struct{})
+
+	// Handle a brand new database.
+	if dbRevision == "" {
+		for _, folder := range []string{"active", "retired"} {
+			d, err := os.Open(repositoryLocalPath + "/" + folder)
+			if err != nil {
+				log.Errorf("could not open Ubuntu vulnerabilities repository's folder: %s", err)
+				return nil, ErrFilesystem
+			}
+			defer d.Close()
+
+			// Get the FileInfo of all the files in the directory.
+			names, err := d.Readdirnames(-1)
+			if err != nil {
+				log.Errorf("could not read Ubuntu vulnerabilities repository's folder:: %s.", err)
+				return nil, ErrFilesystem
+			}
+
+			// Add the vulnerabilities to the list.
+			for _, name := range names {
+				if strings.HasPrefix(name, "CVE-") {
+					modifiedCVE[folder+"/"+name] = struct{}{}
+				}
+			}
+		}
+
+		return modifiedCVE, nil
+	}
+
+	// Handle an up to date database.
+	dbRevisionInt, _ := strconv.Atoi(dbRevision)
+	if revision == dbRevisionInt {
+		log.Debug("no Ubuntu update")
+		return modifiedCVE, nil
+	}
+
+	// Handle a database that needs upgrading.
+	out, err := utils.Exec(repositoryLocalPath, "bzr", "log", "--verbose", "-r"+strconv.Itoa(dbRevisionInt+1)+"..", "-n0")
+	if err != nil {
+		log.Errorf("could not get Ubuntu vulnerabilities repository logs: %s. output: %s", err, string(out))
+		return nil, cerrors.ErrCouldNotDownload
+	}
+
+	scanner := bufio.NewScanner(bytes.NewReader(out))
+	for scanner.Scan() {
+		text := strings.TrimSpace(scanner.Text())
+		if strings.Contains(text, "CVE-") && (strings.HasPrefix(text, "active/") || strings.HasPrefix(text, "retired/")) {
+			if strings.Contains(text, " => ") {
+				text = text[strings.Index(text, " => ")+4:]
+			}
+			modifiedCVE[text] = struct{}{}
+		}
+	}
+
+	return modifiedCVE, nil
+}
+
+func createRepository(pathToRepo string) (int, error) {
+	// Branch repository
+	out, err := utils.Exec("/tmp/", "bzr", "branch", ubuntuTracker, pathToRepo)
+	if err != nil {
+		log.Errorf("could not branch Ubuntu repository: %s. output: %s", err, string(out))
+		return 0, cerrors.ErrCouldNotDownload
+	}
+
+	// Get revision number
+	regexpMatches := branchedRegexp.FindStringSubmatch(string(out))
+	if len(regexpMatches) != 2 {
+		log.Error("could not parse bzr branch output to get the revision number")
+		return 0, cerrors.ErrCouldNotDownload
+	}
+
+	revision, err := strconv.Atoi(regexpMatches[1])
+	if err != nil {
+		log.Error("could not parse bzr branch output to get the revision number")
+		return 0, cerrors.ErrCouldNotDownload
+	}
+
+	return revision, err
+}
+
+func updateRepository(pathToRepo string) (int, error) {
+	// Pull repository
+	out, err := utils.Exec(pathToRepo, "bzr", "pull", "--overwrite")
+	if err != nil {
+		log.Errorf("could not pull Ubuntu repository: %s. output: %s", err, string(out))
+		return 0, cerrors.ErrCouldNotDownload
+	}
+
+	// Get revision number
+	if strings.Contains(string(out), "No revisions or tags to pull") {
+		out, _ = utils.Exec(pathToRepo, "bzr", "revno")
+		revno, err := strconv.Atoi(string(out[:len(out)-1]))
+		if err != nil {
+			log.Errorf("could not parse Ubuntu repository revision number: %s. output: %s", err, string(out))
+			return 0, cerrors.ErrCouldNotDownload
+		}
+		return revno, nil
+	}
+
+	regexpMatches := revisionRegexp.FindStringSubmatch(string(out))
+	if len(regexpMatches) != 2 {
+		log.Error("could not parse bzr pull output to get the revision number")
+		return 0, cerrors.ErrCouldNotDownload
+	}
+
+	revno, err := strconv.Atoi(regexpMatches[1])
+	if err != nil {
+		log.Error("could not parse bzr pull output to get the revision number")
+		return 0, cerrors.ErrCouldNotDownload
+	}
+
+	return revno, nil
+}
+
+func parseUbuntuCVE(fileContent io.Reader) (vulnerability updater.FetcherVulnerability, unknownReleases map[string]struct{}, err error) {
+	unknownReleases = make(map[string]struct{})
+	readingDescription := false
+	scanner := bufio.NewScanner(fileContent)
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		// Skip any comments.
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Parse the name.
+		if strings.HasPrefix(line, "Candidate:") {
+			vulnerability.ID = strings.TrimSpace(strings.TrimPrefix(line, "Candidate:"))
+			continue
+		}
+
+		// Parse the link.
+		if vulnerability.Link == "" && strings.HasPrefix(line, "http") {
+			vulnerability.Link = strings.TrimSpace(line)
+			continue
+		}
+
+		// Parse the priority.
+		if strings.HasPrefix(line, "Priority:") {
+			priority := strings.TrimSpace(strings.TrimPrefix(line, "Priority:"))
+
+			// Handle syntax error: Priority: medium (heap-protector)
+			if strings.Contains(priority, " ") {
+				priority = priority[:strings.Index(priority, " ")]
+			}
+
+			vulnerability.Priority = ubuntuPriorityToPriority(priority)
+			continue
+		}
+
+		// Parse the description.
+		if strings.HasPrefix(line, "Description:") {
+			readingDescription = true
+			vulnerability.Description = strings.TrimSpace(strings.TrimPrefix(line, "Description:")) // In case there is a formatting error and the description starts on the same line
+			continue
+		}
+		if readingDescription {
+			if strings.HasPrefix(line, "Ubuntu-Description:") || strings.HasPrefix(line, "Notes:") || strings.HasPrefix(line, "Bugs:") || strings.HasPrefix(line, "Priority:") || strings.HasPrefix(line, "Discovered-by:") || strings.HasPrefix(line, "Assigned-to:") {
+				readingDescription = false
+			} else {
+				vulnerability.Description = vulnerability.Description + " " + line
+				continue
+			}
+		}
+
+		// Try to parse the package that the vulnerability affects.
+		affectsCaptureArr := affectsCaptureRegexp.FindAllStringSubmatch(line, -1)
+		if len(affectsCaptureArr) > 0 {
+			affectsCapture := affectsCaptureArr[0]
+
+			md := map[string]string{}
+			for i, n := range affectsCapture {
+				md[affectsCaptureRegexpNames[i]] = strings.TrimSpace(n)
+			}
+
+			// Ignore Linux kernels.
+			if strings.HasPrefix(md["package"], "linux") {
+				continue
+			}
+
+			// Only consider the package if its status is needed, active, deferred
+			// or released. Ignore DNE, needs-triage, not-affected, ignored, pending.
+			if md["status"] == "needed" || md["status"] == "active" || md["status"] == "deferred" || md["status"] == "released" {
+				if _, isReleaseIgnored := ubuntuIgnoredReleases[md["release"]]; isReleaseIgnored {
+					continue
+				}
+				if _, isReleaseKnown := database.UbuntuReleasesMapping[md["release"]]; !isReleaseKnown {
+					unknownReleases[md["release"]] = struct{}{}
+					continue
+				}
+
+				var version types.Version
+				if md["status"] == "released" {
+					if md["note"] != "" {
+						var err error
+						version, err = types.NewVersion(md["note"])
+						if err != nil {
+							log.Warningf("could not parse package version '%s': %s. skipping", md["note"], err)
+						}
+					}
+				} else {
+					version = types.MaxVersion
+				}
+				if version.String() == "" {
+					continue
+				}
+
+				// Create and add the new package.
+				vulnerability.FixedIn = append(vulnerability.FixedIn, &database.Package{OS: "ubuntu:" + database.UbuntuReleasesMapping[md["release"]], Name: md["package"], Version: version})
+			}
+		}
+	}
+
+	// Trim extra spaces in the description
+	vulnerability.Description = strings.TrimSpace(vulnerability.Description)
+
+	// If no link has been provided (CVE-2006-NNN0 for instance), add the link to the tracker
+	if vulnerability.Link == "" {
+		vulnerability.Link = ubuntuTrackerURI
+	}
+
+	// If no priority has been provided (CVE-2007-0667 for instance), set the priority to Unknown
+	if vulnerability.Priority == "" {
+		vulnerability.Priority = types.Unknown
+	}
+
+	return
+}
+
+func ubuntuPriorityToPriority(priority string) types.Priority {
+	switch priority {
+	case "untriaged":
+		return types.Unknown
+	case "negligible":
+		return types.Negligible
+	case "low":
+		return types.Low
+	case "medium":
+		return types.Medium
+	case "high":
+		return types.High
+	case "critical":
+		return types.Critical
+	}
+
+	log.Warning("Could not determine a vulnerability priority from: %s", priority)
+	return types.Unknown
+}
diff --git a/updater/fetchers/ubuntu_test.go b/updater/fetchers/ubuntu_test.go
new file mode 100644
index 00000000..446e2152
--- /dev/null
+++ b/updater/fetchers/ubuntu_test.go
@@ -0,0 +1,63 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fetchers
+
+import (
+	"os"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUbuntuParser(t *testing.T) {
+	_, filename, _, _ := runtime.Caller(0)
+	path := path.Join(path.Dir(filename))
+
+	// Test parsing testdata/fetcher_
+	testData, _ := os.Open(path + "/testdata/fetcher_ubuntu_test.txt")
+	defer testData.Close()
+	vulnerability, unknownReleases, err := parseUbuntuCVE(testData)
+	if assert.Nil(t, err) {
+		assert.Equal(t, "CVE-2015-4471", vulnerability.ID)
+		assert.Equal(t, types.Medium, vulnerability.Priority)
+		assert.Equal(t, "Off-by-one error in the lzxd_decompress function in lzxd.c in libmspack before 0.5 allows remote attackers to cause a denial of service (buffer under-read and application crash) via a crafted CAB archive.", vulnerability.Description)
+
+		// Unknown release (line 28)
+		_, hasUnkownRelease := unknownReleases["unknown"]
+		assert.True(t, hasUnkownRelease)
+
+		if assert.Len(t, vulnerability.FixedIn, 3) {
+			assert.Contains(t, vulnerability.FixedIn, &database.Package{
+				OS:      "ubuntu:14.04",
+				Name:    "libmspack",
+				Version: types.MaxVersion,
+			})
+			assert.Contains(t, vulnerability.FixedIn, &database.Package{
+				OS:      "ubuntu:15.04",
+				Name:    "libmspack",
+				Version: types.NewVersionUnsafe("0.4-3"),
+			})
+			assert.Contains(t, vulnerability.FixedIn, &database.Package{
+				OS:      "ubuntu:15.10",
+				Name:    "libmspack-anotherpkg",
+				Version: types.NewVersionUnsafe("0.1"),
+			})
+		}
+	}
+}
diff --git a/updater/updater.go b/updater/updater.go
new file mode 100644
index 00000000..8c2fe245
--- /dev/null
+++ b/updater/updater.go
@@ -0,0 +1,286 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package updater updates the vulnerability database periodically using
+// the registered vulnerability fetchers.
+package updater
+
+import (
+	"math/rand"
+	"strconv"
+	"time"
+
+	"github.com/coreos/pkg/capnslog"
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/health"
+	"github.com/coreos/clair/utils"
+	"github.com/pborman/uuid"
+)
+
+const (
+	flagName            = "updater"
+	refreshLockDuration = time.Minute * 8
+	lockDuration        = refreshLockDuration + time.Minute*2
+
+	// healthMaxConsecutiveLocalFailures defines the number of times the updater
+	// can fail before we should tag it as unhealthy
+	healthMaxConsecutiveLocalFailures = 5
+)
+
+var (
+	log = capnslog.NewPackageLogger("github.com/coreos/clair", "updater")
+
+	healthLatestSuccessfulUpdate   time.Time
+	healthLockOwner                string
+	healthIdentifier               string
+	healthConsecutiveLocalFailures int
+	healthNotes                    []string
+)
+
+func init() {
+	health.RegisterHealthchecker("updater", Healthcheck)
+}
+
+// Run updates the vulnerability database at regular intervals
+func Run(interval time.Duration, st *utils.Stopper) {
+	defer st.End()
+
+	// Do not run the updater if the interval is 0
+	if interval == 0 {
+		log.Infof("updater service is disabled.")
+		return
+	}
+
+	whoAmI := uuid.New()
+	healthIdentifier = whoAmI
+	log.Infof("updater service started. lock identifier: %s", whoAmI)
+
+	for {
+		// Set the next update time to (last update time + interval) or now if there
+		// is no last update time stored in database (first update) or if an error
+		// occurs
+		nextUpdate := time.Now().UTC()
+		if lastUpdateTSS, err := database.GetFlagValue(flagName); err == nil && lastUpdateTSS != "" {
+			if lastUpdateTS, err := strconv.ParseInt(lastUpdateTSS, 10, 64); err == nil {
+				healthLatestSuccessfulUpdate = time.Unix(lastUpdateTS, 0)
+				nextUpdate = time.Unix(lastUpdateTS, 0).Add(interval)
+			}
+		}
+
+		// If the next update timer is in the past, then try to update.
+		if nextUpdate.Before(time.Now().UTC()) {
+			// Attempt to get a lock on the the update.
+			log.Debug("attempting to obtain update lock")
+			hasLock, hasLockUntil := database.Lock(flagName, lockDuration, whoAmI)
+			if hasLock {
+				healthLockOwner = healthIdentifier
+
+				// Launch update in a new go routine.
+				doneC := make(chan bool, 1)
+				go func() {
+					Update()
+					doneC <- true
+				}()
+
+				// Refresh the lock until the update is done.
+				for done := false; !done; {
+					select {
+					case <-doneC:
+						done = true
+					case <-time.After(refreshLockDuration):
+						database.Lock(flagName, lockDuration, whoAmI)
+					}
+				}
+
+				// Write the last update time to the database and set the next update
+				// time.
+				now := time.Now().UTC()
+				database.UpdateFlag(flagName, strconv.FormatInt(now.Unix(), 10))
+				healthLatestSuccessfulUpdate = now
+				nextUpdate = now.Add(interval)
+
+				// Unlock the update.
+				database.Unlock(flagName, whoAmI)
+			} else {
+				lockOwner, lockExpiration, err := database.LockInfo(flagName)
+				if err != nil {
+					log.Debug("update lock is already taken")
+					nextUpdate = hasLockUntil
+				} else {
+					log.Debugf("update lock is already taken by %s until %v", lockOwner, lockExpiration)
+					nextUpdate = lockExpiration
+					healthLockOwner = lockOwner
+				}
+			}
+		}
+
+		// Sleep, but remain stoppable until approximately the next update time.
+		now := time.Now().UTC()
+		waitUntil := nextUpdate.Add(time.Duration(rand.ExpFloat64()/0.5) * time.Second)
+		log.Debugf("next update attempt scheduled for %v.", waitUntil)
+		if !waitUntil.Before(now) {
+			if !st.Sleep(waitUntil.Sub(time.Now())) {
+				break
+			}
+		}
+	}
+
+	log.Info("updater service stopped")
+}
+
+// Update fetches all the vulnerabilities from the registered fetchers, upserts
+// them into the database and then sends notifications.
+func Update() {
+	log.Info("updating vulnerabilities")
+
+	// Fetch updates in parallel.
+	var status = true
+	var responseC = make(chan *FetcherResponse, 0)
+	for n, f := range fetchers {
+		go func(name string, fetcher Fetcher) {
+			response, err := fetcher.FetchUpdate()
+			if err != nil {
+				log.Errorf("an error occured when fetching update '%s': %s.", name, err)
+				status = false
+				responseC <- nil
+				return
+			}
+
+			responseC <- &response
+		}(n, f)
+	}
+
+	// Collect results of updates.
+	var responses []*FetcherResponse
+	var notes []string
+	for i := 0; i < len(fetchers); {
+		select {
+		case resp := <-responseC:
+			if resp != nil {
+				responses = append(responses, resp)
+				notes = append(notes, resp.Notes...)
+			}
+			i++
+		}
+	}
+
+	close(responseC)
+
+	// TODO(Quentin-M): Merge responses together
+	// TODO(Quentin-M): Complete informations using NVD
+
+	// Store flags out of the response struct.
+	flags := make(map[string]string)
+	for _, response := range responses {
+		if response.FlagName != "" && response.FlagValue != "" {
+			flags[response.FlagName] = response.FlagValue
+		}
+	}
+
+	// Update health notes.
+	healthNotes = notes
+
+	// Build list of packages.
+	var packages []*database.Package
+	for _, response := range responses {
+		for _, v := range response.Vulnerabilities {
+			packages = append(packages, v.FixedIn...)
+		}
+	}
+
+	// Insert packages into the database.
+	log.Tracef("beginning insertion of %d packages for update", len(packages))
+	t := time.Now()
+	err := database.InsertPackages(packages)
+	log.Tracef("inserting %d packages took %v", len(packages), time.Since(t))
+	if err != nil {
+		log.Errorf("an error occured when inserting packages for update: %s", err)
+		updateHealth(false)
+		return
+	}
+	packages = nil
+
+	// Build a list of vulnerabilties.
+	var vulnerabilities []*database.Vulnerability
+	for _, response := range responses {
+		for _, v := range response.Vulnerabilities {
+			var packageNodes []string
+			for _, pkg := range v.FixedIn {
+				packageNodes = append(packageNodes, pkg.Node)
+			}
+			vulnerabilities = append(vulnerabilities, &database.Vulnerability{ID: v.ID, Link: v.Link, Priority: v.Priority, Description: v.Description, FixedInNodes: packageNodes})
+		}
+	}
+	responses = nil
+
+	// Insert vulnerabilities into the database.
+	log.Tracef("beginning insertion of %d vulnerabilities for update", len(vulnerabilities))
+	t = time.Now()
+	notifications, err := database.InsertVulnerabilities(vulnerabilities)
+	log.Tracef("inserting %d vulnerabilities took %v", len(vulnerabilities), time.Since(t))
+	if err != nil {
+		log.Errorf("an error occured when inserting vulnerabilities for update: %s", err)
+		updateHealth(false)
+		return
+	}
+	vulnerabilities = nil
+
+	// Insert notifications into the database.
+	err = database.InsertNotifications(notifications, database.GetDefaultNotificationWrapper())
+	if err != nil {
+		log.Errorf("an error occured when inserting notifications for update: %s", err)
+		updateHealth(false)
+		return
+	}
+	notifications = nil
+
+	// Update flags in the database.
+	for flagName, flagValue := range flags {
+		database.UpdateFlag(flagName, flagValue)
+	}
+
+	// Update health depending on the status of the fetchers.
+	updateHealth(status)
+
+	log.Info("update finished")
+}
+
+func updateHealth(s bool) {
+	if s == false {
+		healthConsecutiveLocalFailures++
+	} else {
+		healthConsecutiveLocalFailures = 0
+	}
+}
+
+// Healthcheck returns the health of the updater service.
+func Healthcheck() health.Status {
+	return health.Status{
+		IsEssential: false,
+		IsHealthy:   healthConsecutiveLocalFailures < healthMaxConsecutiveLocalFailures,
+		Details: struct {
+			HealthIdentifier         string
+			HealthLockOwner          string
+			LatestSuccessfulUpdate   time.Time
+			ConsecutiveLocalFailures int
+			Notes                    []string `json:",omitempty"`
+		}{
+			HealthIdentifier:         healthIdentifier,
+			HealthLockOwner:          healthLockOwner,
+			LatestSuccessfulUpdate:   healthLatestSuccessfulUpdate,
+			ConsecutiveLocalFailures: healthConsecutiveLocalFailures,
+			Notes: healthNotes,
+		},
+	}
+}
diff --git a/utils/errors/errors.go b/utils/errors/errors.go
new file mode 100644
index 00000000..2d391be4
--- /dev/null
+++ b/utils/errors/errors.go
@@ -0,0 +1,41 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package errors defines error types that are used in several modules
+package errors
+
+import "errors"
+
+var (
+	// ErrFilesystem occurs when a filesystem interaction fails.
+	ErrFilesystem = errors.New("something went wrong when interacting with the fs")
+	// ErrCouldNotDownload occurs when a download fails.
+	ErrCouldNotDownload = errors.New("could not download requested ressource")
+	// ErrNotFound occurs when a resource could not be found.
+	ErrNotFound = errors.New("the resource cannot be found")
+)
+
+// ErrBadRequest occurs when a method has been passed an inappropriate argument.
+type ErrBadRequest struct {
+	s string
+}
+
+// NewBadRequestError instantiates a ErrBadRequest with the specified message.
+func NewBadRequestError(message string) error {
+	return &ErrBadRequest{s: message}
+}
+
+func (e *ErrBadRequest) Error() string {
+	return e.s
+}
diff --git a/utils/exec.go b/utils/exec.go
new file mode 100644
index 00000000..6d5e7cfc
--- /dev/null
+++ b/utils/exec.go
@@ -0,0 +1,39 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package utils simply defines utility functions and types.
+package utils
+
+import (
+	"bytes"
+	"os/exec"
+)
+
+// Exec runs the given binary with arguments
+func Exec(dir string, bin string, args ...string) ([]byte, error) {
+	_, err := exec.LookPath(bin)
+	if err != nil {
+		return nil, err
+	}
+
+	cmd := exec.Command(bin, args...)
+	cmd.Dir = dir
+
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+
+	err = cmd.Run()
+	return buf.Bytes(), err
+}
diff --git a/utils/stopper.go b/utils/stopper.go
new file mode 100644
index 00000000..e2ed6322
--- /dev/null
+++ b/utils/stopper.go
@@ -0,0 +1,65 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"sync"
+	"time"
+)
+
+// Stopper eases the graceful termination of a group of goroutines
+type Stopper struct {
+	wg   sync.WaitGroup
+	stop chan struct{}
+}
+
+// NewStopper initializes a new Stopper instance
+func NewStopper() *Stopper {
+	return &Stopper{stop: make(chan struct{}, 0)}
+}
+
+// Begin indicates that a new goroutine has started.
+func (s *Stopper) Begin() {
+	s.wg.Add(1)
+}
+
+// End indicates that a goroutine has stopped.
+func (s *Stopper) End() {
+	s.wg.Done()
+}
+
+// Chan returns the channel on which goroutines could listen to determine if
+// they should stop. The channel is closed when Stop() is called.
+func (s *Stopper) Chan() chan struct{} {
+	return s.stop
+}
+
+// Sleep puts the current goroutine on sleep during a duration d
+// Sleep could be interrupted in the case the goroutine should stop itself,
+// in which case Sleep returns false.
+func (s *Stopper) Sleep(d time.Duration) bool {
+	select {
+	case <-time.After(d):
+		return true
+	case <-s.stop:
+		return false
+	}
+}
+
+// Stop asks every goroutine to end.
+func (s *Stopper) Stop() {
+	close(s.stop)
+	s.wg.Wait()
+}
diff --git a/utils/string.go b/utils/string.go
new file mode 100644
index 00000000..6e958874
--- /dev/null
+++ b/utils/string.go
@@ -0,0 +1,68 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"regexp"
+)
+
+var urlParametersRegexp = regexp.MustCompile(`(\?|\&)([^=]+)\=([^ &]+)`)
+
+// Hash returns an unique hash of the given string
+func Hash(str string) string {
+	h := sha1.New()
+	h.Write([]byte(str))
+	bs := h.Sum(nil)
+	return hex.EncodeToString(bs)
+}
+
+// CleanURL removes all parameters from an URL
+func CleanURL(str string) string {
+	return urlParametersRegexp.ReplaceAllString(str, "")
+}
+
+// Contains looks for a string into an array of strings and returns whether
+// the string exists
+func Contains(needle string, haystack []string) bool {
+	for _, h := range haystack {
+		if h == needle {
+			return true
+		}
+	}
+	return false
+}
+
+// CompareStringLists returns the strings which are present in X but not in Y
+func CompareStringLists(X, Y []string) []string {
+	m := make(map[string]int)
+
+	for _, y := range Y {
+		m[y] = 1
+	}
+
+	diff := []string{}
+	for _, x := range X {
+		if m[x] > 0 {
+			continue
+		}
+
+		diff = append(diff, x)
+		m[x] = 1
+	}
+
+	return diff
+}
diff --git a/utils/tar.go b/utils/tar.go
new file mode 100644
index 00000000..66d40ea5
--- /dev/null
+++ b/utils/tar.go
@@ -0,0 +1,107 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"archive/tar"
+	"bufio"
+	"bytes"
+	"compress/gzip"
+	"errors"
+	"io"
+	"io/ioutil"
+	"strings"
+)
+
+var (
+	// ErrCouldNotExtract occurs when an extraction fails.
+	ErrCouldNotExtract = errors.New("utils: could not extract the archive")
+
+	// ErrExtractedFileTooBig occurs when a file to extract is too big.
+	ErrExtractedFileTooBig = errors.New("utils: could not extract one or more files from the archive: file too big")
+
+	gzipHeader = []byte{0x1f, 0x8b}
+)
+
+// SelectivelyExtractArchive extracts the specified files and folders
+// from targz data read from the given reader and store them in a map indexed by file paths
+func SelectivelyExtractArchive(r io.Reader, toExtract []string, maxFileSize int64) (map[string][]byte, error) {
+	data := make(map[string][]byte)
+
+	// Create a tar or tar/tar-gzip reader
+	tr, err := getTarReader(r)
+	if err != nil {
+		return data, ErrCouldNotExtract
+	}
+
+	// For each element in the archive
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return data, ErrCouldNotExtract
+		}
+
+		// Get element filename
+		filename := hdr.Name
+		filename = strings.TrimPrefix(filename, "./")
+
+		// Determine if we should extract the element
+		toBeExtracted := false
+		for _, s := range toExtract {
+			if strings.HasPrefix(filename, s) {
+				toBeExtracted = true
+				break
+			}
+		}
+
+		if toBeExtracted {
+			// File size limit
+			if maxFileSize > 0 && hdr.Size > maxFileSize {
+				return data, ErrExtractedFileTooBig
+			}
+
+			// Extract the element
+			if hdr.Typeflag == tar.TypeSymlink || hdr.Typeflag == tar.TypeLink || hdr.Typeflag == tar.TypeReg {
+				d, _ := ioutil.ReadAll(tr)
+				data[filename] = d
+			}
+		}
+	}
+
+	return data, nil
+}
+
+// getTarReader returns a tar.Reader associated with the specified io.Reader,
+// optionally backed by a gzip.Reader if gzip compression is detected.
+//
+// Gzip detection is done by using the magic numbers defined in the RFC1952 :
+// the first two bytes should be 0x1f and 0x8b..
+func getTarReader(r io.Reader) (*tar.Reader, error) {
+	br := bufio.NewReader(r)
+	header, err := br.Peek(2)
+
+	if err == nil && bytes.Equal(header, gzipHeader) {
+		gr, err := gzip.NewReader(br)
+		if err != nil {
+			return nil, err
+		}
+		return tar.NewReader(gr), nil
+	}
+
+	return tar.NewReader(br), nil
+}
diff --git a/utils/testdata/utils_test.tar b/utils/testdata/utils_test.tar
new file mode 100644
index 00000000..f396f40b
Binary files /dev/null and b/utils/testdata/utils_test.tar differ
diff --git a/utils/testdata/utils_test.tar.gz b/utils/testdata/utils_test.tar.gz
new file mode 100644
index 00000000..a8f89d75
Binary files /dev/null and b/utils/testdata/utils_test.tar.gz differ
diff --git a/utils/types/priority.go b/utils/types/priority.go
new file mode 100644
index 00000000..90115f85
--- /dev/null
+++ b/utils/types/priority.go
@@ -0,0 +1,88 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package types defines useful types that are used in database models.
+package types
+
+// Priority defines a vulnerability priority
+type Priority string
+
+const (
+	// Unknown is either a security problem that has not been
+	// assigned to a priority yet or a priority that our system
+	// did not recognize
+	Unknown Priority = "Unknown"
+	// Negligible is technically a security problem, but is
+	// only theoretical in nature, requires a very special
+	// situation, has almost no install base, or does no real
+	// damage. These tend not to get backport from upstreams,
+	// and will likely not be included in security updates unless
+	// there is an easy fix and some other issue causes an update.
+	Negligible Priority = "Negligible"
+	// Low is a security problem, but is hard to
+	// exploit due to environment, requires a user-assisted
+	// attack, a small install base, or does very little damage.
+	// These tend to be included in security updates only when
+	// higher priority issues require an update, or if many
+	// low priority issues have built up.
+	Low Priority = "Low"
+	// Medium is a real security problem, and is exploitable
+	// for many people. Includes network daemon denial of service
+	// attacks, cross-site scripting, and gaining user privileges.
+	// Updates should be made soon for this priority of issue.
+	Medium Priority = "Medium"
+	// High is a real problem, exploitable for many people in a default
+	// installation. Includes serious remote denial of services,
+	// local root privilege escalations, or data loss.
+	High Priority = "High"
+	// Critical is a world-burning problem, exploitable for nearly all people
+	// in a default installation of Linux. Includes remote root
+	// privilege escalations, or massive data loss.
+	Critical Priority = "Critical"
+	// Defcon1 is a Critical problem which has been manually highlighted by
+	// the team. It requires an immediate attention.
+	Defcon1 Priority = "Defcon1"
+)
+
+// Priorities lists all known priorities, ordered from lower to higher
+var Priorities = []Priority{Unknown, Negligible, Low, Medium, High, Critical, Defcon1}
+
+// IsValid determines if the priority is a valid one
+func (p Priority) IsValid() bool {
+	for _, pp := range Priorities {
+		if p == pp {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Compare compares two priorities
+func (p Priority) Compare(p2 Priority) int {
+	var i1, i2 int
+
+	for i1 = 0; i1 < len(Priorities); i1 = i1 + 1 {
+		if p == Priorities[i1] {
+			break
+		}
+	}
+	for i2 = 0; i2 < len(Priorities); i2 = i2 + 1 {
+		if p2 == Priorities[i2] {
+			break
+		}
+	}
+
+	return i1 - i2
+}
diff --git a/utils/types/priority_test.go b/utils/types/priority_test.go
new file mode 100644
index 00000000..15558d5a
--- /dev/null
+++ b/utils/types/priority_test.go
@@ -0,0 +1,32 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestComparePriority(t *testing.T) {
+	assert.Equal(t, Medium.Compare(Medium), 0, "Priority comparison failed")
+	assert.True(t, Medium.Compare(High) < 0, "Priority comparison failed")
+	assert.True(t, Critical.Compare(Low) > 0, "Priority comparison failed")
+}
+
+func TestIsValid(t *testing.T) {
+	assert.False(t, Priority("Test").IsValid())
+	assert.True(t, Unknown.IsValid())
+}
diff --git a/utils/types/version.go b/utils/types/version.go
new file mode 100644
index 00000000..e14a0540
--- /dev/null
+++ b/utils/types/version.go
@@ -0,0 +1,282 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"encoding/json"
+	"errors"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+// Version represents a package version
+type Version struct {
+	epoch    int
+	version  string
+	revision string
+}
+
+var (
+	// MinVersion is a special package version which is always sorted first
+	MinVersion = Version{version: "#MINV#"}
+	// MaxVersion is a special package version which is always sorted last
+	MaxVersion = Version{version: "#MAXV#"}
+
+	versionAllowedSymbols  = []rune{'.', '-', '+', '~', ':', '_'}
+	revisionAllowedSymbols = []rune{'.', '+', '~', '_'}
+)
+
+// NewVersion function parses a string into a Version struct which can be compared
+//
+// The implementation is based on http://man.he.net/man5/deb-version
+// on https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Version
+//
+// It uses the dpkg-1.17.25's algorithm  (lib/parsehelp.c)
+func NewVersion(str string) (Version, error) {
+	var version Version
+
+	// Trim leading and trailing space
+	str = strings.TrimSpace(str)
+
+	if len(str) == 0 {
+		return Version{}, errors.New("Version string is empty")
+	}
+
+	// Max/Min versions
+	if str == MaxVersion.String() {
+		return MaxVersion, nil
+	}
+	if str == MinVersion.String() {
+		return MinVersion, nil
+	}
+
+	// Find epoch
+	sepepoch := strings.Index(str, ":")
+	if sepepoch > -1 {
+		intepoch, err := strconv.Atoi(str[:sepepoch])
+		if err == nil {
+			version.epoch = intepoch
+		} else {
+			return Version{}, errors.New("epoch in version is not a number")
+		}
+		if intepoch < 0 {
+			return Version{}, errors.New("epoch in version is negative")
+		}
+	} else {
+		version.epoch = 0
+	}
+
+	// Find version / revision
+	seprevision := strings.LastIndex(str, "-")
+	if seprevision > -1 {
+		version.version = str[sepepoch+1 : seprevision]
+		version.revision = str[seprevision+1:]
+	} else {
+		version.version = str[sepepoch+1:]
+		version.revision = ""
+	}
+	// Verify format
+	if len(version.version) == 0 {
+		return Version{}, errors.New("No version")
+	}
+
+	if !unicode.IsDigit(rune(version.version[0])) {
+		return Version{}, errors.New("version does not start with digit")
+	}
+
+	for i := 0; i < len(version.version); i = i + 1 {
+		r := rune(version.version[i])
+		if !unicode.IsDigit(r) && !unicode.IsLetter(r) && !containsRune(versionAllowedSymbols, r) {
+			return Version{}, errors.New("invalid character in version")
+		}
+	}
+
+	for i := 0; i < len(version.revision); i = i + 1 {
+		r := rune(version.revision[i])
+		if !unicode.IsDigit(r) && !unicode.IsLetter(r) && !containsRune(revisionAllowedSymbols, r) {
+			return Version{}, errors.New("invalid character in revision")
+		}
+	}
+
+	return version, nil
+}
+
+// NewVersionUnsafe is just a wrapper around NewVersion that ignore potentiel
+// parsing error. Useful for test purposes
+func NewVersionUnsafe(str string) Version {
+	v, _ := NewVersion(str)
+	return v
+}
+
+// Compare function compares two Debian-like package version
+//
+// The implementation is based on http://man.he.net/man5/deb-version
+// on https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Version
+//
+// It uses the dpkg-1.17.25's algorithm  (lib/version.c)
+func (a Version) Compare(b Version) int {
+	// Quick check
+	if a == b {
+		return 0
+	}
+
+	// Max/Min comparison
+	if a == MinVersion || b == MaxVersion {
+		return -1
+	}
+	if b == MinVersion || a == MaxVersion {
+		return 1
+	}
+
+	// Compare epochs
+	if a.epoch > b.epoch {
+		return 1
+	}
+	if a.epoch < b.epoch {
+		return -1
+	}
+
+	// Compare version
+	rc := verrevcmp(a.version, b.version)
+	if rc != 0 {
+		return signum(rc)
+	}
+
+	// Compare revision
+	return signum(verrevcmp(a.revision, b.revision))
+}
+
+// String returns the string representation of a Version
+func (v Version) String() (s string) {
+	if v.epoch != 0 {
+		s = strconv.Itoa(v.epoch) + ":"
+	}
+	s += v.version
+	if v.revision != "" {
+		s += "-" + v.revision
+	}
+	return
+}
+
+func (v Version) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.String())
+}
+
+func (v *Version) UnmarshalJSON(b []byte) (err error) {
+	var str string
+	json.Unmarshal(b, &str)
+	vp, err := NewVersion(str)
+	*v = vp
+	return
+}
+
+func verrevcmp(t1, t2 string) int {
+	t1, rt1 := nextRune(t1)
+	t2, rt2 := nextRune(t2)
+
+	for rt1 != nil || rt2 != nil {
+		firstDiff := 0
+
+		for (rt1 != nil && !unicode.IsDigit(*rt1)) || (rt2 != nil && !unicode.IsDigit(*rt2)) {
+			ac := 0
+			bc := 0
+			if rt1 != nil {
+				ac = order(*rt1)
+			}
+			if rt2 != nil {
+				bc = order(*rt2)
+			}
+
+			if ac != bc {
+				return ac - bc
+			}
+
+			t1, rt1 = nextRune(t1)
+			t2, rt2 = nextRune(t2)
+		}
+		for rt1 != nil && *rt1 == '0' {
+			t1, rt1 = nextRune(t1)
+		}
+		for rt2 != nil && *rt2 == '0' {
+			t2, rt2 = nextRune(t2)
+		}
+		for rt1 != nil && unicode.IsDigit(*rt1) && rt2 != nil && unicode.IsDigit(*rt2) {
+			if firstDiff == 0 {
+				firstDiff = int(*rt1) - int(*rt2)
+			}
+			t1, rt1 = nextRune(t1)
+			t2, rt2 = nextRune(t2)
+		}
+		if rt1 != nil && unicode.IsDigit(*rt1) {
+			return 1
+		}
+		if rt2 != nil && unicode.IsDigit(*rt2) {
+			return -1
+		}
+		if firstDiff != 0 {
+			return firstDiff
+		}
+	}
+
+	return 0
+}
+
+// order compares runes using a modified ASCII table
+// so that letters are sorted earlier than non-letters
+// and so that tildes sorts before anything
+func order(r rune) int {
+	if unicode.IsDigit(r) {
+		return 0
+	}
+
+	if unicode.IsLetter(r) {
+		return int(r)
+	}
+
+	if r == '~' {
+		return -1
+	}
+
+	return int(r) + 256
+}
+
+func nextRune(str string) (string, *rune) {
+	if len(str) >= 1 {
+		r := rune(str[0])
+		return str[1:], &r
+	}
+	return str, nil
+}
+
+func containsRune(s []rune, e rune) bool {
+	for _, a := range s {
+		if a == e {
+			return true
+		}
+	}
+	return false
+}
+
+func signum(a int) int {
+	switch {
+	case a < 0:
+		return -1
+	case a > 0:
+		return +1
+	}
+
+	return 0
+}
diff --git a/utils/types/version_test.go b/utils/types/version_test.go
new file mode 100644
index 00000000..4796ceb9
--- /dev/null
+++ b/utils/types/version_test.go
@@ -0,0 +1,243 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	LESS    = -1
+	EQUAL   = 0
+	GREATER = 1
+)
+
+func TestCompareSimpleVersion(t *testing.T) {
+	cases := []struct {
+		v1       Version
+		expected int
+		v2       Version
+	}{
+		{Version{}, EQUAL, Version{}},
+		{Version{epoch: 1}, LESS, Version{epoch: 2}},
+		{Version{epoch: 0, version: "1", revision: "1"}, LESS, Version{epoch: 0, version: "2", revision: "1"}},
+		{Version{epoch: 0, version: "a", revision: "0"}, LESS, Version{epoch: 0, version: "b", revision: "0"}},
+		{Version{epoch: 0, version: "1", revision: "1"}, LESS, Version{epoch: 0, version: "1", revision: "2"}},
+		{Version{epoch: 0, version: "0", revision: "0"}, EQUAL, Version{epoch: 0, version: "0", revision: "0"}},
+		{Version{epoch: 0, version: "0", revision: "00"}, EQUAL, Version{epoch: 0, version: "00", revision: "0"}},
+		{Version{epoch: 1, version: "2", revision: "3"}, EQUAL, Version{epoch: 1, version: "2", revision: "3"}},
+		{Version{epoch: 0, version: "0", revision: "a"}, LESS, Version{epoch: 0, version: "0", revision: "b"}},
+		{MinVersion, LESS, MaxVersion},
+		{MinVersion, LESS, Version{}},
+		{MinVersion, LESS, Version{version: "0"}},
+		{MaxVersion, GREATER, Version{}},
+		{MaxVersion, GREATER, Version{epoch: 9999999, version: "9999999", revision: "9999999"}},
+	}
+
+	for _, c := range cases {
+		cmp := c.v1.Compare(c.v2)
+		assert.Equal(t, c.expected, cmp, "%s vs. %s, = %d, expected %d", c.v1, c.v2, cmp, c.expected)
+
+		cmp = c.v2.Compare(c.v1)
+		assert.Equal(t, -c.expected, cmp, "%s vs. %s, = %d, expected %d", c.v2, c.v1, cmp, -c.expected)
+	}
+}
+
+func TestParse(t *testing.T) {
+	cases := []struct {
+		str string
+		ver Version
+		err bool
+	}{
+		// Test 0
+		{"0", Version{epoch: 0, version: "0", revision: ""}, false},
+		{"0:0", Version{epoch: 0, version: "0", revision: ""}, false},
+		{"0:0-", Version{epoch: 0, version: "0", revision: ""}, false},
+		{"0:0-0", Version{epoch: 0, version: "0", revision: "0"}, false},
+		{"0:0.0-0.0", Version{epoch: 0, version: "0.0", revision: "0.0"}, false},
+		// Test epoched
+		{"1:0", Version{epoch: 1, version: "0", revision: ""}, false},
+		{"5:1", Version{epoch: 5, version: "1", revision: ""}, false},
+		// Test multiple hypens
+		{"0:0-0-0", Version{epoch: 0, version: "0-0", revision: "0"}, false},
+		{"0:0-0-0-0", Version{epoch: 0, version: "0-0-0", revision: "0"}, false},
+		// Test multiple colons
+		{"0:0:0-0", Version{epoch: 0, version: "0:0", revision: "0"}, false},
+		{"0:0:0:0-0", Version{epoch: 0, version: "0:0:0", revision: "0"}, false},
+		// Test multiple hyphens and colons
+		{"0:0:0-0-0", Version{epoch: 0, version: "0:0-0", revision: "0"}, false},
+		{"0:0-0:0-0", Version{epoch: 0, version: "0-0:0", revision: "0"}, false},
+		// Test valid characters in version
+		{"0:09azAZ.-+~:_-0", Version{epoch: 0, version: "09azAZ.-+~:_", revision: "0"}, false},
+		// Test valid characters in debian revision
+		{"0:0-azAZ09.+~_", Version{epoch: 0, version: "0", revision: "azAZ09.+~_"}, false},
+		// Test version with leading and trailing spaces
+		{"  	0:0-1", Version{epoch: 0, version: "0", revision: "1"}, false},
+		{"0:0-1	  ", Version{epoch: 0, version: "0", revision: "1"}, false},
+		{"	  0:0-1  	", Version{epoch: 0, version: "0", revision: "1"}, false},
+		// Test empty version
+		{"", Version{}, true},
+		{" ", Version{}, true},
+		{"0:", Version{}, true},
+		// Test version with embedded spaces
+		{"0:0 0-1", Version{}, true},
+		// Test version with negative epoch
+		{"-1:0-1", Version{}, true},
+		// Test invalid characters in epoch
+		{"a:0-0", Version{}, true},
+		{"A:0-0", Version{}, true},
+		// Test version not starting with a digit
+		{"0:abc3-0", Version{}, true},
+	}
+	for _, c := range cases {
+		v, err := NewVersion(c.str)
+
+		if c.err {
+			assert.Error(t, err, "When parsing '%s'", c.str)
+		} else {
+			assert.Nil(t, err, "When parsing '%s'", c.str)
+		}
+		assert.Equal(t, c.ver, v, "When parsing '%s'", c.str)
+	}
+
+	// Test invalid characters in version
+	versym := []rune{'!', '#', '@', '$', '%', '&', '/', '|', '\\', '<', '>', '(', ')', '[', ']', '{', '}', ';', ',', '=', '*', '^', '\''}
+	for _, r := range versym {
+		_, err := NewVersion(strings.Join([]string{"0:0", string(r), "-0"}, ""))
+		assert.Error(t, err, "Parsing with invalid character '%s' in version should have failed", string(r))
+	}
+
+	// Test invalid characters in revision
+	versym = []rune{'!', '#', '@', '$', '%', '&', '/', '|', '\\', '<', '>', '(', ')', '[', ']', '{', '}', ':', ';', ',', '=', '*', '^', '\''}
+	for _, r := range versym {
+		_, err := NewVersion(strings.Join([]string{"0:0-", string(r)}, ""))
+		assert.Error(t, err, "Parsing with invalid character '%s' in revision should have failed", string(r))
+	}
+}
+
+func TestParseAndCompare(t *testing.T) {
+	const LESS = -1
+	const EQUAL = 0
+	const GREATER = 1
+
+	cases := []struct {
+		v1       string
+		expected int
+		v2       string
+	}{
+		{"7.6p2-4", GREATER, "7.6-0"},
+		{"1.0.3-3", GREATER, "1.0-1"},
+		{"1.3", GREATER, "1.2.2-2"},
+		{"1.3", GREATER, "1.2.2"},
+		// Some properties of text strings
+		{"0-pre", EQUAL, "0-pre"},
+		{"0-pre", LESS, "0-pree"},
+		{"1.1.6r2-2", GREATER, "1.1.6r-1"},
+		{"2.6b2-1", GREATER, "2.6b-2"},
+		{"98.1p5-1", LESS, "98.1-pre2-b6-2"},
+		{"0.4a6-2", GREATER, "0.4-1"},
+		{"1:3.0.5-2", LESS, "1:3.0.5.1"},
+		// epochs
+		{"1:0.4", GREATER, "10.3"},
+		{"1:1.25-4", LESS, "1:1.25-8"},
+		{"0:1.18.36", EQUAL, "1.18.36"},
+		{"1.18.36", GREATER, "1.18.35"},
+		{"0:1.18.36", GREATER, "1.18.35"},
+		// Funky, but allowed, characters in upstream version
+		{"9:1.18.36:5.4-20", LESS, "10:0.5.1-22"},
+		{"9:1.18.36:5.4-20", LESS, "9:1.18.36:5.5-1"},
+		{"9:1.18.36:5.4-20", LESS, " 9:1.18.37:4.3-22"},
+		{"1.18.36-0.17.35-18", GREATER, "1.18.36-19"},
+		// Junk
+		{"1:1.2.13-3", LESS, "1:1.2.13-3.1"},
+		{"2.0.7pre1-4", LESS, "2.0.7r-1"},
+		// if a version includes a dash, it should be the debrev dash - policy says so
+		{"0:0-0-0", GREATER, "0-0"},
+		// do we like strange versions? Yes we like strange versions…
+		{"0", EQUAL, "0"},
+		{"0", EQUAL, "00"},
+		// #205960
+		{"3.0~rc1-1", LESS, "3.0-1"},
+		// #573592 - debian policy 5.6.12
+		{"1.0", EQUAL, "1.0-0"},
+		{"0.2", LESS, "1.0-0"},
+		{"1.0", LESS, "1.0-0+b1"},
+		{"1.0", GREATER, "1.0-0~"},
+		// "steal" the testcases from (old perl) cupt
+		{"1.2.3", EQUAL, "1.2.3"},                           // identical
+		{"4.4.3-2", EQUAL, "4.4.3-2"},                       // identical
+		{"1:2ab:5", EQUAL, "1:2ab:5"},                       // this is correct...
+		{"7:1-a:b-5", EQUAL, "7:1-a:b-5"},                   // and this
+		{"57:1.2.3abYZ+~-4-5", EQUAL, "57:1.2.3abYZ+~-4-5"}, // and those too
+		{"1.2.3", EQUAL, "0:1.2.3"},                         // zero epoch
+		{"1.2.3", EQUAL, "1.2.3-0"},                         // zero revision
+		{"009", EQUAL, "9"},                                 // zeroes…
+		{"009ab5", EQUAL, "9ab5"},                           // there as well
+		{"1.2.3", LESS, "1.2.3-1"},                          // added non-zero revision
+		{"1.2.3", LESS, "1.2.4"},                            // just bigger
+		{"1.2.4", GREATER, "1.2.3"},                         // order doesn't matter
+		{"1.2.24", GREATER, "1.2.3"},                        // bigger, eh?
+		{"0.10.0", GREATER, "0.8.7"},                        // bigger, eh?
+		{"3.2", GREATER, "2.3"},                             // major number rocks
+		{"1.3.2a", GREATER, "1.3.2"},                        // letters rock
+		{"0.5.0~git", LESS, "0.5.0~git2"},                   // numbers rock
+		{"2a", LESS, "21"},                                  // but not in all places
+		{"1.3.2a", LESS, "1.3.2b"},                          // but there is another letter
+		{"1:1.2.3", GREATER, "1.2.4"},                       // epoch rocks
+		{"1:1.2.3", LESS, "1:1.2.4"},                        // bigger anyway
+		{"1.2a+~bCd3", LESS, "1.2a++"},                      // tilde doesn't rock
+		{"1.2a+~bCd3", GREATER, "1.2a+~"},                   // but first is longer!
+		{"5:2", GREATER, "304-2"},                           // epoch rocks
+		{"5:2", LESS, "304:2"},                              // so big epoch?
+		{"25:2", GREATER, "3:2"},                            // 25 > 3, obviously
+		{"1:2:123", LESS, "1:12:3"},                         // 12 > 2
+		{"1.2-5", LESS, "1.2-3-5"},                          // 1.2 < 1.2-3
+		{"5.10.0", GREATER, "5.005"},                        // preceding zeroes don't matters
+		{"3a9.8", LESS, "3.10.2"},                           // letters are before all letter symbols
+		{"3a9.8", GREATER, "3~10"},                          // but after the tilde
+		{"1.4+OOo3.0.0~", LESS, "1.4+OOo3.0.0-4"},           // another tilde check
+		{"2.4.7-1", LESS, "2.4.7-z"},                        // revision comparing
+		{"1.002-1+b2", GREATER, "1.00"},                     // whatever...
+	}
+
+	for _, c := range cases {
+		v1, err1 := NewVersion(c.v1)
+		v2, err2 := NewVersion(c.v2)
+		if assert.Nil(t, err1) && assert.Nil(t, err2) {
+			cmp := v1.Compare(v2)
+			assert.Equal(t, c.expected, cmp, "%s vs. %s, = %d, expected %d", c.v1, c.v2, cmp, c.expected)
+
+			cmp = v2.Compare(v1)
+			assert.Equal(t, -c.expected, cmp, "%s vs. %s, = %d, expected %d", c.v2, c.v1, cmp, -c.expected)
+		}
+	}
+}
+
+func TestVersionJson(t *testing.T) {
+	v, _ := NewVersion("57:1.2.3abYZ+~-4-5")
+
+	// Marshal
+	json, err := v.MarshalJSON()
+	assert.Nil(t, err)
+	assert.Equal(t, "\""+v.String()+"\"", string(json))
+
+	// Unmarshal
+	var v2 Version
+	v2.UnmarshalJSON(json)
+	assert.Equal(t, v, v2)
+}
diff --git a/utils/utils_test.go b/utils/utils_test.go
new file mode 100644
index 00000000..f9c877c8
--- /dev/null
+++ b/utils/utils_test.go
@@ -0,0 +1,96 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"bytes"
+	"os"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/pborman/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+const fileToDownload = "http://www.google.com/robots.txt"
+
+// TestDiff tests the diff.go source file
+func TestDiff(t *testing.T) {
+	assert.NotContains(t, CompareStringLists([]string{"a", "b", "a"}, []string{"a", "c"}), "a")
+}
+
+// TestExec tests the exec.go source file
+func TestExec(t *testing.T) {
+	_, err := Exec(uuid.New(), "touch", uuid.New())
+	assert.Error(t, err, "Exec should not be able to run in a not existing directory")
+
+	o, err := Exec("/tmp", "echo", "test")
+	assert.Nil(t, err, "Could not exec echo")
+	assert.Equal(t, "test\n", string(o), "Could not exec echo")
+
+	_, err = Exec("/tmp", uuid.New())
+	assert.Error(t, err, "An invalid command should return an error")
+}
+
+// TestString tests the string.go file
+func TestString(t *testing.T) {
+	assert.Equal(t, Hash("abc123"), Hash("abc123"))
+	assert.NotEqual(t, Hash("abc123."), Hash("abc123"))
+
+	assert.False(t, Contains("", []string{}))
+	assert.True(t, Contains("a", []string{"a", "b"}))
+	assert.False(t, Contains("c", []string{"a", "b"}))
+}
+
+// TestTar tests the tar.go file
+func TestTar(t *testing.T) {
+	var err error
+	var data map[string][]byte
+	_, filepath, _, _ := runtime.Caller(0)
+
+	for _, filename := range []string{"/testdata/utils_test.tar.gz", "/testdata/utils_test.tar"} {
+		testArchivePath := path.Join(path.Dir(filepath)) + filename
+
+		// Extract non compressed data
+		data, err = SelectivelyExtractArchive(bytes.NewReader([]byte("that string does not represent a tar or tar-gzip file")), []string{}, 0)
+		assert.Error(t, err, "Extracting non compressed data should return an error")
+
+		// Extract an archive
+		f, _ := os.Open(testArchivePath)
+		defer f.Close()
+		data, err = SelectivelyExtractArchive(f, []string{"test/"}, 0)
+		assert.Nil(t, err)
+
+		if c, n := data["test/test.txt"]; !n {
+			assert.Fail(t, "test/test.txt should have been extracted")
+		} else {
+			assert.NotEqual(t, 0, len(c) > 0, "test/test.txt file is empty")
+		}
+		if _, n := data["test.txt"]; n {
+			assert.Fail(t, "test.txt should not be extracted")
+		}
+
+		// File size limit
+		f, _ = os.Open(testArchivePath)
+		defer f.Close()
+		data, err = SelectivelyExtractArchive(f, []string{"test"}, 50)
+		assert.Equal(t, ErrExtractedFileTooBig, err)
+	}
+}
+
+func TestCleanURL(t *testing.T) {
+	assert.Equal(t, "Test http://test.cn/test Test", CleanURL("Test http://test.cn/test?foo=bar&bar=foo Test"))
+}
diff --git a/vendor/github.com/alecthomas/template/README.md b/vendor/github.com/alecthomas/template/README.md
new file mode 100644
index 00000000..ef6a8ee3
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/README.md
@@ -0,0 +1,25 @@
+# Go's `text/template` package with newline elision
+
+This is a fork of Go 1.4's [text/template](http://golang.org/pkg/text/template/) package with one addition: a backslash immediately after a closing delimiter will delete all subsequent newlines until a non-newline.
+
+eg.
+
+```
+{{if true}}\
+hello
+{{end}}\
+```
+
+Will result in:
+
+```
+hello\n
+```
+
+Rather than:
+
+```
+\n
+hello\n
+\n
+```
diff --git a/vendor/github.com/alecthomas/template/doc.go b/vendor/github.com/alecthomas/template/doc.go
new file mode 100644
index 00000000..223c595c
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/doc.go
@@ -0,0 +1,406 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package template implements data-driven templates for generating textual output.
+
+To generate HTML output, see package html/template, which has the same interface
+as this package but automatically secures HTML output against certain attacks.
+
+Templates are executed by applying them to a data structure. Annotations in the
+template refer to elements of the data structure (typically a field of a struct
+or a key in a map) to control execution and derive values to be displayed.
+Execution of the template walks the structure and sets the cursor, represented
+by a period '.' and called "dot", to the value at the current location in the
+structure as execution proceeds.
+
+The input text for a template is UTF-8-encoded text in any format.
+"Actions"--data evaluations or control structures--are delimited by
+"{{" and "}}"; all text outside actions is copied to the output unchanged.
+Actions may not span newlines, although comments can.
+
+Once parsed, a template may be executed safely in parallel.
+
+Here is a trivial example that prints "17 items are made of wool".
+
+	type Inventory struct {
+		Material string
+		Count    uint
+	}
+	sweaters := Inventory{"wool", 17}
+	tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")
+	if err != nil { panic(err) }
+	err = tmpl.Execute(os.Stdout, sweaters)
+	if err != nil { panic(err) }
+
+More intricate examples appear below.
+
+Actions
+
+Here is the list of actions. "Arguments" and "pipelines" are evaluations of
+data, defined in detail below.
+
+*/
+//	{{/* a comment */}}
+//		A comment; discarded. May contain newlines.
+//		Comments do not nest and must start and end at the
+//		delimiters, as shown here.
+/*
+
+	{{pipeline}}
+		The default textual representation of the value of the pipeline
+		is copied to the output.
+
+	{{if pipeline}} T1 {{end}}
+		If the value of the pipeline is empty, no output is generated;
+		otherwise, T1 is executed.  The empty values are false, 0, any
+		nil pointer or interface value, and any array, slice, map, or
+		string of length zero.
+		Dot is unaffected.
+
+	{{if pipeline}} T1 {{else}} T0 {{end}}
+		If the value of the pipeline is empty, T0 is executed;
+		otherwise, T1 is executed.  Dot is unaffected.
+
+	{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}
+		To simplify the appearance of if-else chains, the else action
+		of an if may include another if directly; the effect is exactly
+		the same as writing
+			{{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}}
+
+	{{range pipeline}} T1 {{end}}
+		The value of the pipeline must be an array, slice, map, or channel.
+		If the value of the pipeline has length zero, nothing is output;
+		otherwise, dot is set to the successive elements of the array,
+		slice, or map and T1 is executed. If the value is a map and the
+		keys are of basic type with a defined order ("comparable"), the
+		elements will be visited in sorted key order.
+
+	{{range pipeline}} T1 {{else}} T0 {{end}}
+		The value of the pipeline must be an array, slice, map, or channel.
+		If the value of the pipeline has length zero, dot is unaffected and
+		T0 is executed; otherwise, dot is set to the successive elements
+		of the array, slice, or map and T1 is executed.
+
+	{{template "name"}}
+		The template with the specified name is executed with nil data.
+
+	{{template "name" pipeline}}
+		The template with the specified name is executed with dot set
+		to the value of the pipeline.
+
+	{{with pipeline}} T1 {{end}}
+		If the value of the pipeline is empty, no output is generated;
+		otherwise, dot is set to the value of the pipeline and T1 is
+		executed.
+
+	{{with pipeline}} T1 {{else}} T0 {{end}}
+		If the value of the pipeline is empty, dot is unaffected and T0
+		is executed; otherwise, dot is set to the value of the pipeline
+		and T1 is executed.
+
+Arguments
+
+An argument is a simple value, denoted by one of the following.
+
+	- A boolean, string, character, integer, floating-point, imaginary
+	  or complex constant in Go syntax. These behave like Go's untyped
+	  constants, although raw strings may not span newlines.
+	- The keyword nil, representing an untyped Go nil.
+	- The character '.' (period):
+		.
+	  The result is the value of dot.
+	- A variable name, which is a (possibly empty) alphanumeric string
+	  preceded by a dollar sign, such as
+		$piOver2
+	  or
+		$
+	  The result is the value of the variable.
+	  Variables are described below.
+	- The name of a field of the data, which must be a struct, preceded
+	  by a period, such as
+		.Field
+	  The result is the value of the field. Field invocations may be
+	  chained:
+	    .Field1.Field2
+	  Fields can also be evaluated on variables, including chaining:
+	    $x.Field1.Field2
+	- The name of a key of the data, which must be a map, preceded
+	  by a period, such as
+		.Key
+	  The result is the map element value indexed by the key.
+	  Key invocations may be chained and combined with fields to any
+	  depth:
+	    .Field1.Key1.Field2.Key2
+	  Although the key must be an alphanumeric identifier, unlike with
+	  field names they do not need to start with an upper case letter.
+	  Keys can also be evaluated on variables, including chaining:
+	    $x.key1.key2
+	- The name of a niladic method of the data, preceded by a period,
+	  such as
+		.Method
+	  The result is the value of invoking the method with dot as the
+	  receiver, dot.Method(). Such a method must have one return value (of
+	  any type) or two return values, the second of which is an error.
+	  If it has two and the returned error is non-nil, execution terminates
+	  and an error is returned to the caller as the value of Execute.
+	  Method invocations may be chained and combined with fields and keys
+	  to any depth:
+	    .Field1.Key1.Method1.Field2.Key2.Method2
+	  Methods can also be evaluated on variables, including chaining:
+	    $x.Method1.Field
+	- The name of a niladic function, such as
+		fun
+	  The result is the value of invoking the function, fun(). The return
+	  types and values behave as in methods. Functions and function
+	  names are described below.
+	- A parenthesized instance of one the above, for grouping. The result
+	  may be accessed by a field or map key invocation.
+		print (.F1 arg1) (.F2 arg2)
+		(.StructValuedMethod "arg").Field
+
+Arguments may evaluate to any type; if they are pointers the implementation
+automatically indirects to the base type when required.
+If an evaluation yields a function value, such as a function-valued
+field of a struct, the function is not invoked automatically, but it
+can be used as a truth value for an if action and the like. To invoke
+it, use the call function, defined below.
+
+A pipeline is a possibly chained sequence of "commands". A command is a simple
+value (argument) or a function or method call, possibly with multiple arguments:
+
+	Argument
+		The result is the value of evaluating the argument.
+	.Method [Argument...]
+		The method can be alone or the last element of a chain but,
+		unlike methods in the middle of a chain, it can take arguments.
+		The result is the value of calling the method with the
+		arguments:
+			dot.Method(Argument1, etc.)
+	functionName [Argument...]
+		The result is the value of calling the function associated
+		with the name:
+			function(Argument1, etc.)
+		Functions and function names are described below.
+
+Pipelines
+
+A pipeline may be "chained" by separating a sequence of commands with pipeline
+characters '|'. In a chained pipeline, the result of the each command is
+passed as the last argument of the following command. The output of the final
+command in the pipeline is the value of the pipeline.
+
+The output of a command will be either one value or two values, the second of
+which has type error. If that second value is present and evaluates to
+non-nil, execution terminates and the error is returned to the caller of
+Execute.
+
+Variables
+
+A pipeline inside an action may initialize a variable to capture the result.
+The initialization has syntax
+
+	$variable := pipeline
+
+where $variable is the name of the variable. An action that declares a
+variable produces no output.
+
+If a "range" action initializes a variable, the variable is set to the
+successive elements of the iteration.  Also, a "range" may declare two
+variables, separated by a comma:
+
+	range $index, $element := pipeline
+
+in which case $index and $element are set to the successive values of the
+array/slice index or map key and element, respectively.  Note that if there is
+only one variable, it is assigned the element; this is opposite to the
+convention in Go range clauses.
+
+A variable's scope extends to the "end" action of the control structure ("if",
+"with", or "range") in which it is declared, or to the end of the template if
+there is no such control structure.  A template invocation does not inherit
+variables from the point of its invocation.
+
+When execution begins, $ is set to the data argument passed to Execute, that is,
+to the starting value of dot.
+
+Examples
+
+Here are some example one-line templates demonstrating pipelines and variables.
+All produce the quoted word "output":
+
+	{{"\"output\""}}
+		A string constant.
+	{{`"output"`}}
+		A raw string constant.
+	{{printf "%q" "output"}}
+		A function call.
+	{{"output" | printf "%q"}}
+		A function call whose final argument comes from the previous
+		command.
+	{{printf "%q" (print "out" "put")}}
+		A parenthesized argument.
+	{{"put" | printf "%s%s" "out" | printf "%q"}}
+		A more elaborate call.
+	{{"output" | printf "%s" | printf "%q"}}
+		A longer chain.
+	{{with "output"}}{{printf "%q" .}}{{end}}
+		A with action using dot.
+	{{with $x := "output" | printf "%q"}}{{$x}}{{end}}
+		A with action that creates and uses a variable.
+	{{with $x := "output"}}{{printf "%q" $x}}{{end}}
+		A with action that uses the variable in another action.
+	{{with $x := "output"}}{{$x | printf "%q"}}{{end}}
+		The same, but pipelined.
+
+Functions
+
+During execution functions are found in two function maps: first in the
+template, then in the global function map. By default, no functions are defined
+in the template but the Funcs method can be used to add them.
+
+Predefined global functions are named as follows.
+
+	and
+		Returns the boolean AND of its arguments by returning the
+		first empty argument or the last argument, that is,
+		"and x y" behaves as "if x then y else x". All the
+		arguments are evaluated.
+	call
+		Returns the result of calling the first argument, which
+		must be a function, with the remaining arguments as parameters.
+		Thus "call .X.Y 1 2" is, in Go notation, dot.X.Y(1, 2) where
+		Y is a func-valued field, map entry, or the like.
+		The first argument must be the result of an evaluation
+		that yields a value of function type (as distinct from
+		a predefined function such as print). The function must
+		return either one or two result values, the second of which
+		is of type error. If the arguments don't match the function
+		or the returned error value is non-nil, execution stops.
+	html
+		Returns the escaped HTML equivalent of the textual
+		representation of its arguments.
+	index
+		Returns the result of indexing its first argument by the
+		following arguments. Thus "index x 1 2 3" is, in Go syntax,
+		x[1][2][3]. Each indexed item must be a map, slice, or array.
+	js
+		Returns the escaped JavaScript equivalent of the textual
+		representation of its arguments.
+	len
+		Returns the integer length of its argument.
+	not
+		Returns the boolean negation of its single argument.
+	or
+		Returns the boolean OR of its arguments by returning the
+		first non-empty argument or the last argument, that is,
+		"or x y" behaves as "if x then x else y". All the
+		arguments are evaluated.
+	print
+		An alias for fmt.Sprint
+	printf
+		An alias for fmt.Sprintf
+	println
+		An alias for fmt.Sprintln
+	urlquery
+		Returns the escaped value of the textual representation of
+		its arguments in a form suitable for embedding in a URL query.
+
+The boolean functions take any zero value to be false and a non-zero
+value to be true.
+
+There is also a set of binary comparison operators defined as
+functions:
+
+	eq
+		Returns the boolean truth of arg1 == arg2
+	ne
+		Returns the boolean truth of arg1 != arg2
+	lt
+		Returns the boolean truth of arg1 < arg2
+	le
+		Returns the boolean truth of arg1 <= arg2
+	gt
+		Returns the boolean truth of arg1 > arg2
+	ge
+		Returns the boolean truth of arg1 >= arg2
+
+For simpler multi-way equality tests, eq (only) accepts two or more
+arguments and compares the second and subsequent to the first,
+returning in effect
+
+	arg1==arg2 || arg1==arg3 || arg1==arg4 ...
+
+(Unlike with || in Go, however, eq is a function call and all the
+arguments will be evaluated.)
+
+The comparison functions work on basic types only (or named basic
+types, such as "type Celsius float32"). They implement the Go rules
+for comparison of values, except that size and exact type are
+ignored, so any integer value, signed or unsigned, may be compared
+with any other integer value. (The arithmetic value is compared,
+not the bit pattern, so all negative integers are less than all
+unsigned integers.) However, as usual, one may not compare an int
+with a float32 and so on.
+
+Associated templates
+
+Each template is named by a string specified when it is created. Also, each
+template is associated with zero or more other templates that it may invoke by
+name; such associations are transitive and form a name space of templates.
+
+A template may use a template invocation to instantiate another associated
+template; see the explanation of the "template" action above. The name must be
+that of a template associated with the template that contains the invocation.
+
+Nested template definitions
+
+When parsing a template, another template may be defined and associated with the
+template being parsed. Template definitions must appear at the top level of the
+template, much like global variables in a Go program.
+
+The syntax of such definitions is to surround each template declaration with a
+"define" and "end" action.
+
+The define action names the template being created by providing a string
+constant. Here is a simple example:
+
+	`{{define "T1"}}ONE{{end}}
+	{{define "T2"}}TWO{{end}}
+	{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
+	{{template "T3"}}`
+
+This defines two templates, T1 and T2, and a third T3 that invokes the other two
+when it is executed. Finally it invokes T3. If executed this template will
+produce the text
+
+	ONE TWO
+
+By construction, a template may reside in only one association. If it's
+necessary to have a template addressable from multiple associations, the
+template definition must be parsed multiple times to create distinct *Template
+values, or must be copied with the Clone or AddParseTree method.
+
+Parse may be called multiple times to assemble the various associated templates;
+see the ParseFiles and ParseGlob functions and methods for simple ways to parse
+related templates stored in files.
+
+A template may be executed directly or through ExecuteTemplate, which executes
+an associated template identified by name. To invoke our example above, we
+might write,
+
+	err := tmpl.Execute(os.Stdout, "no data needed")
+	if err != nil {
+		log.Fatalf("execution failed: %s", err)
+	}
+
+or to invoke a particular template explicitly by name,
+
+	err := tmpl.ExecuteTemplate(os.Stdout, "T2", "no data needed")
+	if err != nil {
+		log.Fatalf("execution failed: %s", err)
+	}
+
+*/
+package template
diff --git a/vendor/github.com/alecthomas/template/exec.go b/vendor/github.com/alecthomas/template/exec.go
new file mode 100644
index 00000000..cc155b0f
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/exec.go
@@ -0,0 +1,844 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package template
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"github.com/alecthomas/template/parse"
+)
+
+// state represents the state of an execution. It's not part of the
+// template so that multiple executions of the same template
+// can execute in parallel.
+type state struct {
+	tmpl *Template
+	wr   io.Writer
+	node parse.Node // current node, for errors
+	vars []variable // push-down stack of variable values.
+}
+
+// variable holds the dynamic value of a variable such as $, $x etc.
+type variable struct {
+	name  string
+	value reflect.Value
+}
+
+// push pushes a new variable on the stack.
+func (s *state) push(name string, value reflect.Value) {
+	s.vars = append(s.vars, variable{name, value})
+}
+
+// mark returns the length of the variable stack.
+func (s *state) mark() int {
+	return len(s.vars)
+}
+
+// pop pops the variable stack up to the mark.
+func (s *state) pop(mark int) {
+	s.vars = s.vars[0:mark]
+}
+
+// setVar overwrites the top-nth variable on the stack. Used by range iterations.
+func (s *state) setVar(n int, value reflect.Value) {
+	s.vars[len(s.vars)-n].value = value
+}
+
+// varValue returns the value of the named variable.
+func (s *state) varValue(name string) reflect.Value {
+	for i := s.mark() - 1; i >= 0; i-- {
+		if s.vars[i].name == name {
+			return s.vars[i].value
+		}
+	}
+	s.errorf("undefined variable: %s", name)
+	return zero
+}
+
+var zero reflect.Value
+
+// at marks the state to be on node n, for error reporting.
+func (s *state) at(node parse.Node) {
+	s.node = node
+}
+
+// doublePercent returns the string with %'s replaced by %%, if necessary,
+// so it can be used safely inside a Printf format string.
+func doublePercent(str string) string {
+	if strings.Contains(str, "%") {
+		str = strings.Replace(str, "%", "%%", -1)
+	}
+	return str
+}
+
+// errorf formats the error and terminates processing.
+func (s *state) errorf(format string, args ...interface{}) {
+	name := doublePercent(s.tmpl.Name())
+	if s.node == nil {
+		format = fmt.Sprintf("template: %s: %s", name, format)
+	} else {
+		location, context := s.tmpl.ErrorContext(s.node)
+		format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format)
+	}
+	panic(fmt.Errorf(format, args...))
+}
+
+// errRecover is the handler that turns panics into returns from the top
+// level of Parse.
+func errRecover(errp *error) {
+	e := recover()
+	if e != nil {
+		switch err := e.(type) {
+		case runtime.Error:
+			panic(e)
+		case error:
+			*errp = err
+		default:
+			panic(e)
+		}
+	}
+}
+
+// ExecuteTemplate applies the template associated with t that has the given name
+// to the specified data object and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel.
+func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error {
+	tmpl := t.tmpl[name]
+	if tmpl == nil {
+		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
+	}
+	return tmpl.Execute(wr, data)
+}
+
+// Execute applies a parsed template to the specified data object,
+// and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel.
+func (t *Template) Execute(wr io.Writer, data interface{}) (err error) {
+	defer errRecover(&err)
+	value := reflect.ValueOf(data)
+	state := &state{
+		tmpl: t,
+		wr:   wr,
+		vars: []variable{{"$", value}},
+	}
+	t.init()
+	if t.Tree == nil || t.Root == nil {
+		var b bytes.Buffer
+		for name, tmpl := range t.tmpl {
+			if tmpl.Tree == nil || tmpl.Root == nil {
+				continue
+			}
+			if b.Len() > 0 {
+				b.WriteString(", ")
+			}
+			fmt.Fprintf(&b, "%q", name)
+		}
+		var s string
+		if b.Len() > 0 {
+			s = "; defined templates are: " + b.String()
+		}
+		state.errorf("%q is an incomplete or empty template%s", t.Name(), s)
+	}
+	state.walk(value, t.Root)
+	return
+}
+
+// Walk functions step through the major pieces of the template structure,
+// generating output as they go.
+func (s *state) walk(dot reflect.Value, node parse.Node) {
+	s.at(node)
+	switch node := node.(type) {
+	case *parse.ActionNode:
+		// Do not pop variables so they persist until next end.
+		// Also, if the action declares variables, don't print the result.
+		val := s.evalPipeline(dot, node.Pipe)
+		if len(node.Pipe.Decl) == 0 {
+			s.printValue(node, val)
+		}
+	case *parse.IfNode:
+		s.walkIfOrWith(parse.NodeIf, dot, node.Pipe, node.List, node.ElseList)
+	case *parse.ListNode:
+		for _, node := range node.Nodes {
+			s.walk(dot, node)
+		}
+	case *parse.RangeNode:
+		s.walkRange(dot, node)
+	case *parse.TemplateNode:
+		s.walkTemplate(dot, node)
+	case *parse.TextNode:
+		if _, err := s.wr.Write(node.Text); err != nil {
+			s.errorf("%s", err)
+		}
+	case *parse.WithNode:
+		s.walkIfOrWith(parse.NodeWith, dot, node.Pipe, node.List, node.ElseList)
+	default:
+		s.errorf("unknown node: %s", node)
+	}
+}
+
+// walkIfOrWith walks an 'if' or 'with' node. The two control structures
+// are identical in behavior except that 'with' sets dot.
+func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
+	defer s.pop(s.mark())
+	val := s.evalPipeline(dot, pipe)
+	truth, ok := isTrue(val)
+	if !ok {
+		s.errorf("if/with can't use %v", val)
+	}
+	if truth {
+		if typ == parse.NodeWith {
+			s.walk(val, list)
+		} else {
+			s.walk(dot, list)
+		}
+	} else if elseList != nil {
+		s.walk(dot, elseList)
+	}
+}
+
+// isTrue reports whether the value is 'true', in the sense of not the zero of its type,
+// and whether the value has a meaningful truth value.
+func isTrue(val reflect.Value) (truth, ok bool) {
+	if !val.IsValid() {
+		// Something like var x interface{}, never set. It's a form of nil.
+		return false, true
+	}
+	switch val.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		truth = val.Len() > 0
+	case reflect.Bool:
+		truth = val.Bool()
+	case reflect.Complex64, reflect.Complex128:
+		truth = val.Complex() != 0
+	case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface:
+		truth = !val.IsNil()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		truth = val.Int() != 0
+	case reflect.Float32, reflect.Float64:
+		truth = val.Float() != 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		truth = val.Uint() != 0
+	case reflect.Struct:
+		truth = true // Struct values are always true.
+	default:
+		return
+	}
+	return truth, true
+}
+
+func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
+	s.at(r)
+	defer s.pop(s.mark())
+	val, _ := indirect(s.evalPipeline(dot, r.Pipe))
+	// mark top of stack before any variables in the body are pushed.
+	mark := s.mark()
+	oneIteration := func(index, elem reflect.Value) {
+		// Set top var (lexically the second if there are two) to the element.
+		if len(r.Pipe.Decl) > 0 {
+			s.setVar(1, elem)
+		}
+		// Set next var (lexically the first if there are two) to the index.
+		if len(r.Pipe.Decl) > 1 {
+			s.setVar(2, index)
+		}
+		s.walk(elem, r.List)
+		s.pop(mark)
+	}
+	switch val.Kind() {
+	case reflect.Array, reflect.Slice:
+		if val.Len() == 0 {
+			break
+		}
+		for i := 0; i < val.Len(); i++ {
+			oneIteration(reflect.ValueOf(i), val.Index(i))
+		}
+		return
+	case reflect.Map:
+		if val.Len() == 0 {
+			break
+		}
+		for _, key := range sortKeys(val.MapKeys()) {
+			oneIteration(key, val.MapIndex(key))
+		}
+		return
+	case reflect.Chan:
+		if val.IsNil() {
+			break
+		}
+		i := 0
+		for ; ; i++ {
+			elem, ok := val.Recv()
+			if !ok {
+				break
+			}
+			oneIteration(reflect.ValueOf(i), elem)
+		}
+		if i == 0 {
+			break
+		}
+		return
+	case reflect.Invalid:
+		break // An invalid value is likely a nil map, etc. and acts like an empty map.
+	default:
+		s.errorf("range can't iterate over %v", val)
+	}
+	if r.ElseList != nil {
+		s.walk(dot, r.ElseList)
+	}
+}
+
+func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
+	s.at(t)
+	tmpl := s.tmpl.tmpl[t.Name]
+	if tmpl == nil {
+		s.errorf("template %q not defined", t.Name)
+	}
+	// Variables declared by the pipeline persist.
+	dot = s.evalPipeline(dot, t.Pipe)
+	newState := *s
+	newState.tmpl = tmpl
+	// No dynamic scoping: template invocations inherit no variables.
+	newState.vars = []variable{{"$", dot}}
+	newState.walk(dot, tmpl.Root)
+}
+
+// Eval functions evaluate pipelines, commands, and their elements and extract
+// values from the data structure by examining fields, calling methods, and so on.
+// The printing of those values happens only through walk functions.
+
+// evalPipeline returns the value acquired by evaluating a pipeline. If the
+// pipeline has a variable declaration, the variable will be pushed on the
+// stack. Callers should therefore pop the stack after they are finished
+// executing commands depending on the pipeline value.
+func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
+	if pipe == nil {
+		return
+	}
+	s.at(pipe)
+	for _, cmd := range pipe.Cmds {
+		value = s.evalCommand(dot, cmd, value) // previous value is this one's final arg.
+		// If the object has type interface{}, dig down one level to the thing inside.
+		if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
+			value = reflect.ValueOf(value.Interface()) // lovely!
+		}
+	}
+	for _, variable := range pipe.Decl {
+		s.push(variable.Ident[0], value)
+	}
+	return value
+}
+
+func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
+	if len(args) > 1 || final.IsValid() {
+		s.errorf("can't give argument to non-function %s", args[0])
+	}
+}
+
+func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
+	firstWord := cmd.Args[0]
+	switch n := firstWord.(type) {
+	case *parse.FieldNode:
+		return s.evalFieldNode(dot, n, cmd.Args, final)
+	case *parse.ChainNode:
+		return s.evalChainNode(dot, n, cmd.Args, final)
+	case *parse.IdentifierNode:
+		// Must be a function.
+		return s.evalFunction(dot, n, cmd, cmd.Args, final)
+	case *parse.PipeNode:
+		// Parenthesized pipeline. The arguments are all inside the pipeline; final is ignored.
+		return s.evalPipeline(dot, n)
+	case *parse.VariableNode:
+		return s.evalVariableNode(dot, n, cmd.Args, final)
+	}
+	s.at(firstWord)
+	s.notAFunction(cmd.Args, final)
+	switch word := firstWord.(type) {
+	case *parse.BoolNode:
+		return reflect.ValueOf(word.True)
+	case *parse.DotNode:
+		return dot
+	case *parse.NilNode:
+		s.errorf("nil is not a command")
+	case *parse.NumberNode:
+		return s.idealConstant(word)
+	case *parse.StringNode:
+		return reflect.ValueOf(word.Text)
+	}
+	s.errorf("can't evaluate command %q", firstWord)
+	panic("not reached")
+}
+
+// idealConstant is called to return the value of a number in a context where
+// we don't know the type. In that case, the syntax of the number tells us
+// its type, and we use Go rules to resolve.  Note there is no such thing as
+// a uint ideal constant in this situation - the value must be of int type.
+func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
+	// These are ideal constants but we don't know the type
+	// and we have no context.  (If it was a method argument,
+	// we'd know what we need.) The syntax guides us to some extent.
+	s.at(constant)
+	switch {
+	case constant.IsComplex:
+		return reflect.ValueOf(constant.Complex128) // incontrovertible.
+	case constant.IsFloat && !isHexConstant(constant.Text) && strings.IndexAny(constant.Text, ".eE") >= 0:
+		return reflect.ValueOf(constant.Float64)
+	case constant.IsInt:
+		n := int(constant.Int64)
+		if int64(n) != constant.Int64 {
+			s.errorf("%s overflows int", constant.Text)
+		}
+		return reflect.ValueOf(n)
+	case constant.IsUint:
+		s.errorf("%s overflows int", constant.Text)
+	}
+	return zero
+}
+
+func isHexConstant(s string) bool {
+	return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')
+}
+
+func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
+	s.at(field)
+	return s.evalFieldChain(dot, dot, field, field.Ident, args, final)
+}
+
+func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
+	s.at(chain)
+	// (pipe).Field1.Field2 has pipe as .Node, fields as .Field. Eval the pipeline, then the fields.
+	pipe := s.evalArg(dot, nil, chain.Node)
+	if len(chain.Field) == 0 {
+		s.errorf("internal error: no fields in evalChainNode")
+	}
+	return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final)
+}
+
+func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
+	// $x.Field has $x as the first ident, Field as the second. Eval the var, then the fields.
+	s.at(variable)
+	value := s.varValue(variable.Ident[0])
+	if len(variable.Ident) == 1 {
+		s.notAFunction(args, final)
+		return value
+	}
+	return s.evalFieldChain(dot, value, variable, variable.Ident[1:], args, final)
+}
+
+// evalFieldChain evaluates .X.Y.Z possibly followed by arguments.
+// dot is the environment in which to evaluate arguments, while
+// receiver is the value being walked along the chain.
+func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
+	n := len(ident)
+	for i := 0; i < n-1; i++ {
+		receiver = s.evalField(dot, ident[i], node, nil, zero, receiver)
+	}
+	// Now if it's a method, it gets the arguments.
+	return s.evalField(dot, ident[n-1], node, args, final, receiver)
+}
+
+func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
+	s.at(node)
+	name := node.Ident
+	function, ok := findFunction(name, s.tmpl)
+	if !ok {
+		s.errorf("%q is not a defined function", name)
+	}
+	return s.evalCall(dot, function, cmd, name, args, final)
+}
+
+// evalField evaluates an expression like (.Field) or (.Field arg1 arg2).
+// The 'final' argument represents the return value from the preceding
+// value of the pipeline, if any.
+func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
+	if !receiver.IsValid() {
+		return zero
+	}
+	typ := receiver.Type()
+	receiver, _ = indirect(receiver)
+	// Unless it's an interface, need to get to a value of type *T to guarantee
+	// we see all methods of T and *T.
+	ptr := receiver
+	if ptr.Kind() != reflect.Interface && ptr.CanAddr() {
+		ptr = ptr.Addr()
+	}
+	if method := ptr.MethodByName(fieldName); method.IsValid() {
+		return s.evalCall(dot, method, node, fieldName, args, final)
+	}
+	hasArgs := len(args) > 1 || final.IsValid()
+	// It's not a method; must be a field of a struct or an element of a map. The receiver must not be nil.
+	receiver, isNil := indirect(receiver)
+	if isNil {
+		s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
+	}
+	switch receiver.Kind() {
+	case reflect.Struct:
+		tField, ok := receiver.Type().FieldByName(fieldName)
+		if ok {
+			field := receiver.FieldByIndex(tField.Index)
+			if tField.PkgPath != "" { // field is unexported
+				s.errorf("%s is an unexported field of struct type %s", fieldName, typ)
+			}
+			// If it's a function, we must call it.
+			if hasArgs {
+				s.errorf("%s has arguments but cannot be invoked as function", fieldName)
+			}
+			return field
+		}
+		s.errorf("%s is not a field of struct type %s", fieldName, typ)
+	case reflect.Map:
+		// If it's a map, attempt to use the field name as a key.
+		nameVal := reflect.ValueOf(fieldName)
+		if nameVal.Type().AssignableTo(receiver.Type().Key()) {
+			if hasArgs {
+				s.errorf("%s is not a method but has arguments", fieldName)
+			}
+			return receiver.MapIndex(nameVal)
+		}
+	}
+	s.errorf("can't evaluate field %s in type %s", fieldName, typ)
+	panic("not reached")
+}
+
+var (
+	errorType       = reflect.TypeOf((*error)(nil)).Elem()
+	fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
+)
+
+// evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so
+// it looks just like a function call.  The arg list, if non-nil, includes (in the manner of the shell), arg[0]
+// as the function itself.
+func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
+	if args != nil {
+		args = args[1:] // Zeroth arg is function name/node; not passed to function.
+	}
+	typ := fun.Type()
+	numIn := len(args)
+	if final.IsValid() {
+		numIn++
+	}
+	numFixed := len(args)
+	if typ.IsVariadic() {
+		numFixed = typ.NumIn() - 1 // last arg is the variadic one.
+		if numIn < numFixed {
+			s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args))
+		}
+	} else if numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() {
+		s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), len(args))
+	}
+	if !goodFunc(typ) {
+		// TODO: This could still be a confusing error; maybe goodFunc should provide info.
+		s.errorf("can't call method/function %q with %d results", name, typ.NumOut())
+	}
+	// Build the arg list.
+	argv := make([]reflect.Value, numIn)
+	// Args must be evaluated. Fixed args first.
+	i := 0
+	for ; i < numFixed && i < len(args); i++ {
+		argv[i] = s.evalArg(dot, typ.In(i), args[i])
+	}
+	// Now the ... args.
+	if typ.IsVariadic() {
+		argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice.
+		for ; i < len(args); i++ {
+			argv[i] = s.evalArg(dot, argType, args[i])
+		}
+	}
+	// Add final value if necessary.
+	if final.IsValid() {
+		t := typ.In(typ.NumIn() - 1)
+		if typ.IsVariadic() {
+			t = t.Elem()
+		}
+		argv[i] = s.validateType(final, t)
+	}
+	result := fun.Call(argv)
+	// If we have an error that is not nil, stop execution and return that error to the caller.
+	if len(result) == 2 && !result[1].IsNil() {
+		s.at(node)
+		s.errorf("error calling %s: %s", name, result[1].Interface().(error))
+	}
+	return result[0]
+}
+
+// canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero.
+func canBeNil(typ reflect.Type) bool {
+	switch typ.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return true
+	}
+	return false
+}
+
+// validateType guarantees that the value is valid and assignable to the type.
+func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
+	if !value.IsValid() {
+		if typ == nil || canBeNil(typ) {
+			// An untyped nil interface{}. Accept as a proper nil value.
+			return reflect.Zero(typ)
+		}
+		s.errorf("invalid value; expected %s", typ)
+	}
+	if typ != nil && !value.Type().AssignableTo(typ) {
+		if value.Kind() == reflect.Interface && !value.IsNil() {
+			value = value.Elem()
+			if value.Type().AssignableTo(typ) {
+				return value
+			}
+			// fallthrough
+		}
+		// Does one dereference or indirection work? We could do more, as we
+		// do with method receivers, but that gets messy and method receivers
+		// are much more constrained, so it makes more sense there than here.
+		// Besides, one is almost always all you need.
+		switch {
+		case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ):
+			value = value.Elem()
+			if !value.IsValid() {
+				s.errorf("dereference of nil pointer of type %s", typ)
+			}
+		case reflect.PtrTo(value.Type()).AssignableTo(typ) && value.CanAddr():
+			value = value.Addr()
+		default:
+			s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
+		}
+	}
+	return value
+}
+
+func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	switch arg := n.(type) {
+	case *parse.DotNode:
+		return s.validateType(dot, typ)
+	case *parse.NilNode:
+		if canBeNil(typ) {
+			return reflect.Zero(typ)
+		}
+		s.errorf("cannot assign nil to %s", typ)
+	case *parse.FieldNode:
+		return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, zero), typ)
+	case *parse.VariableNode:
+		return s.validateType(s.evalVariableNode(dot, arg, nil, zero), typ)
+	case *parse.PipeNode:
+		return s.validateType(s.evalPipeline(dot, arg), typ)
+	case *parse.IdentifierNode:
+		return s.evalFunction(dot, arg, arg, nil, zero)
+	case *parse.ChainNode:
+		return s.validateType(s.evalChainNode(dot, arg, nil, zero), typ)
+	}
+	switch typ.Kind() {
+	case reflect.Bool:
+		return s.evalBool(typ, n)
+	case reflect.Complex64, reflect.Complex128:
+		return s.evalComplex(typ, n)
+	case reflect.Float32, reflect.Float64:
+		return s.evalFloat(typ, n)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return s.evalInteger(typ, n)
+	case reflect.Interface:
+		if typ.NumMethod() == 0 {
+			return s.evalEmptyInterface(dot, n)
+		}
+	case reflect.String:
+		return s.evalString(typ, n)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return s.evalUnsignedInteger(typ, n)
+	}
+	s.errorf("can't handle %s for arg of type %s", n, typ)
+	panic("not reached")
+}
+
+func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.BoolNode); ok {
+		value := reflect.New(typ).Elem()
+		value.SetBool(n.True)
+		return value
+	}
+	s.errorf("expected bool; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.StringNode); ok {
+		value := reflect.New(typ).Elem()
+		value.SetString(n.Text)
+		return value
+	}
+	s.errorf("expected string; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.NumberNode); ok && n.IsInt {
+		value := reflect.New(typ).Elem()
+		value.SetInt(n.Int64)
+		return value
+	}
+	s.errorf("expected integer; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.NumberNode); ok && n.IsUint {
+		value := reflect.New(typ).Elem()
+		value.SetUint(n.Uint64)
+		return value
+	}
+	s.errorf("expected unsigned integer; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
+	s.at(n)
+	if n, ok := n.(*parse.NumberNode); ok && n.IsFloat {
+		value := reflect.New(typ).Elem()
+		value.SetFloat(n.Float64)
+		return value
+	}
+	s.errorf("expected float; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
+	if n, ok := n.(*parse.NumberNode); ok && n.IsComplex {
+		value := reflect.New(typ).Elem()
+		value.SetComplex(n.Complex128)
+		return value
+	}
+	s.errorf("expected complex; found %s", n)
+	panic("not reached")
+}
+
+func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
+	s.at(n)
+	switch n := n.(type) {
+	case *parse.BoolNode:
+		return reflect.ValueOf(n.True)
+	case *parse.DotNode:
+		return dot
+	case *parse.FieldNode:
+		return s.evalFieldNode(dot, n, nil, zero)
+	case *parse.IdentifierNode:
+		return s.evalFunction(dot, n, n, nil, zero)
+	case *parse.NilNode:
+		// NilNode is handled in evalArg, the only place that calls here.
+		s.errorf("evalEmptyInterface: nil (can't happen)")
+	case *parse.NumberNode:
+		return s.idealConstant(n)
+	case *parse.StringNode:
+		return reflect.ValueOf(n.Text)
+	case *parse.VariableNode:
+		return s.evalVariableNode(dot, n, nil, zero)
+	case *parse.PipeNode:
+		return s.evalPipeline(dot, n)
+	}
+	s.errorf("can't handle assignment of %s to empty interface argument", n)
+	panic("not reached")
+}
+
+// indirect returns the item at the end of indirection, and a bool to indicate if it's nil.
+// We indirect through pointers and empty interfaces (only) because
+// non-empty interfaces have methods we might need.
+func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
+	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
+		if v.IsNil() {
+			return v, true
+		}
+		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
+			break
+		}
+	}
+	return v, false
+}
+
+// printValue writes the textual representation of the value to the output of
+// the template.
+func (s *state) printValue(n parse.Node, v reflect.Value) {
+	s.at(n)
+	iface, ok := printableValue(v)
+	if !ok {
+		s.errorf("can't print %s of type %s", n, v.Type())
+	}
+	fmt.Fprint(s.wr, iface)
+}
+
+// printableValue returns the, possibly indirected, interface value inside v that
+// is best for a call to formatted printer.
+func printableValue(v reflect.Value) (interface{}, bool) {
+	if v.Kind() == reflect.Ptr {
+		v, _ = indirect(v) // fmt.Fprint handles nil.
+	}
+	if !v.IsValid() {
+		return "<no value>", true
+	}
+
+	if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
+		if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
+			v = v.Addr()
+		} else {
+			switch v.Kind() {
+			case reflect.Chan, reflect.Func:
+				return nil, false
+			}
+		}
+	}
+	return v.Interface(), true
+}
+
+// Types to help sort the keys in a map for reproducible output.
+
+type rvs []reflect.Value
+
+func (x rvs) Len() int      { return len(x) }
+func (x rvs) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+type rvInts struct{ rvs }
+
+func (x rvInts) Less(i, j int) bool { return x.rvs[i].Int() < x.rvs[j].Int() }
+
+type rvUints struct{ rvs }
+
+func (x rvUints) Less(i, j int) bool { return x.rvs[i].Uint() < x.rvs[j].Uint() }
+
+type rvFloats struct{ rvs }
+
+func (x rvFloats) Less(i, j int) bool { return x.rvs[i].Float() < x.rvs[j].Float() }
+
+type rvStrings struct{ rvs }
+
+func (x rvStrings) Less(i, j int) bool { return x.rvs[i].String() < x.rvs[j].String() }
+
+// sortKeys sorts (if it can) the slice of reflect.Values, which is a slice of map keys.
+func sortKeys(v []reflect.Value) []reflect.Value {
+	if len(v) <= 1 {
+		return v
+	}
+	switch v[0].Kind() {
+	case reflect.Float32, reflect.Float64:
+		sort.Sort(rvFloats{v})
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		sort.Sort(rvInts{v})
+	case reflect.String:
+		sort.Sort(rvStrings{v})
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		sort.Sort(rvUints{v})
+	}
+	return v
+}
diff --git a/vendor/github.com/alecthomas/template/funcs.go b/vendor/github.com/alecthomas/template/funcs.go
new file mode 100644
index 00000000..39ee5ed6
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/funcs.go
@@ -0,0 +1,598 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package template
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"reflect"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// FuncMap is the type of the map defining the mapping from names to functions.
+// Each function must have either a single return value, or two return values of
+// which the second has type error. In that case, if the second (error)
+// return value evaluates to non-nil during execution, execution terminates and
+// Execute returns that error.
+type FuncMap map[string]interface{}
+
+var builtins = FuncMap{
+	"and":      and,
+	"call":     call,
+	"html":     HTMLEscaper,
+	"index":    index,
+	"js":       JSEscaper,
+	"len":      length,
+	"not":      not,
+	"or":       or,
+	"print":    fmt.Sprint,
+	"printf":   fmt.Sprintf,
+	"println":  fmt.Sprintln,
+	"urlquery": URLQueryEscaper,
+
+	// Comparisons
+	"eq": eq, // ==
+	"ge": ge, // >=
+	"gt": gt, // >
+	"le": le, // <=
+	"lt": lt, // <
+	"ne": ne, // !=
+}
+
+var builtinFuncs = createValueFuncs(builtins)
+
+// createValueFuncs turns a FuncMap into a map[string]reflect.Value
+func createValueFuncs(funcMap FuncMap) map[string]reflect.Value {
+	m := make(map[string]reflect.Value)
+	addValueFuncs(m, funcMap)
+	return m
+}
+
+// addValueFuncs adds to values the functions in funcs, converting them to reflect.Values.
+func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
+	for name, fn := range in {
+		v := reflect.ValueOf(fn)
+		if v.Kind() != reflect.Func {
+			panic("value for " + name + " not a function")
+		}
+		if !goodFunc(v.Type()) {
+			panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
+		}
+		out[name] = v
+	}
+}
+
+// addFuncs adds to values the functions in funcs. It does no checking of the input -
+// call addValueFuncs first.
+func addFuncs(out, in FuncMap) {
+	for name, fn := range in {
+		out[name] = fn
+	}
+}
+
+// goodFunc checks that the function or method has the right result signature.
+func goodFunc(typ reflect.Type) bool {
+	// We allow functions with 1 result or 2 results where the second is an error.
+	switch {
+	case typ.NumOut() == 1:
+		return true
+	case typ.NumOut() == 2 && typ.Out(1) == errorType:
+		return true
+	}
+	return false
+}
+
+// findFunction looks for a function in the template, and global map.
+func findFunction(name string, tmpl *Template) (reflect.Value, bool) {
+	if tmpl != nil && tmpl.common != nil {
+		if fn := tmpl.execFuncs[name]; fn.IsValid() {
+			return fn, true
+		}
+	}
+	if fn := builtinFuncs[name]; fn.IsValid() {
+		return fn, true
+	}
+	return reflect.Value{}, false
+}
+
+// Indexing.
+
+// index returns the result of indexing its first argument by the following
+// arguments.  Thus "index x 1 2 3" is, in Go syntax, x[1][2][3]. Each
+// indexed item must be a map, slice, or array.
+func index(item interface{}, indices ...interface{}) (interface{}, error) {
+	v := reflect.ValueOf(item)
+	for _, i := range indices {
+		index := reflect.ValueOf(i)
+		var isNil bool
+		if v, isNil = indirect(v); isNil {
+			return nil, fmt.Errorf("index of nil pointer")
+		}
+		switch v.Kind() {
+		case reflect.Array, reflect.Slice, reflect.String:
+			var x int64
+			switch index.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				x = index.Int()
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+				x = int64(index.Uint())
+			default:
+				return nil, fmt.Errorf("cannot index slice/array with type %s", index.Type())
+			}
+			if x < 0 || x >= int64(v.Len()) {
+				return nil, fmt.Errorf("index out of range: %d", x)
+			}
+			v = v.Index(int(x))
+		case reflect.Map:
+			if !index.IsValid() {
+				index = reflect.Zero(v.Type().Key())
+			}
+			if !index.Type().AssignableTo(v.Type().Key()) {
+				return nil, fmt.Errorf("%s is not index type for %s", index.Type(), v.Type())
+			}
+			if x := v.MapIndex(index); x.IsValid() {
+				v = x
+			} else {
+				v = reflect.Zero(v.Type().Elem())
+			}
+		default:
+			return nil, fmt.Errorf("can't index item of type %s", v.Type())
+		}
+	}
+	return v.Interface(), nil
+}
+
+// Length
+
+// length returns the length of the item, with an error if it has no defined length.
+func length(item interface{}) (int, error) {
+	v, isNil := indirect(reflect.ValueOf(item))
+	if isNil {
+		return 0, fmt.Errorf("len of nil pointer")
+	}
+	switch v.Kind() {
+	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len(), nil
+	}
+	return 0, fmt.Errorf("len of type %s", v.Type())
+}
+
+// Function invocation
+
+// call returns the result of evaluating the first argument as a function.
+// The function must return 1 result, or 2 results, the second of which is an error.
+func call(fn interface{}, args ...interface{}) (interface{}, error) {
+	v := reflect.ValueOf(fn)
+	typ := v.Type()
+	if typ.Kind() != reflect.Func {
+		return nil, fmt.Errorf("non-function of type %s", typ)
+	}
+	if !goodFunc(typ) {
+		return nil, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
+	}
+	numIn := typ.NumIn()
+	var dddType reflect.Type
+	if typ.IsVariadic() {
+		if len(args) < numIn-1 {
+			return nil, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
+		}
+		dddType = typ.In(numIn - 1).Elem()
+	} else {
+		if len(args) != numIn {
+			return nil, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
+		}
+	}
+	argv := make([]reflect.Value, len(args))
+	for i, arg := range args {
+		value := reflect.ValueOf(arg)
+		// Compute the expected type. Clumsy because of variadics.
+		var argType reflect.Type
+		if !typ.IsVariadic() || i < numIn-1 {
+			argType = typ.In(i)
+		} else {
+			argType = dddType
+		}
+		if !value.IsValid() && canBeNil(argType) {
+			value = reflect.Zero(argType)
+		}
+		if !value.Type().AssignableTo(argType) {
+			return nil, fmt.Errorf("arg %d has type %s; should be %s", i, value.Type(), argType)
+		}
+		argv[i] = value
+	}
+	result := v.Call(argv)
+	if len(result) == 2 && !result[1].IsNil() {
+		return result[0].Interface(), result[1].Interface().(error)
+	}
+	return result[0].Interface(), nil
+}
+
+// Boolean logic.
+
+func truth(a interface{}) bool {
+	t, _ := isTrue(reflect.ValueOf(a))
+	return t
+}
+
+// and computes the Boolean AND of its arguments, returning
+// the first false argument it encounters, or the last argument.
+func and(arg0 interface{}, args ...interface{}) interface{} {
+	if !truth(arg0) {
+		return arg0
+	}
+	for i := range args {
+		arg0 = args[i]
+		if !truth(arg0) {
+			break
+		}
+	}
+	return arg0
+}
+
+// or computes the Boolean OR of its arguments, returning
+// the first true argument it encounters, or the last argument.
+func or(arg0 interface{}, args ...interface{}) interface{} {
+	if truth(arg0) {
+		return arg0
+	}
+	for i := range args {
+		arg0 = args[i]
+		if truth(arg0) {
+			break
+		}
+	}
+	return arg0
+}
+
+// not returns the Boolean negation of its argument.
+func not(arg interface{}) (truth bool) {
+	truth, _ = isTrue(reflect.ValueOf(arg))
+	return !truth
+}
+
+// Comparison.
+
+// TODO: Perhaps allow comparison between signed and unsigned integers.
+
+var (
+	errBadComparisonType = errors.New("invalid type for comparison")
+	errBadComparison     = errors.New("incompatible types for comparison")
+	errNoComparison      = errors.New("missing argument for comparison")
+)
+
+type kind int
+
+const (
+	invalidKind kind = iota
+	boolKind
+	complexKind
+	intKind
+	floatKind
+	integerKind
+	stringKind
+	uintKind
+)
+
+func basicKind(v reflect.Value) (kind, error) {
+	switch v.Kind() {
+	case reflect.Bool:
+		return boolKind, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return intKind, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return uintKind, nil
+	case reflect.Float32, reflect.Float64:
+		return floatKind, nil
+	case reflect.Complex64, reflect.Complex128:
+		return complexKind, nil
+	case reflect.String:
+		return stringKind, nil
+	}
+	return invalidKind, errBadComparisonType
+}
+
+// eq evaluates the comparison a == b || a == c || ...
+func eq(arg1 interface{}, arg2 ...interface{}) (bool, error) {
+	v1 := reflect.ValueOf(arg1)
+	k1, err := basicKind(v1)
+	if err != nil {
+		return false, err
+	}
+	if len(arg2) == 0 {
+		return false, errNoComparison
+	}
+	for _, arg := range arg2 {
+		v2 := reflect.ValueOf(arg)
+		k2, err := basicKind(v2)
+		if err != nil {
+			return false, err
+		}
+		truth := false
+		if k1 != k2 {
+			// Special case: Can compare integer values regardless of type's sign.
+			switch {
+			case k1 == intKind && k2 == uintKind:
+				truth = v1.Int() >= 0 && uint64(v1.Int()) == v2.Uint()
+			case k1 == uintKind && k2 == intKind:
+				truth = v2.Int() >= 0 && v1.Uint() == uint64(v2.Int())
+			default:
+				return false, errBadComparison
+			}
+		} else {
+			switch k1 {
+			case boolKind:
+				truth = v1.Bool() == v2.Bool()
+			case complexKind:
+				truth = v1.Complex() == v2.Complex()
+			case floatKind:
+				truth = v1.Float() == v2.Float()
+			case intKind:
+				truth = v1.Int() == v2.Int()
+			case stringKind:
+				truth = v1.String() == v2.String()
+			case uintKind:
+				truth = v1.Uint() == v2.Uint()
+			default:
+				panic("invalid kind")
+			}
+		}
+		if truth {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// ne evaluates the comparison a != b.
+func ne(arg1, arg2 interface{}) (bool, error) {
+	// != is the inverse of ==.
+	equal, err := eq(arg1, arg2)
+	return !equal, err
+}
+
+// lt evaluates the comparison a < b.
+func lt(arg1, arg2 interface{}) (bool, error) {
+	v1 := reflect.ValueOf(arg1)
+	k1, err := basicKind(v1)
+	if err != nil {
+		return false, err
+	}
+	v2 := reflect.ValueOf(arg2)
+	k2, err := basicKind(v2)
+	if err != nil {
+		return false, err
+	}
+	truth := false
+	if k1 != k2 {
+		// Special case: Can compare integer values regardless of type's sign.
+		switch {
+		case k1 == intKind && k2 == uintKind:
+			truth = v1.Int() < 0 || uint64(v1.Int()) < v2.Uint()
+		case k1 == uintKind && k2 == intKind:
+			truth = v2.Int() >= 0 && v1.Uint() < uint64(v2.Int())
+		default:
+			return false, errBadComparison
+		}
+	} else {
+		switch k1 {
+		case boolKind, complexKind:
+			return false, errBadComparisonType
+		case floatKind:
+			truth = v1.Float() < v2.Float()
+		case intKind:
+			truth = v1.Int() < v2.Int()
+		case stringKind:
+			truth = v1.String() < v2.String()
+		case uintKind:
+			truth = v1.Uint() < v2.Uint()
+		default:
+			panic("invalid kind")
+		}
+	}
+	return truth, nil
+}
+
+// le evaluates the comparison <= b.
+func le(arg1, arg2 interface{}) (bool, error) {
+	// <= is < or ==.
+	lessThan, err := lt(arg1, arg2)
+	if lessThan || err != nil {
+		return lessThan, err
+	}
+	return eq(arg1, arg2)
+}
+
+// gt evaluates the comparison a > b.
+func gt(arg1, arg2 interface{}) (bool, error) {
+	// > is the inverse of <=.
+	lessOrEqual, err := le(arg1, arg2)
+	if err != nil {
+		return false, err
+	}
+	return !lessOrEqual, nil
+}
+
+// ge evaluates the comparison a >= b.
+func ge(arg1, arg2 interface{}) (bool, error) {
+	// >= is the inverse of <.
+	lessThan, err := lt(arg1, arg2)
+	if err != nil {
+		return false, err
+	}
+	return !lessThan, nil
+}
+
+// HTML escaping.
+
+var (
+	htmlQuot = []byte("&#34;") // shorter than "&quot;"
+	htmlApos = []byte("&#39;") // shorter than "&apos;" and apos was not in HTML until HTML5
+	htmlAmp  = []byte("&amp;")
+	htmlLt   = []byte("&lt;")
+	htmlGt   = []byte("&gt;")
+)
+
+// HTMLEscape writes to w the escaped HTML equivalent of the plain text data b.
+func HTMLEscape(w io.Writer, b []byte) {
+	last := 0
+	for i, c := range b {
+		var html []byte
+		switch c {
+		case '"':
+			html = htmlQuot
+		case '\'':
+			html = htmlApos
+		case '&':
+			html = htmlAmp
+		case '<':
+			html = htmlLt
+		case '>':
+			html = htmlGt
+		default:
+			continue
+		}
+		w.Write(b[last:i])
+		w.Write(html)
+		last = i + 1
+	}
+	w.Write(b[last:])
+}
+
+// HTMLEscapeString returns the escaped HTML equivalent of the plain text data s.
+func HTMLEscapeString(s string) string {
+	// Avoid allocation if we can.
+	if strings.IndexAny(s, `'"&<>`) < 0 {
+		return s
+	}
+	var b bytes.Buffer
+	HTMLEscape(&b, []byte(s))
+	return b.String()
+}
+
+// HTMLEscaper returns the escaped HTML equivalent of the textual
+// representation of its arguments.
+func HTMLEscaper(args ...interface{}) string {
+	return HTMLEscapeString(evalArgs(args))
+}
+
+// JavaScript escaping.
+
+var (
+	jsLowUni = []byte(`\u00`)
+	hex      = []byte("0123456789ABCDEF")
+
+	jsBackslash = []byte(`\\`)
+	jsApos      = []byte(`\'`)
+	jsQuot      = []byte(`\"`)
+	jsLt        = []byte(`\x3C`)
+	jsGt        = []byte(`\x3E`)
+)
+
+// JSEscape writes to w the escaped JavaScript equivalent of the plain text data b.
+func JSEscape(w io.Writer, b []byte) {
+	last := 0
+	for i := 0; i < len(b); i++ {
+		c := b[i]
+
+		if !jsIsSpecial(rune(c)) {
+			// fast path: nothing to do
+			continue
+		}
+		w.Write(b[last:i])
+
+		if c < utf8.RuneSelf {
+			// Quotes, slashes and angle brackets get quoted.
+			// Control characters get written as \u00XX.
+			switch c {
+			case '\\':
+				w.Write(jsBackslash)
+			case '\'':
+				w.Write(jsApos)
+			case '"':
+				w.Write(jsQuot)
+			case '<':
+				w.Write(jsLt)
+			case '>':
+				w.Write(jsGt)
+			default:
+				w.Write(jsLowUni)
+				t, b := c>>4, c&0x0f
+				w.Write(hex[t : t+1])
+				w.Write(hex[b : b+1])
+			}
+		} else {
+			// Unicode rune.
+			r, size := utf8.DecodeRune(b[i:])
+			if unicode.IsPrint(r) {
+				w.Write(b[i : i+size])
+			} else {
+				fmt.Fprintf(w, "\\u%04X", r)
+			}
+			i += size - 1
+		}
+		last = i + 1
+	}
+	w.Write(b[last:])
+}
+
+// JSEscapeString returns the escaped JavaScript equivalent of the plain text data s.
+func JSEscapeString(s string) string {
+	// Avoid allocation if we can.
+	if strings.IndexFunc(s, jsIsSpecial) < 0 {
+		return s
+	}
+	var b bytes.Buffer
+	JSEscape(&b, []byte(s))
+	return b.String()
+}
+
+func jsIsSpecial(r rune) bool {
+	switch r {
+	case '\\', '\'', '"', '<', '>':
+		return true
+	}
+	return r < ' ' || utf8.RuneSelf <= r
+}
+
+// JSEscaper returns the escaped JavaScript equivalent of the textual
+// representation of its arguments.
+func JSEscaper(args ...interface{}) string {
+	return JSEscapeString(evalArgs(args))
+}
+
+// URLQueryEscaper returns the escaped value of the textual representation of
+// its arguments in a form suitable for embedding in a URL query.
+func URLQueryEscaper(args ...interface{}) string {
+	return url.QueryEscape(evalArgs(args))
+}
+
+// evalArgs formats the list of arguments into a string. It is therefore equivalent to
+//	fmt.Sprint(args...)
+// except that each argument is indirected (if a pointer), as required,
+// using the same rules as the default string evaluation during template
+// execution.
+func evalArgs(args []interface{}) string {
+	ok := false
+	var s string
+	// Fast path for simple common case.
+	if len(args) == 1 {
+		s, ok = args[0].(string)
+	}
+	if !ok {
+		for i, arg := range args {
+			a, ok := printableValue(reflect.ValueOf(arg))
+			if ok {
+				args[i] = a
+			} // else left fmt do its thing
+		}
+		s = fmt.Sprint(args...)
+	}
+	return s
+}
diff --git a/vendor/github.com/alecthomas/template/helper.go b/vendor/github.com/alecthomas/template/helper.go
new file mode 100644
index 00000000..3636fb54
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/helper.go
@@ -0,0 +1,108 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Helper functions to make constructing templates easier.
+
+package template
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+)
+
+// Functions and methods to parse templates.
+
+// Must is a helper that wraps a call to a function returning (*Template, error)
+// and panics if the error is non-nil. It is intended for use in variable
+// initializations such as
+//	var t = template.Must(template.New("name").Parse("text"))
+func Must(t *Template, err error) *Template {
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// ParseFiles creates a new Template and parses the template definitions from
+// the named files. The returned template's name will have the (base) name and
+// (parsed) contents of the first file. There must be at least one file.
+// If an error occurs, parsing stops and the returned *Template is nil.
+func ParseFiles(filenames ...string) (*Template, error) {
+	return parseFiles(nil, filenames...)
+}
+
+// ParseFiles parses the named files and associates the resulting templates with
+// t. If an error occurs, parsing stops and the returned template is nil;
+// otherwise it is t. There must be at least one file.
+func (t *Template) ParseFiles(filenames ...string) (*Template, error) {
+	return parseFiles(t, filenames...)
+}
+
+// parseFiles is the helper for the method and function. If the argument
+// template is nil, it is created from the first file.
+func parseFiles(t *Template, filenames ...string) (*Template, error) {
+	if len(filenames) == 0 {
+		// Not really a problem, but be consistent.
+		return nil, fmt.Errorf("template: no files named in call to ParseFiles")
+	}
+	for _, filename := range filenames {
+		b, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return nil, err
+		}
+		s := string(b)
+		name := filepath.Base(filename)
+		// First template becomes return value if not already defined,
+		// and we use that one for subsequent New calls to associate
+		// all the templates together. Also, if this file has the same name
+		// as t, this file becomes the contents of t, so
+		//  t, err := New(name).Funcs(xxx).ParseFiles(name)
+		// works. Otherwise we create a new template associated with t.
+		var tmpl *Template
+		if t == nil {
+			t = New(name)
+		}
+		if name == t.Name() {
+			tmpl = t
+		} else {
+			tmpl = t.New(name)
+		}
+		_, err = tmpl.Parse(s)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return t, nil
+}
+
+// ParseGlob creates a new Template and parses the template definitions from the
+// files identified by the pattern, which must match at least one file. The
+// returned template will have the (base) name and (parsed) contents of the
+// first file matched by the pattern. ParseGlob is equivalent to calling
+// ParseFiles with the list of files matched by the pattern.
+func ParseGlob(pattern string) (*Template, error) {
+	return parseGlob(nil, pattern)
+}
+
+// ParseGlob parses the template definitions in the files identified by the
+// pattern and associates the resulting templates with t. The pattern is
+// processed by filepath.Glob and must match at least one file. ParseGlob is
+// equivalent to calling t.ParseFiles with the list of files matched by the
+// pattern.
+func (t *Template) ParseGlob(pattern string) (*Template, error) {
+	return parseGlob(t, pattern)
+}
+
+// parseGlob is the implementation of the function and method ParseGlob.
+func parseGlob(t *Template, pattern string) (*Template, error) {
+	filenames, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, err
+	}
+	if len(filenames) == 0 {
+		return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
+	}
+	return parseFiles(t, filenames...)
+}
diff --git a/vendor/github.com/alecthomas/template/parse/lex.go b/vendor/github.com/alecthomas/template/parse/lex.go
new file mode 100644
index 00000000..55f1c051
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/parse/lex.go
@@ -0,0 +1,556 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package parse
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// item represents a token or text string returned from the scanner.
+type item struct {
+	typ itemType // The type of this item.
+	pos Pos      // The starting position, in bytes, of this item in the input string.
+	val string   // The value of this item.
+}
+
+func (i item) String() string {
+	switch {
+	case i.typ == itemEOF:
+		return "EOF"
+	case i.typ == itemError:
+		return i.val
+	case i.typ > itemKeyword:
+		return fmt.Sprintf("<%s>", i.val)
+	case len(i.val) > 10:
+		return fmt.Sprintf("%.10q...", i.val)
+	}
+	return fmt.Sprintf("%q", i.val)
+}
+
+// itemType identifies the type of lex items.
+type itemType int
+
+const (
+	itemError        itemType = iota // error occurred; value is text of error
+	itemBool                         // boolean constant
+	itemChar                         // printable ASCII character; grab bag for comma etc.
+	itemCharConstant                 // character constant
+	itemComplex                      // complex constant (1+2i); imaginary is just a number
+	itemColonEquals                  // colon-equals (':=') introducing a declaration
+	itemEOF
+	itemField        // alphanumeric identifier starting with '.'
+	itemIdentifier   // alphanumeric identifier not starting with '.'
+	itemLeftDelim    // left action delimiter
+	itemLeftParen    // '(' inside action
+	itemNumber       // simple number, including imaginary
+	itemPipe         // pipe symbol
+	itemRawString    // raw quoted string (includes quotes)
+	itemRightDelim   // right action delimiter
+	itemElideNewline // elide newline after right delim
+	itemRightParen   // ')' inside action
+	itemSpace        // run of spaces separating arguments
+	itemString       // quoted string (includes quotes)
+	itemText         // plain text
+	itemVariable     // variable starting with '$', such as '$' or  '$1' or '$hello'
+	// Keywords appear after all the rest.
+	itemKeyword  // used only to delimit the keywords
+	itemDot      // the cursor, spelled '.'
+	itemDefine   // define keyword
+	itemElse     // else keyword
+	itemEnd      // end keyword
+	itemIf       // if keyword
+	itemNil      // the untyped nil constant, easiest to treat as a keyword
+	itemRange    // range keyword
+	itemTemplate // template keyword
+	itemWith     // with keyword
+)
+
+var key = map[string]itemType{
+	".":        itemDot,
+	"define":   itemDefine,
+	"else":     itemElse,
+	"end":      itemEnd,
+	"if":       itemIf,
+	"range":    itemRange,
+	"nil":      itemNil,
+	"template": itemTemplate,
+	"with":     itemWith,
+}
+
+const eof = -1
+
+// stateFn represents the state of the scanner as a function that returns the next state.
+type stateFn func(*lexer) stateFn
+
+// lexer holds the state of the scanner.
+type lexer struct {
+	name       string    // the name of the input; used only for error reports
+	input      string    // the string being scanned
+	leftDelim  string    // start of action
+	rightDelim string    // end of action
+	state      stateFn   // the next lexing function to enter
+	pos        Pos       // current position in the input
+	start      Pos       // start position of this item
+	width      Pos       // width of last rune read from input
+	lastPos    Pos       // position of most recent item returned by nextItem
+	items      chan item // channel of scanned items
+	parenDepth int       // nesting depth of ( ) exprs
+}
+
+// next returns the next rune in the input.
+func (l *lexer) next() rune {
+	if int(l.pos) >= len(l.input) {
+		l.width = 0
+		return eof
+	}
+	r, w := utf8.DecodeRuneInString(l.input[l.pos:])
+	l.width = Pos(w)
+	l.pos += l.width
+	return r
+}
+
+// peek returns but does not consume the next rune in the input.
+func (l *lexer) peek() rune {
+	r := l.next()
+	l.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per call of next.
+func (l *lexer) backup() {
+	l.pos -= l.width
+}
+
+// emit passes an item back to the client.
+func (l *lexer) emit(t itemType) {
+	l.items <- item{t, l.start, l.input[l.start:l.pos]}
+	l.start = l.pos
+}
+
+// ignore skips over the pending input before this point.
+func (l *lexer) ignore() {
+	l.start = l.pos
+}
+
+// accept consumes the next rune if it's from the valid set.
+func (l *lexer) accept(valid string) bool {
+	if strings.IndexRune(valid, l.next()) >= 0 {
+		return true
+	}
+	l.backup()
+	return false
+}
+
+// acceptRun consumes a run of runes from the valid set.
+func (l *lexer) acceptRun(valid string) {
+	for strings.IndexRune(valid, l.next()) >= 0 {
+	}
+	l.backup()
+}
+
+// lineNumber reports which line we're on, based on the position of
+// the previous item returned by nextItem. Doing it this way
+// means we don't have to worry about peek double counting.
+func (l *lexer) lineNumber() int {
+	return 1 + strings.Count(l.input[:l.lastPos], "\n")
+}
+
+// errorf returns an error token and terminates the scan by passing
+// back a nil pointer that will be the next state, terminating l.nextItem.
+func (l *lexer) errorf(format string, args ...interface{}) stateFn {
+	l.items <- item{itemError, l.start, fmt.Sprintf(format, args...)}
+	return nil
+}
+
+// nextItem returns the next item from the input.
+func (l *lexer) nextItem() item {
+	item := <-l.items
+	l.lastPos = item.pos
+	return item
+}
+
+// lex creates a new scanner for the input string.
+func lex(name, input, left, right string) *lexer {
+	if left == "" {
+		left = leftDelim
+	}
+	if right == "" {
+		right = rightDelim
+	}
+	l := &lexer{
+		name:       name,
+		input:      input,
+		leftDelim:  left,
+		rightDelim: right,
+		items:      make(chan item),
+	}
+	go l.run()
+	return l
+}
+
+// run runs the state machine for the lexer.
+func (l *lexer) run() {
+	for l.state = lexText; l.state != nil; {
+		l.state = l.state(l)
+	}
+}
+
+// state functions
+
+const (
+	leftDelim    = "{{"
+	rightDelim   = "}}"
+	leftComment  = "/*"
+	rightComment = "*/"
+)
+
+// lexText scans until an opening action delimiter, "{{".
+func lexText(l *lexer) stateFn {
+	for {
+		if strings.HasPrefix(l.input[l.pos:], l.leftDelim) {
+			if l.pos > l.start {
+				l.emit(itemText)
+			}
+			return lexLeftDelim
+		}
+		if l.next() == eof {
+			break
+		}
+	}
+	// Correctly reached EOF.
+	if l.pos > l.start {
+		l.emit(itemText)
+	}
+	l.emit(itemEOF)
+	return nil
+}
+
+// lexLeftDelim scans the left delimiter, which is known to be present.
+func lexLeftDelim(l *lexer) stateFn {
+	l.pos += Pos(len(l.leftDelim))
+	if strings.HasPrefix(l.input[l.pos:], leftComment) {
+		return lexComment
+	}
+	l.emit(itemLeftDelim)
+	l.parenDepth = 0
+	return lexInsideAction
+}
+
+// lexComment scans a comment. The left comment marker is known to be present.
+func lexComment(l *lexer) stateFn {
+	l.pos += Pos(len(leftComment))
+	i := strings.Index(l.input[l.pos:], rightComment)
+	if i < 0 {
+		return l.errorf("unclosed comment")
+	}
+	l.pos += Pos(i + len(rightComment))
+	if !strings.HasPrefix(l.input[l.pos:], l.rightDelim) {
+		return l.errorf("comment ends before closing delimiter")
+
+	}
+	l.pos += Pos(len(l.rightDelim))
+	l.ignore()
+	return lexText
+}
+
+// lexRightDelim scans the right delimiter, which is known to be present.
+func lexRightDelim(l *lexer) stateFn {
+	l.pos += Pos(len(l.rightDelim))
+	l.emit(itemRightDelim)
+	if l.peek() == '\\' {
+		l.pos++
+		l.emit(itemElideNewline)
+	}
+	return lexText
+}
+
+// lexInsideAction scans the elements inside action delimiters.
+func lexInsideAction(l *lexer) stateFn {
+	// Either number, quoted string, or identifier.
+	// Spaces separate arguments; runs of spaces turn into itemSpace.
+	// Pipe symbols separate and are emitted.
+	if strings.HasPrefix(l.input[l.pos:], l.rightDelim+"\\") || strings.HasPrefix(l.input[l.pos:], l.rightDelim) {
+		if l.parenDepth == 0 {
+			return lexRightDelim
+		}
+		return l.errorf("unclosed left paren")
+	}
+	switch r := l.next(); {
+	case r == eof || isEndOfLine(r):
+		return l.errorf("unclosed action")
+	case isSpace(r):
+		return lexSpace
+	case r == ':':
+		if l.next() != '=' {
+			return l.errorf("expected :=")
+		}
+		l.emit(itemColonEquals)
+	case r == '|':
+		l.emit(itemPipe)
+	case r == '"':
+		return lexQuote
+	case r == '`':
+		return lexRawQuote
+	case r == '$':
+		return lexVariable
+	case r == '\'':
+		return lexChar
+	case r == '.':
+		// special look-ahead for ".field" so we don't break l.backup().
+		if l.pos < Pos(len(l.input)) {
+			r := l.input[l.pos]
+			if r < '0' || '9' < r {
+				return lexField
+			}
+		}
+		fallthrough // '.' can start a number.
+	case r == '+' || r == '-' || ('0' <= r && r <= '9'):
+		l.backup()
+		return lexNumber
+	case isAlphaNumeric(r):
+		l.backup()
+		return lexIdentifier
+	case r == '(':
+		l.emit(itemLeftParen)
+		l.parenDepth++
+		return lexInsideAction
+	case r == ')':
+		l.emit(itemRightParen)
+		l.parenDepth--
+		if l.parenDepth < 0 {
+			return l.errorf("unexpected right paren %#U", r)
+		}
+		return lexInsideAction
+	case r <= unicode.MaxASCII && unicode.IsPrint(r):
+		l.emit(itemChar)
+		return lexInsideAction
+	default:
+		return l.errorf("unrecognized character in action: %#U", r)
+	}
+	return lexInsideAction
+}
+
+// lexSpace scans a run of space characters.
+// One space has already been seen.
+func lexSpace(l *lexer) stateFn {
+	for isSpace(l.peek()) {
+		l.next()
+	}
+	l.emit(itemSpace)
+	return lexInsideAction
+}
+
+// lexIdentifier scans an alphanumeric.
+func lexIdentifier(l *lexer) stateFn {
+Loop:
+	for {
+		switch r := l.next(); {
+		case isAlphaNumeric(r):
+			// absorb.
+		default:
+			l.backup()
+			word := l.input[l.start:l.pos]
+			if !l.atTerminator() {
+				return l.errorf("bad character %#U", r)
+			}
+			switch {
+			case key[word] > itemKeyword:
+				l.emit(key[word])
+			case word[0] == '.':
+				l.emit(itemField)
+			case word == "true", word == "false":
+				l.emit(itemBool)
+			default:
+				l.emit(itemIdentifier)
+			}
+			break Loop
+		}
+	}
+	return lexInsideAction
+}
+
+// lexField scans a field: .Alphanumeric.
+// The . has been scanned.
+func lexField(l *lexer) stateFn {
+	return lexFieldOrVariable(l, itemField)
+}
+
+// lexVariable scans a Variable: $Alphanumeric.
+// The $ has been scanned.
+func lexVariable(l *lexer) stateFn {
+	if l.atTerminator() { // Nothing interesting follows -> "$".
+		l.emit(itemVariable)
+		return lexInsideAction
+	}
+	return lexFieldOrVariable(l, itemVariable)
+}
+
+// lexVariable scans a field or variable: [.$]Alphanumeric.
+// The . or $ has been scanned.
+func lexFieldOrVariable(l *lexer, typ itemType) stateFn {
+	if l.atTerminator() { // Nothing interesting follows -> "." or "$".
+		if typ == itemVariable {
+			l.emit(itemVariable)
+		} else {
+			l.emit(itemDot)
+		}
+		return lexInsideAction
+	}
+	var r rune
+	for {
+		r = l.next()
+		if !isAlphaNumeric(r) {
+			l.backup()
+			break
+		}
+	}
+	if !l.atTerminator() {
+		return l.errorf("bad character %#U", r)
+	}
+	l.emit(typ)
+	return lexInsideAction
+}
+
+// atTerminator reports whether the input is at valid termination character to
+// appear after an identifier. Breaks .X.Y into two pieces. Also catches cases
+// like "$x+2" not being acceptable without a space, in case we decide one
+// day to implement arithmetic.
+func (l *lexer) atTerminator() bool {
+	r := l.peek()
+	if isSpace(r) || isEndOfLine(r) {
+		return true
+	}
+	switch r {
+	case eof, '.', ',', '|', ':', ')', '(':
+		return true
+	}
+	// Does r start the delimiter? This can be ambiguous (with delim=="//", $x/2 will
+	// succeed but should fail) but only in extremely rare cases caused by willfully
+	// bad choice of delimiter.
+	if rd, _ := utf8.DecodeRuneInString(l.rightDelim); rd == r {
+		return true
+	}
+	return false
+}
+
+// lexChar scans a character constant. The initial quote is already
+// scanned. Syntax checking is done by the parser.
+func lexChar(l *lexer) stateFn {
+Loop:
+	for {
+		switch l.next() {
+		case '\\':
+			if r := l.next(); r != eof && r != '\n' {
+				break
+			}
+			fallthrough
+		case eof, '\n':
+			return l.errorf("unterminated character constant")
+		case '\'':
+			break Loop
+		}
+	}
+	l.emit(itemCharConstant)
+	return lexInsideAction
+}
+
+// lexNumber scans a number: decimal, octal, hex, float, or imaginary. This
+// isn't a perfect number scanner - for instance it accepts "." and "0x0.2"
+// and "089" - but when it's wrong the input is invalid and the parser (via
+// strconv) will notice.
+func lexNumber(l *lexer) stateFn {
+	if !l.scanNumber() {
+		return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
+	}
+	if sign := l.peek(); sign == '+' || sign == '-' {
+		// Complex: 1+2i. No spaces, must end in 'i'.
+		if !l.scanNumber() || l.input[l.pos-1] != 'i' {
+			return l.errorf("bad number syntax: %q", l.input[l.start:l.pos])
+		}
+		l.emit(itemComplex)
+	} else {
+		l.emit(itemNumber)
+	}
+	return lexInsideAction
+}
+
+func (l *lexer) scanNumber() bool {
+	// Optional leading sign.
+	l.accept("+-")
+	// Is it hex?
+	digits := "0123456789"
+	if l.accept("0") && l.accept("xX") {
+		digits = "0123456789abcdefABCDEF"
+	}
+	l.acceptRun(digits)
+	if l.accept(".") {
+		l.acceptRun(digits)
+	}
+	if l.accept("eE") {
+		l.accept("+-")
+		l.acceptRun("0123456789")
+	}
+	// Is it imaginary?
+	l.accept("i")
+	// Next thing mustn't be alphanumeric.
+	if isAlphaNumeric(l.peek()) {
+		l.next()
+		return false
+	}
+	return true
+}
+
+// lexQuote scans a quoted string.
+func lexQuote(l *lexer) stateFn {
+Loop:
+	for {
+		switch l.next() {
+		case '\\':
+			if r := l.next(); r != eof && r != '\n' {
+				break
+			}
+			fallthrough
+		case eof, '\n':
+			return l.errorf("unterminated quoted string")
+		case '"':
+			break Loop
+		}
+	}
+	l.emit(itemString)
+	return lexInsideAction
+}
+
+// lexRawQuote scans a raw quoted string.
+func lexRawQuote(l *lexer) stateFn {
+Loop:
+	for {
+		switch l.next() {
+		case eof, '\n':
+			return l.errorf("unterminated raw quoted string")
+		case '`':
+			break Loop
+		}
+	}
+	l.emit(itemRawString)
+	return lexInsideAction
+}
+
+// isSpace reports whether r is a space character.
+func isSpace(r rune) bool {
+	return r == ' ' || r == '\t'
+}
+
+// isEndOfLine reports whether r is an end-of-line character.
+func isEndOfLine(r rune) bool {
+	return r == '\r' || r == '\n'
+}
+
+// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
+func isAlphaNumeric(r rune) bool {
+	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
diff --git a/vendor/github.com/alecthomas/template/parse/node.go b/vendor/github.com/alecthomas/template/parse/node.go
new file mode 100644
index 00000000..55c37f6d
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/parse/node.go
@@ -0,0 +1,834 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Parse nodes.
+
+package parse
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+var textFormat = "%s" // Changed to "%q" in tests for better error messages.
+
+// A Node is an element in the parse tree. The interface is trivial.
+// The interface contains an unexported method so that only
+// types local to this package can satisfy it.
+type Node interface {
+	Type() NodeType
+	String() string
+	// Copy does a deep copy of the Node and all its components.
+	// To avoid type assertions, some XxxNodes also have specialized
+	// CopyXxx methods that return *XxxNode.
+	Copy() Node
+	Position() Pos // byte position of start of node in full original input string
+	// tree returns the containing *Tree.
+	// It is unexported so all implementations of Node are in this package.
+	tree() *Tree
+}
+
+// NodeType identifies the type of a parse tree node.
+type NodeType int
+
+// Pos represents a byte position in the original input text from which
+// this template was parsed.
+type Pos int
+
+func (p Pos) Position() Pos {
+	return p
+}
+
+// Type returns itself and provides an easy default implementation
+// for embedding in a Node. Embedded in all non-trivial Nodes.
+func (t NodeType) Type() NodeType {
+	return t
+}
+
+const (
+	NodeText       NodeType = iota // Plain text.
+	NodeAction                     // A non-control action such as a field evaluation.
+	NodeBool                       // A boolean constant.
+	NodeChain                      // A sequence of field accesses.
+	NodeCommand                    // An element of a pipeline.
+	NodeDot                        // The cursor, dot.
+	nodeElse                       // An else action. Not added to tree.
+	nodeEnd                        // An end action. Not added to tree.
+	NodeField                      // A field or method name.
+	NodeIdentifier                 // An identifier; always a function name.
+	NodeIf                         // An if action.
+	NodeList                       // A list of Nodes.
+	NodeNil                        // An untyped nil constant.
+	NodeNumber                     // A numerical constant.
+	NodePipe                       // A pipeline of commands.
+	NodeRange                      // A range action.
+	NodeString                     // A string constant.
+	NodeTemplate                   // A template invocation action.
+	NodeVariable                   // A $ variable.
+	NodeWith                       // A with action.
+)
+
+// Nodes.
+
+// ListNode holds a sequence of nodes.
+type ListNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Nodes []Node // The element nodes in lexical order.
+}
+
+func (t *Tree) newList(pos Pos) *ListNode {
+	return &ListNode{tr: t, NodeType: NodeList, Pos: pos}
+}
+
+func (l *ListNode) append(n Node) {
+	l.Nodes = append(l.Nodes, n)
+}
+
+func (l *ListNode) tree() *Tree {
+	return l.tr
+}
+
+func (l *ListNode) String() string {
+	b := new(bytes.Buffer)
+	for _, n := range l.Nodes {
+		fmt.Fprint(b, n)
+	}
+	return b.String()
+}
+
+func (l *ListNode) CopyList() *ListNode {
+	if l == nil {
+		return l
+	}
+	n := l.tr.newList(l.Pos)
+	for _, elem := range l.Nodes {
+		n.append(elem.Copy())
+	}
+	return n
+}
+
+func (l *ListNode) Copy() Node {
+	return l.CopyList()
+}
+
+// TextNode holds plain text.
+type TextNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Text []byte // The text; may span newlines.
+}
+
+func (t *Tree) newText(pos Pos, text string) *TextNode {
+	return &TextNode{tr: t, NodeType: NodeText, Pos: pos, Text: []byte(text)}
+}
+
+func (t *TextNode) String() string {
+	return fmt.Sprintf(textFormat, t.Text)
+}
+
+func (t *TextNode) tree() *Tree {
+	return t.tr
+}
+
+func (t *TextNode) Copy() Node {
+	return &TextNode{tr: t.tr, NodeType: NodeText, Pos: t.Pos, Text: append([]byte{}, t.Text...)}
+}
+
+// PipeNode holds a pipeline with optional declaration
+type PipeNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int             // The line number in the input (deprecated; kept for compatibility)
+	Decl []*VariableNode // Variable declarations in lexical order.
+	Cmds []*CommandNode  // The commands in lexical order.
+}
+
+func (t *Tree) newPipeline(pos Pos, line int, decl []*VariableNode) *PipeNode {
+	return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Decl: decl}
+}
+
+func (p *PipeNode) append(command *CommandNode) {
+	p.Cmds = append(p.Cmds, command)
+}
+
+func (p *PipeNode) String() string {
+	s := ""
+	if len(p.Decl) > 0 {
+		for i, v := range p.Decl {
+			if i > 0 {
+				s += ", "
+			}
+			s += v.String()
+		}
+		s += " := "
+	}
+	for i, c := range p.Cmds {
+		if i > 0 {
+			s += " | "
+		}
+		s += c.String()
+	}
+	return s
+}
+
+func (p *PipeNode) tree() *Tree {
+	return p.tr
+}
+
+func (p *PipeNode) CopyPipe() *PipeNode {
+	if p == nil {
+		return p
+	}
+	var decl []*VariableNode
+	for _, d := range p.Decl {
+		decl = append(decl, d.Copy().(*VariableNode))
+	}
+	n := p.tr.newPipeline(p.Pos, p.Line, decl)
+	for _, c := range p.Cmds {
+		n.append(c.Copy().(*CommandNode))
+	}
+	return n
+}
+
+func (p *PipeNode) Copy() Node {
+	return p.CopyPipe()
+}
+
+// ActionNode holds an action (something bounded by delimiters).
+// Control actions have their own nodes; ActionNode represents simple
+// ones such as field evaluations and parenthesized pipelines.
+type ActionNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int       // The line number in the input (deprecated; kept for compatibility)
+	Pipe *PipeNode // The pipeline in the action.
+}
+
+func (t *Tree) newAction(pos Pos, line int, pipe *PipeNode) *ActionNode {
+	return &ActionNode{tr: t, NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
+}
+
+func (a *ActionNode) String() string {
+	return fmt.Sprintf("{{%s}}", a.Pipe)
+
+}
+
+func (a *ActionNode) tree() *Tree {
+	return a.tr
+}
+
+func (a *ActionNode) Copy() Node {
+	return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
+
+}
+
+// CommandNode holds a command (a pipeline inside an evaluating action).
+type CommandNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Args []Node // Arguments in lexical order: Identifier, field, or constant.
+}
+
+func (t *Tree) newCommand(pos Pos) *CommandNode {
+	return &CommandNode{tr: t, NodeType: NodeCommand, Pos: pos}
+}
+
+func (c *CommandNode) append(arg Node) {
+	c.Args = append(c.Args, arg)
+}
+
+func (c *CommandNode) String() string {
+	s := ""
+	for i, arg := range c.Args {
+		if i > 0 {
+			s += " "
+		}
+		if arg, ok := arg.(*PipeNode); ok {
+			s += "(" + arg.String() + ")"
+			continue
+		}
+		s += arg.String()
+	}
+	return s
+}
+
+func (c *CommandNode) tree() *Tree {
+	return c.tr
+}
+
+func (c *CommandNode) Copy() Node {
+	if c == nil {
+		return c
+	}
+	n := c.tr.newCommand(c.Pos)
+	for _, c := range c.Args {
+		n.append(c.Copy())
+	}
+	return n
+}
+
+// IdentifierNode holds an identifier.
+type IdentifierNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Ident string // The identifier's name.
+}
+
+// NewIdentifier returns a new IdentifierNode with the given identifier name.
+func NewIdentifier(ident string) *IdentifierNode {
+	return &IdentifierNode{NodeType: NodeIdentifier, Ident: ident}
+}
+
+// SetPos sets the position. NewIdentifier is a public method so we can't modify its signature.
+// Chained for convenience.
+// TODO: fix one day?
+func (i *IdentifierNode) SetPos(pos Pos) *IdentifierNode {
+	i.Pos = pos
+	return i
+}
+
+// SetTree sets the parent tree for the node. NewIdentifier is a public method so we can't modify its signature.
+// Chained for convenience.
+// TODO: fix one day?
+func (i *IdentifierNode) SetTree(t *Tree) *IdentifierNode {
+	i.tr = t
+	return i
+}
+
+func (i *IdentifierNode) String() string {
+	return i.Ident
+}
+
+func (i *IdentifierNode) tree() *Tree {
+	return i.tr
+}
+
+func (i *IdentifierNode) Copy() Node {
+	return NewIdentifier(i.Ident).SetTree(i.tr).SetPos(i.Pos)
+}
+
+// VariableNode holds a list of variable names, possibly with chained field
+// accesses. The dollar sign is part of the (first) name.
+type VariableNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Ident []string // Variable name and fields in lexical order.
+}
+
+func (t *Tree) newVariable(pos Pos, ident string) *VariableNode {
+	return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
+}
+
+func (v *VariableNode) String() string {
+	s := ""
+	for i, id := range v.Ident {
+		if i > 0 {
+			s += "."
+		}
+		s += id
+	}
+	return s
+}
+
+func (v *VariableNode) tree() *Tree {
+	return v.tr
+}
+
+func (v *VariableNode) Copy() Node {
+	return &VariableNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
+}
+
+// DotNode holds the special identifier '.'.
+type DotNode struct {
+	NodeType
+	Pos
+	tr *Tree
+}
+
+func (t *Tree) newDot(pos Pos) *DotNode {
+	return &DotNode{tr: t, NodeType: NodeDot, Pos: pos}
+}
+
+func (d *DotNode) Type() NodeType {
+	// Override method on embedded NodeType for API compatibility.
+	// TODO: Not really a problem; could change API without effect but
+	// api tool complains.
+	return NodeDot
+}
+
+func (d *DotNode) String() string {
+	return "."
+}
+
+func (d *DotNode) tree() *Tree {
+	return d.tr
+}
+
+func (d *DotNode) Copy() Node {
+	return d.tr.newDot(d.Pos)
+}
+
+// NilNode holds the special identifier 'nil' representing an untyped nil constant.
+type NilNode struct {
+	NodeType
+	Pos
+	tr *Tree
+}
+
+func (t *Tree) newNil(pos Pos) *NilNode {
+	return &NilNode{tr: t, NodeType: NodeNil, Pos: pos}
+}
+
+func (n *NilNode) Type() NodeType {
+	// Override method on embedded NodeType for API compatibility.
+	// TODO: Not really a problem; could change API without effect but
+	// api tool complains.
+	return NodeNil
+}
+
+func (n *NilNode) String() string {
+	return "nil"
+}
+
+func (n *NilNode) tree() *Tree {
+	return n.tr
+}
+
+func (n *NilNode) Copy() Node {
+	return n.tr.newNil(n.Pos)
+}
+
+// FieldNode holds a field (identifier starting with '.').
+// The names may be chained ('.x.y').
+// The period is dropped from each ident.
+type FieldNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Ident []string // The identifiers in lexical order.
+}
+
+func (t *Tree) newField(pos Pos, ident string) *FieldNode {
+	return &FieldNode{tr: t, NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
+}
+
+func (f *FieldNode) String() string {
+	s := ""
+	for _, id := range f.Ident {
+		s += "." + id
+	}
+	return s
+}
+
+func (f *FieldNode) tree() *Tree {
+	return f.tr
+}
+
+func (f *FieldNode) Copy() Node {
+	return &FieldNode{tr: f.tr, NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
+}
+
+// ChainNode holds a term followed by a chain of field accesses (identifier starting with '.').
+// The names may be chained ('.x.y').
+// The periods are dropped from each ident.
+type ChainNode struct {
+	NodeType
+	Pos
+	tr    *Tree
+	Node  Node
+	Field []string // The identifiers in lexical order.
+}
+
+func (t *Tree) newChain(pos Pos, node Node) *ChainNode {
+	return &ChainNode{tr: t, NodeType: NodeChain, Pos: pos, Node: node}
+}
+
+// Add adds the named field (which should start with a period) to the end of the chain.
+func (c *ChainNode) Add(field string) {
+	if len(field) == 0 || field[0] != '.' {
+		panic("no dot in field")
+	}
+	field = field[1:] // Remove leading dot.
+	if field == "" {
+		panic("empty field")
+	}
+	c.Field = append(c.Field, field)
+}
+
+func (c *ChainNode) String() string {
+	s := c.Node.String()
+	if _, ok := c.Node.(*PipeNode); ok {
+		s = "(" + s + ")"
+	}
+	for _, field := range c.Field {
+		s += "." + field
+	}
+	return s
+}
+
+func (c *ChainNode) tree() *Tree {
+	return c.tr
+}
+
+func (c *ChainNode) Copy() Node {
+	return &ChainNode{tr: c.tr, NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
+}
+
+// BoolNode holds a boolean constant.
+type BoolNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	True bool // The value of the boolean constant.
+}
+
+func (t *Tree) newBool(pos Pos, true bool) *BoolNode {
+	return &BoolNode{tr: t, NodeType: NodeBool, Pos: pos, True: true}
+}
+
+func (b *BoolNode) String() string {
+	if b.True {
+		return "true"
+	}
+	return "false"
+}
+
+func (b *BoolNode) tree() *Tree {
+	return b.tr
+}
+
+func (b *BoolNode) Copy() Node {
+	return b.tr.newBool(b.Pos, b.True)
+}
+
+// NumberNode holds a number: signed or unsigned integer, float, or complex.
+// The value is parsed and stored under all the types that can represent the value.
+// This simulates in a small amount of code the behavior of Go's ideal constants.
+type NumberNode struct {
+	NodeType
+	Pos
+	tr         *Tree
+	IsInt      bool       // Number has an integral value.
+	IsUint     bool       // Number has an unsigned integral value.
+	IsFloat    bool       // Number has a floating-point value.
+	IsComplex  bool       // Number is complex.
+	Int64      int64      // The signed integer value.
+	Uint64     uint64     // The unsigned integer value.
+	Float64    float64    // The floating-point value.
+	Complex128 complex128 // The complex value.
+	Text       string     // The original textual representation from the input.
+}
+
+func (t *Tree) newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
+	n := &NumberNode{tr: t, NodeType: NodeNumber, Pos: pos, Text: text}
+	switch typ {
+	case itemCharConstant:
+		rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0])
+		if err != nil {
+			return nil, err
+		}
+		if tail != "'" {
+			return nil, fmt.Errorf("malformed character constant: %s", text)
+		}
+		n.Int64 = int64(rune)
+		n.IsInt = true
+		n.Uint64 = uint64(rune)
+		n.IsUint = true
+		n.Float64 = float64(rune) // odd but those are the rules.
+		n.IsFloat = true
+		return n, nil
+	case itemComplex:
+		// fmt.Sscan can parse the pair, so let it do the work.
+		if _, err := fmt.Sscan(text, &n.Complex128); err != nil {
+			return nil, err
+		}
+		n.IsComplex = true
+		n.simplifyComplex()
+		return n, nil
+	}
+	// Imaginary constants can only be complex unless they are zero.
+	if len(text) > 0 && text[len(text)-1] == 'i' {
+		f, err := strconv.ParseFloat(text[:len(text)-1], 64)
+		if err == nil {
+			n.IsComplex = true
+			n.Complex128 = complex(0, f)
+			n.simplifyComplex()
+			return n, nil
+		}
+	}
+	// Do integer test first so we get 0x123 etc.
+	u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.
+	if err == nil {
+		n.IsUint = true
+		n.Uint64 = u
+	}
+	i, err := strconv.ParseInt(text, 0, 64)
+	if err == nil {
+		n.IsInt = true
+		n.Int64 = i
+		if i == 0 {
+			n.IsUint = true // in case of -0.
+			n.Uint64 = u
+		}
+	}
+	// If an integer extraction succeeded, promote the float.
+	if n.IsInt {
+		n.IsFloat = true
+		n.Float64 = float64(n.Int64)
+	} else if n.IsUint {
+		n.IsFloat = true
+		n.Float64 = float64(n.Uint64)
+	} else {
+		f, err := strconv.ParseFloat(text, 64)
+		if err == nil {
+			n.IsFloat = true
+			n.Float64 = f
+			// If a floating-point extraction succeeded, extract the int if needed.
+			if !n.IsInt && float64(int64(f)) == f {
+				n.IsInt = true
+				n.Int64 = int64(f)
+			}
+			if !n.IsUint && float64(uint64(f)) == f {
+				n.IsUint = true
+				n.Uint64 = uint64(f)
+			}
+		}
+	}
+	if !n.IsInt && !n.IsUint && !n.IsFloat {
+		return nil, fmt.Errorf("illegal number syntax: %q", text)
+	}
+	return n, nil
+}
+
+// simplifyComplex pulls out any other types that are represented by the complex number.
+// These all require that the imaginary part be zero.
+func (n *NumberNode) simplifyComplex() {
+	n.IsFloat = imag(n.Complex128) == 0
+	if n.IsFloat {
+		n.Float64 = real(n.Complex128)
+		n.IsInt = float64(int64(n.Float64)) == n.Float64
+		if n.IsInt {
+			n.Int64 = int64(n.Float64)
+		}
+		n.IsUint = float64(uint64(n.Float64)) == n.Float64
+		if n.IsUint {
+			n.Uint64 = uint64(n.Float64)
+		}
+	}
+}
+
+func (n *NumberNode) String() string {
+	return n.Text
+}
+
+func (n *NumberNode) tree() *Tree {
+	return n.tr
+}
+
+func (n *NumberNode) Copy() Node {
+	nn := new(NumberNode)
+	*nn = *n // Easy, fast, correct.
+	return nn
+}
+
+// StringNode holds a string constant. The value has been "unquoted".
+type StringNode struct {
+	NodeType
+	Pos
+	tr     *Tree
+	Quoted string // The original text of the string, with quotes.
+	Text   string // The string, after quote processing.
+}
+
+func (t *Tree) newString(pos Pos, orig, text string) *StringNode {
+	return &StringNode{tr: t, NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
+}
+
+func (s *StringNode) String() string {
+	return s.Quoted
+}
+
+func (s *StringNode) tree() *Tree {
+	return s.tr
+}
+
+func (s *StringNode) Copy() Node {
+	return s.tr.newString(s.Pos, s.Quoted, s.Text)
+}
+
+// endNode represents an {{end}} action.
+// It does not appear in the final parse tree.
+type endNode struct {
+	NodeType
+	Pos
+	tr *Tree
+}
+
+func (t *Tree) newEnd(pos Pos) *endNode {
+	return &endNode{tr: t, NodeType: nodeEnd, Pos: pos}
+}
+
+func (e *endNode) String() string {
+	return "{{end}}"
+}
+
+func (e *endNode) tree() *Tree {
+	return e.tr
+}
+
+func (e *endNode) Copy() Node {
+	return e.tr.newEnd(e.Pos)
+}
+
+// elseNode represents an {{else}} action. Does not appear in the final tree.
+type elseNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int // The line number in the input (deprecated; kept for compatibility)
+}
+
+func (t *Tree) newElse(pos Pos, line int) *elseNode {
+	return &elseNode{tr: t, NodeType: nodeElse, Pos: pos, Line: line}
+}
+
+func (e *elseNode) Type() NodeType {
+	return nodeElse
+}
+
+func (e *elseNode) String() string {
+	return "{{else}}"
+}
+
+func (e *elseNode) tree() *Tree {
+	return e.tr
+}
+
+func (e *elseNode) Copy() Node {
+	return e.tr.newElse(e.Pos, e.Line)
+}
+
+// BranchNode is the common representation of if, range, and with.
+type BranchNode struct {
+	NodeType
+	Pos
+	tr       *Tree
+	Line     int       // The line number in the input (deprecated; kept for compatibility)
+	Pipe     *PipeNode // The pipeline to be evaluated.
+	List     *ListNode // What to execute if the value is non-empty.
+	ElseList *ListNode // What to execute if the value is empty (nil if absent).
+}
+
+func (b *BranchNode) String() string {
+	name := ""
+	switch b.NodeType {
+	case NodeIf:
+		name = "if"
+	case NodeRange:
+		name = "range"
+	case NodeWith:
+		name = "with"
+	default:
+		panic("unknown branch type")
+	}
+	if b.ElseList != nil {
+		return fmt.Sprintf("{{%s %s}}%s{{else}}%s{{end}}", name, b.Pipe, b.List, b.ElseList)
+	}
+	return fmt.Sprintf("{{%s %s}}%s{{end}}", name, b.Pipe, b.List)
+}
+
+func (b *BranchNode) tree() *Tree {
+	return b.tr
+}
+
+func (b *BranchNode) Copy() Node {
+	switch b.NodeType {
+	case NodeIf:
+		return b.tr.newIf(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	case NodeRange:
+		return b.tr.newRange(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	case NodeWith:
+		return b.tr.newWith(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	default:
+		panic("unknown branch type")
+	}
+}
+
+// IfNode represents an {{if}} action and its commands.
+type IfNode struct {
+	BranchNode
+}
+
+func (t *Tree) newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode {
+	return &IfNode{BranchNode{tr: t, NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+}
+
+func (i *IfNode) Copy() Node {
+	return i.tr.newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
+}
+
+// RangeNode represents a {{range}} action and its commands.
+type RangeNode struct {
+	BranchNode
+}
+
+func (t *Tree) newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode {
+	return &RangeNode{BranchNode{tr: t, NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+}
+
+func (r *RangeNode) Copy() Node {
+	return r.tr.newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
+}
+
+// WithNode represents a {{with}} action and its commands.
+type WithNode struct {
+	BranchNode
+}
+
+func (t *Tree) newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
+	return &WithNode{BranchNode{tr: t, NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+}
+
+func (w *WithNode) Copy() Node {
+	return w.tr.newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
+}
+
+// TemplateNode represents a {{template}} action.
+type TemplateNode struct {
+	NodeType
+	Pos
+	tr   *Tree
+	Line int       // The line number in the input (deprecated; kept for compatibility)
+	Name string    // The name of the template (unquoted).
+	Pipe *PipeNode // The command to evaluate as dot for the template.
+}
+
+func (t *Tree) newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode {
+	return &TemplateNode{tr: t, NodeType: NodeTemplate, Pos: pos, Line: line, Name: name, Pipe: pipe}
+}
+
+func (t *TemplateNode) String() string {
+	if t.Pipe == nil {
+		return fmt.Sprintf("{{template %q}}", t.Name)
+	}
+	return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
+}
+
+func (t *TemplateNode) tree() *Tree {
+	return t.tr
+}
+
+func (t *TemplateNode) Copy() Node {
+	return t.tr.newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
+}
diff --git a/vendor/github.com/alecthomas/template/parse/parse.go b/vendor/github.com/alecthomas/template/parse/parse.go
new file mode 100644
index 00000000..0d77ade8
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/parse/parse.go
@@ -0,0 +1,700 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package parse builds parse trees for templates as defined by text/template
+// and html/template. Clients should use those packages to construct templates
+// rather than this one, which provides shared internal data structures not
+// intended for general use.
+package parse
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+// Tree is the representation of a single parsed template.
+type Tree struct {
+	Name      string    // name of the template represented by the tree.
+	ParseName string    // name of the top-level template during parsing, for error messages.
+	Root      *ListNode // top-level root of the tree.
+	text      string    // text parsed to create the template (or its parent)
+	// Parsing only; cleared after parse.
+	funcs     []map[string]interface{}
+	lex       *lexer
+	token     [3]item // three-token lookahead for parser.
+	peekCount int
+	vars      []string // variables defined at the moment.
+}
+
+// Copy returns a copy of the Tree. Any parsing state is discarded.
+func (t *Tree) Copy() *Tree {
+	if t == nil {
+		return nil
+	}
+	return &Tree{
+		Name:      t.Name,
+		ParseName: t.ParseName,
+		Root:      t.Root.CopyList(),
+		text:      t.text,
+	}
+}
+
+// Parse returns a map from template name to parse.Tree, created by parsing the
+// templates described in the argument string. The top-level template will be
+// given the specified name. If an error is encountered, parsing stops and an
+// empty map is returned with the error.
+func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]interface{}) (treeSet map[string]*Tree, err error) {
+	treeSet = make(map[string]*Tree)
+	t := New(name)
+	t.text = text
+	_, err = t.Parse(text, leftDelim, rightDelim, treeSet, funcs...)
+	return
+}
+
+// next returns the next token.
+func (t *Tree) next() item {
+	if t.peekCount > 0 {
+		t.peekCount--
+	} else {
+		t.token[0] = t.lex.nextItem()
+	}
+	return t.token[t.peekCount]
+}
+
+// backup backs the input stream up one token.
+func (t *Tree) backup() {
+	t.peekCount++
+}
+
+// backup2 backs the input stream up two tokens.
+// The zeroth token is already there.
+func (t *Tree) backup2(t1 item) {
+	t.token[1] = t1
+	t.peekCount = 2
+}
+
+// backup3 backs the input stream up three tokens
+// The zeroth token is already there.
+func (t *Tree) backup3(t2, t1 item) { // Reverse order: we're pushing back.
+	t.token[1] = t1
+	t.token[2] = t2
+	t.peekCount = 3
+}
+
+// peek returns but does not consume the next token.
+func (t *Tree) peek() item {
+	if t.peekCount > 0 {
+		return t.token[t.peekCount-1]
+	}
+	t.peekCount = 1
+	t.token[0] = t.lex.nextItem()
+	return t.token[0]
+}
+
+// nextNonSpace returns the next non-space token.
+func (t *Tree) nextNonSpace() (token item) {
+	for {
+		token = t.next()
+		if token.typ != itemSpace {
+			break
+		}
+	}
+	return token
+}
+
+// peekNonSpace returns but does not consume the next non-space token.
+func (t *Tree) peekNonSpace() (token item) {
+	for {
+		token = t.next()
+		if token.typ != itemSpace {
+			break
+		}
+	}
+	t.backup()
+	return token
+}
+
+// Parsing.
+
+// New allocates a new parse tree with the given name.
+func New(name string, funcs ...map[string]interface{}) *Tree {
+	return &Tree{
+		Name:  name,
+		funcs: funcs,
+	}
+}
+
+// ErrorContext returns a textual representation of the location of the node in the input text.
+// The receiver is only used when the node does not have a pointer to the tree inside,
+// which can occur in old code.
+func (t *Tree) ErrorContext(n Node) (location, context string) {
+	pos := int(n.Position())
+	tree := n.tree()
+	if tree == nil {
+		tree = t
+	}
+	text := tree.text[:pos]
+	byteNum := strings.LastIndex(text, "\n")
+	if byteNum == -1 {
+		byteNum = pos // On first line.
+	} else {
+		byteNum++ // After the newline.
+		byteNum = pos - byteNum
+	}
+	lineNum := 1 + strings.Count(text, "\n")
+	context = n.String()
+	if len(context) > 20 {
+		context = fmt.Sprintf("%.20s...", context)
+	}
+	return fmt.Sprintf("%s:%d:%d", tree.ParseName, lineNum, byteNum), context
+}
+
+// errorf formats the error and terminates processing.
+func (t *Tree) errorf(format string, args ...interface{}) {
+	t.Root = nil
+	format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.lex.lineNumber(), format)
+	panic(fmt.Errorf(format, args...))
+}
+
+// error terminates processing.
+func (t *Tree) error(err error) {
+	t.errorf("%s", err)
+}
+
+// expect consumes the next token and guarantees it has the required type.
+func (t *Tree) expect(expected itemType, context string) item {
+	token := t.nextNonSpace()
+	if token.typ != expected {
+		t.unexpected(token, context)
+	}
+	return token
+}
+
+// expectOneOf consumes the next token and guarantees it has one of the required types.
+func (t *Tree) expectOneOf(expected1, expected2 itemType, context string) item {
+	token := t.nextNonSpace()
+	if token.typ != expected1 && token.typ != expected2 {
+		t.unexpected(token, context)
+	}
+	return token
+}
+
+// unexpected complains about the token and terminates processing.
+func (t *Tree) unexpected(token item, context string) {
+	t.errorf("unexpected %s in %s", token, context)
+}
+
+// recover is the handler that turns panics into returns from the top level of Parse.
+func (t *Tree) recover(errp *error) {
+	e := recover()
+	if e != nil {
+		if _, ok := e.(runtime.Error); ok {
+			panic(e)
+		}
+		if t != nil {
+			t.stopParse()
+		}
+		*errp = e.(error)
+	}
+	return
+}
+
+// startParse initializes the parser, using the lexer.
+func (t *Tree) startParse(funcs []map[string]interface{}, lex *lexer) {
+	t.Root = nil
+	t.lex = lex
+	t.vars = []string{"$"}
+	t.funcs = funcs
+}
+
+// stopParse terminates parsing.
+func (t *Tree) stopParse() {
+	t.lex = nil
+	t.vars = nil
+	t.funcs = nil
+}
+
+// Parse parses the template definition string to construct a representation of
+// the template for execution. If either action delimiter string is empty, the
+// default ("{{" or "}}") is used. Embedded template definitions are added to
+// the treeSet map.
+func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]interface{}) (tree *Tree, err error) {
+	defer t.recover(&err)
+	t.ParseName = t.Name
+	t.startParse(funcs, lex(t.Name, text, leftDelim, rightDelim))
+	t.text = text
+	t.parse(treeSet)
+	t.add(treeSet)
+	t.stopParse()
+	return t, nil
+}
+
+// add adds tree to the treeSet.
+func (t *Tree) add(treeSet map[string]*Tree) {
+	tree := treeSet[t.Name]
+	if tree == nil || IsEmptyTree(tree.Root) {
+		treeSet[t.Name] = t
+		return
+	}
+	if !IsEmptyTree(t.Root) {
+		t.errorf("template: multiple definition of template %q", t.Name)
+	}
+}
+
+// IsEmptyTree reports whether this tree (node) is empty of everything but space.
+func IsEmptyTree(n Node) bool {
+	switch n := n.(type) {
+	case nil:
+		return true
+	case *ActionNode:
+	case *IfNode:
+	case *ListNode:
+		for _, node := range n.Nodes {
+			if !IsEmptyTree(node) {
+				return false
+			}
+		}
+		return true
+	case *RangeNode:
+	case *TemplateNode:
+	case *TextNode:
+		return len(bytes.TrimSpace(n.Text)) == 0
+	case *WithNode:
+	default:
+		panic("unknown node: " + n.String())
+	}
+	return false
+}
+
+// parse is the top-level parser for a template, essentially the same
+// as itemList except it also parses {{define}} actions.
+// It runs to EOF.
+func (t *Tree) parse(treeSet map[string]*Tree) (next Node) {
+	t.Root = t.newList(t.peek().pos)
+	for t.peek().typ != itemEOF {
+		if t.peek().typ == itemLeftDelim {
+			delim := t.next()
+			if t.nextNonSpace().typ == itemDefine {
+				newT := New("definition") // name will be updated once we know it.
+				newT.text = t.text
+				newT.ParseName = t.ParseName
+				newT.startParse(t.funcs, t.lex)
+				newT.parseDefinition(treeSet)
+				continue
+			}
+			t.backup2(delim)
+		}
+		n := t.textOrAction()
+		if n.Type() == nodeEnd {
+			t.errorf("unexpected %s", n)
+		}
+		t.Root.append(n)
+	}
+	return nil
+}
+
+// parseDefinition parses a {{define}} ...  {{end}} template definition and
+// installs the definition in the treeSet map.  The "define" keyword has already
+// been scanned.
+func (t *Tree) parseDefinition(treeSet map[string]*Tree) {
+	const context = "define clause"
+	name := t.expectOneOf(itemString, itemRawString, context)
+	var err error
+	t.Name, err = strconv.Unquote(name.val)
+	if err != nil {
+		t.error(err)
+	}
+	t.expect(itemRightDelim, context)
+	var end Node
+	t.Root, end = t.itemList()
+	if end.Type() != nodeEnd {
+		t.errorf("unexpected %s in %s", end, context)
+	}
+	t.add(treeSet)
+	t.stopParse()
+}
+
+// itemList:
+//	textOrAction*
+// Terminates at {{end}} or {{else}}, returned separately.
+func (t *Tree) itemList() (list *ListNode, next Node) {
+	list = t.newList(t.peekNonSpace().pos)
+	for t.peekNonSpace().typ != itemEOF {
+		n := t.textOrAction()
+		switch n.Type() {
+		case nodeEnd, nodeElse:
+			return list, n
+		}
+		list.append(n)
+	}
+	t.errorf("unexpected EOF")
+	return
+}
+
+// textOrAction:
+//	text | action
+func (t *Tree) textOrAction() Node {
+	switch token := t.nextNonSpace(); token.typ {
+	case itemElideNewline:
+		return t.elideNewline()
+	case itemText:
+		return t.newText(token.pos, token.val)
+	case itemLeftDelim:
+		return t.action()
+	default:
+		t.unexpected(token, "input")
+	}
+	return nil
+}
+
+// elideNewline:
+// Remove newlines trailing rightDelim if \\ is present.
+func (t *Tree) elideNewline() Node {
+	token := t.peek()
+	if token.typ != itemText {
+		t.unexpected(token, "input")
+		return nil
+	}
+
+	t.next()
+	stripped := strings.TrimLeft(token.val, "\n\r")
+	diff := len(token.val) - len(stripped)
+	if diff > 0 {
+		// This is a bit nasty. We mutate the token in-place to remove
+		// preceding newlines.
+		token.pos += Pos(diff)
+		token.val = stripped
+	}
+	return t.newText(token.pos, token.val)
+}
+
+// Action:
+//	control
+//	command ("|" command)*
+// Left delim is past. Now get actions.
+// First word could be a keyword such as range.
+func (t *Tree) action() (n Node) {
+	switch token := t.nextNonSpace(); token.typ {
+	case itemElse:
+		return t.elseControl()
+	case itemEnd:
+		return t.endControl()
+	case itemIf:
+		return t.ifControl()
+	case itemRange:
+		return t.rangeControl()
+	case itemTemplate:
+		return t.templateControl()
+	case itemWith:
+		return t.withControl()
+	}
+	t.backup()
+	// Do not pop variables; they persist until "end".
+	return t.newAction(t.peek().pos, t.lex.lineNumber(), t.pipeline("command"))
+}
+
+// Pipeline:
+//	declarations? command ('|' command)*
+func (t *Tree) pipeline(context string) (pipe *PipeNode) {
+	var decl []*VariableNode
+	pos := t.peekNonSpace().pos
+	// Are there declarations?
+	for {
+		if v := t.peekNonSpace(); v.typ == itemVariable {
+			t.next()
+			// Since space is a token, we need 3-token look-ahead here in the worst case:
+			// in "$x foo" we need to read "foo" (as opposed to ":=") to know that $x is an
+			// argument variable rather than a declaration. So remember the token
+			// adjacent to the variable so we can push it back if necessary.
+			tokenAfterVariable := t.peek()
+			if next := t.peekNonSpace(); next.typ == itemColonEquals || (next.typ == itemChar && next.val == ",") {
+				t.nextNonSpace()
+				variable := t.newVariable(v.pos, v.val)
+				decl = append(decl, variable)
+				t.vars = append(t.vars, v.val)
+				if next.typ == itemChar && next.val == "," {
+					if context == "range" && len(decl) < 2 {
+						continue
+					}
+					t.errorf("too many declarations in %s", context)
+				}
+			} else if tokenAfterVariable.typ == itemSpace {
+				t.backup3(v, tokenAfterVariable)
+			} else {
+				t.backup2(v)
+			}
+		}
+		break
+	}
+	pipe = t.newPipeline(pos, t.lex.lineNumber(), decl)
+	for {
+		switch token := t.nextNonSpace(); token.typ {
+		case itemRightDelim, itemRightParen:
+			if len(pipe.Cmds) == 0 {
+				t.errorf("missing value for %s", context)
+			}
+			if token.typ == itemRightParen {
+				t.backup()
+			}
+			return
+		case itemBool, itemCharConstant, itemComplex, itemDot, itemField, itemIdentifier,
+			itemNumber, itemNil, itemRawString, itemString, itemVariable, itemLeftParen:
+			t.backup()
+			pipe.append(t.command())
+		default:
+			t.unexpected(token, context)
+		}
+	}
+}
+
+func (t *Tree) parseControl(allowElseIf bool, context string) (pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) {
+	defer t.popVars(len(t.vars))
+	line = t.lex.lineNumber()
+	pipe = t.pipeline(context)
+	var next Node
+	list, next = t.itemList()
+	switch next.Type() {
+	case nodeEnd: //done
+	case nodeElse:
+		if allowElseIf {
+			// Special case for "else if". If the "else" is followed immediately by an "if",
+			// the elseControl will have left the "if" token pending. Treat
+			//	{{if a}}_{{else if b}}_{{end}}
+			// as
+			//	{{if a}}_{{else}}{{if b}}_{{end}}{{end}}.
+			// To do this, parse the if as usual and stop at it {{end}}; the subsequent{{end}}
+			// is assumed. This technique works even for long if-else-if chains.
+			// TODO: Should we allow else-if in with and range?
+			if t.peek().typ == itemIf {
+				t.next() // Consume the "if" token.
+				elseList = t.newList(next.Position())
+				elseList.append(t.ifControl())
+				// Do not consume the next item - only one {{end}} required.
+				break
+			}
+		}
+		elseList, next = t.itemList()
+		if next.Type() != nodeEnd {
+			t.errorf("expected end; found %s", next)
+		}
+	}
+	return pipe.Position(), line, pipe, list, elseList
+}
+
+// If:
+//	{{if pipeline}} itemList {{end}}
+//	{{if pipeline}} itemList {{else}} itemList {{end}}
+// If keyword is past.
+func (t *Tree) ifControl() Node {
+	return t.newIf(t.parseControl(true, "if"))
+}
+
+// Range:
+//	{{range pipeline}} itemList {{end}}
+//	{{range pipeline}} itemList {{else}} itemList {{end}}
+// Range keyword is past.
+func (t *Tree) rangeControl() Node {
+	return t.newRange(t.parseControl(false, "range"))
+}
+
+// With:
+//	{{with pipeline}} itemList {{end}}
+//	{{with pipeline}} itemList {{else}} itemList {{end}}
+// If keyword is past.
+func (t *Tree) withControl() Node {
+	return t.newWith(t.parseControl(false, "with"))
+}
+
+// End:
+//	{{end}}
+// End keyword is past.
+func (t *Tree) endControl() Node {
+	return t.newEnd(t.expect(itemRightDelim, "end").pos)
+}
+
+// Else:
+//	{{else}}
+// Else keyword is past.
+func (t *Tree) elseControl() Node {
+	// Special case for "else if".
+	peek := t.peekNonSpace()
+	if peek.typ == itemIf {
+		// We see "{{else if ... " but in effect rewrite it to {{else}}{{if ... ".
+		return t.newElse(peek.pos, t.lex.lineNumber())
+	}
+	return t.newElse(t.expect(itemRightDelim, "else").pos, t.lex.lineNumber())
+}
+
+// Template:
+//	{{template stringValue pipeline}}
+// Template keyword is past.  The name must be something that can evaluate
+// to a string.
+func (t *Tree) templateControl() Node {
+	var name string
+	token := t.nextNonSpace()
+	switch token.typ {
+	case itemString, itemRawString:
+		s, err := strconv.Unquote(token.val)
+		if err != nil {
+			t.error(err)
+		}
+		name = s
+	default:
+		t.unexpected(token, "template invocation")
+	}
+	var pipe *PipeNode
+	if t.nextNonSpace().typ != itemRightDelim {
+		t.backup()
+		// Do not pop variables; they persist until "end".
+		pipe = t.pipeline("template")
+	}
+	return t.newTemplate(token.pos, t.lex.lineNumber(), name, pipe)
+}
+
+// command:
+//	operand (space operand)*
+// space-separated arguments up to a pipeline character or right delimiter.
+// we consume the pipe character but leave the right delim to terminate the action.
+func (t *Tree) command() *CommandNode {
+	cmd := t.newCommand(t.peekNonSpace().pos)
+	for {
+		t.peekNonSpace() // skip leading spaces.
+		operand := t.operand()
+		if operand != nil {
+			cmd.append(operand)
+		}
+		switch token := t.next(); token.typ {
+		case itemSpace:
+			continue
+		case itemError:
+			t.errorf("%s", token.val)
+		case itemRightDelim, itemRightParen:
+			t.backup()
+		case itemPipe:
+		default:
+			t.errorf("unexpected %s in operand; missing space?", token)
+		}
+		break
+	}
+	if len(cmd.Args) == 0 {
+		t.errorf("empty command")
+	}
+	return cmd
+}
+
+// operand:
+//	term .Field*
+// An operand is a space-separated component of a command,
+// a term possibly followed by field accesses.
+// A nil return means the next item is not an operand.
+func (t *Tree) operand() Node {
+	node := t.term()
+	if node == nil {
+		return nil
+	}
+	if t.peek().typ == itemField {
+		chain := t.newChain(t.peek().pos, node)
+		for t.peek().typ == itemField {
+			chain.Add(t.next().val)
+		}
+		// Compatibility with original API: If the term is of type NodeField
+		// or NodeVariable, just put more fields on the original.
+		// Otherwise, keep the Chain node.
+		// TODO: Switch to Chains always when we can.
+		switch node.Type() {
+		case NodeField:
+			node = t.newField(chain.Position(), chain.String())
+		case NodeVariable:
+			node = t.newVariable(chain.Position(), chain.String())
+		default:
+			node = chain
+		}
+	}
+	return node
+}
+
+// term:
+//	literal (number, string, nil, boolean)
+//	function (identifier)
+//	.
+//	.Field
+//	$
+//	'(' pipeline ')'
+// A term is a simple "expression".
+// A nil return means the next item is not a term.
+func (t *Tree) term() Node {
+	switch token := t.nextNonSpace(); token.typ {
+	case itemError:
+		t.errorf("%s", token.val)
+	case itemIdentifier:
+		if !t.hasFunction(token.val) {
+			t.errorf("function %q not defined", token.val)
+		}
+		return NewIdentifier(token.val).SetTree(t).SetPos(token.pos)
+	case itemDot:
+		return t.newDot(token.pos)
+	case itemNil:
+		return t.newNil(token.pos)
+	case itemVariable:
+		return t.useVar(token.pos, token.val)
+	case itemField:
+		return t.newField(token.pos, token.val)
+	case itemBool:
+		return t.newBool(token.pos, token.val == "true")
+	case itemCharConstant, itemComplex, itemNumber:
+		number, err := t.newNumber(token.pos, token.val, token.typ)
+		if err != nil {
+			t.error(err)
+		}
+		return number
+	case itemLeftParen:
+		pipe := t.pipeline("parenthesized pipeline")
+		if token := t.next(); token.typ != itemRightParen {
+			t.errorf("unclosed right paren: unexpected %s", token)
+		}
+		return pipe
+	case itemString, itemRawString:
+		s, err := strconv.Unquote(token.val)
+		if err != nil {
+			t.error(err)
+		}
+		return t.newString(token.pos, token.val, s)
+	}
+	t.backup()
+	return nil
+}
+
+// hasFunction reports if a function name exists in the Tree's maps.
+func (t *Tree) hasFunction(name string) bool {
+	for _, funcMap := range t.funcs {
+		if funcMap == nil {
+			continue
+		}
+		if funcMap[name] != nil {
+			return true
+		}
+	}
+	return false
+}
+
+// popVars trims the variable list to the specified length
+func (t *Tree) popVars(n int) {
+	t.vars = t.vars[:n]
+}
+
+// useVar returns a node for a variable reference. It errors if the
+// variable is not defined.
+func (t *Tree) useVar(pos Pos, name string) Node {
+	v := t.newVariable(pos, name)
+	for _, varName := range t.vars {
+		if varName == v.Ident[0] {
+			return v
+		}
+	}
+	t.errorf("undefined variable %q", v.Ident[0])
+	return nil
+}
diff --git a/vendor/github.com/alecthomas/template/template.go b/vendor/github.com/alecthomas/template/template.go
new file mode 100644
index 00000000..8632e417
--- /dev/null
+++ b/vendor/github.com/alecthomas/template/template.go
@@ -0,0 +1,217 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package template
+
+import (
+	"fmt"
+	"reflect"
+	"github.com/alecthomas/template/parse"
+)
+
+// common holds the information shared by related templates.
+type common struct {
+	tmpl map[string]*Template
+	// We use two maps, one for parsing and one for execution.
+	// This separation makes the API cleaner since it doesn't
+	// expose reflection to the client.
+	parseFuncs FuncMap
+	execFuncs  map[string]reflect.Value
+}
+
+// Template is the representation of a parsed template. The *parse.Tree
+// field is exported only for use by html/template and should be treated
+// as unexported by all other clients.
+type Template struct {
+	name string
+	*parse.Tree
+	*common
+	leftDelim  string
+	rightDelim string
+}
+
+// New allocates a new template with the given name.
+func New(name string) *Template {
+	return &Template{
+		name: name,
+	}
+}
+
+// Name returns the name of the template.
+func (t *Template) Name() string {
+	return t.name
+}
+
+// New allocates a new template associated with the given one and with the same
+// delimiters. The association, which is transitive, allows one template to
+// invoke another with a {{template}} action.
+func (t *Template) New(name string) *Template {
+	t.init()
+	return &Template{
+		name:       name,
+		common:     t.common,
+		leftDelim:  t.leftDelim,
+		rightDelim: t.rightDelim,
+	}
+}
+
+func (t *Template) init() {
+	if t.common == nil {
+		t.common = new(common)
+		t.tmpl = make(map[string]*Template)
+		t.parseFuncs = make(FuncMap)
+		t.execFuncs = make(map[string]reflect.Value)
+	}
+}
+
+// Clone returns a duplicate of the template, including all associated
+// templates. The actual representation is not copied, but the name space of
+// associated templates is, so further calls to Parse in the copy will add
+// templates to the copy but not to the original. Clone can be used to prepare
+// common templates and use them with variant definitions for other templates
+// by adding the variants after the clone is made.
+func (t *Template) Clone() (*Template, error) {
+	nt := t.copy(nil)
+	nt.init()
+	nt.tmpl[t.name] = nt
+	for k, v := range t.tmpl {
+		if k == t.name { // Already installed.
+			continue
+		}
+		// The associated templates share nt's common structure.
+		tmpl := v.copy(nt.common)
+		nt.tmpl[k] = tmpl
+	}
+	for k, v := range t.parseFuncs {
+		nt.parseFuncs[k] = v
+	}
+	for k, v := range t.execFuncs {
+		nt.execFuncs[k] = v
+	}
+	return nt, nil
+}
+
+// copy returns a shallow copy of t, with common set to the argument.
+func (t *Template) copy(c *common) *Template {
+	nt := New(t.name)
+	nt.Tree = t.Tree
+	nt.common = c
+	nt.leftDelim = t.leftDelim
+	nt.rightDelim = t.rightDelim
+	return nt
+}
+
+// AddParseTree creates a new template with the name and parse tree
+// and associates it with t.
+func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) {
+	if t.common != nil && t.tmpl[name] != nil {
+		return nil, fmt.Errorf("template: redefinition of template %q", name)
+	}
+	nt := t.New(name)
+	nt.Tree = tree
+	t.tmpl[name] = nt
+	return nt, nil
+}
+
+// Templates returns a slice of the templates associated with t, including t
+// itself.
+func (t *Template) Templates() []*Template {
+	if t.common == nil {
+		return nil
+	}
+	// Return a slice so we don't expose the map.
+	m := make([]*Template, 0, len(t.tmpl))
+	for _, v := range t.tmpl {
+		m = append(m, v)
+	}
+	return m
+}
+
+// Delims sets the action delimiters to the specified strings, to be used in
+// subsequent calls to Parse, ParseFiles, or ParseGlob. Nested template
+// definitions will inherit the settings. An empty delimiter stands for the
+// corresponding default: {{ or }}.
+// The return value is the template, so calls can be chained.
+func (t *Template) Delims(left, right string) *Template {
+	t.leftDelim = left
+	t.rightDelim = right
+	return t
+}
+
+// Funcs adds the elements of the argument map to the template's function map.
+// It panics if a value in the map is not a function with appropriate return
+// type. However, it is legal to overwrite elements of the map. The return
+// value is the template, so calls can be chained.
+func (t *Template) Funcs(funcMap FuncMap) *Template {
+	t.init()
+	addValueFuncs(t.execFuncs, funcMap)
+	addFuncs(t.parseFuncs, funcMap)
+	return t
+}
+
+// Lookup returns the template with the given name that is associated with t,
+// or nil if there is no such template.
+func (t *Template) Lookup(name string) *Template {
+	if t.common == nil {
+		return nil
+	}
+	return t.tmpl[name]
+}
+
+// Parse parses a string into a template. Nested template definitions will be
+// associated with the top-level template t. Parse may be called multiple times
+// to parse definitions of templates to associate with t. It is an error if a
+// resulting template is non-empty (contains content other than template
+// definitions) and would replace a non-empty template with the same name.
+// (In multiple calls to Parse with the same receiver template, only one call
+// can contain text other than space, comments, and template definitions.)
+func (t *Template) Parse(text string) (*Template, error) {
+	t.init()
+	trees, err := parse.Parse(t.name, text, t.leftDelim, t.rightDelim, t.parseFuncs, builtins)
+	if err != nil {
+		return nil, err
+	}
+	// Add the newly parsed trees, including the one for t, into our common structure.
+	for name, tree := range trees {
+		// If the name we parsed is the name of this template, overwrite this template.
+		// The associate method checks it's not a redefinition.
+		tmpl := t
+		if name != t.name {
+			tmpl = t.New(name)
+		}
+		// Even if t == tmpl, we need to install it in the common.tmpl map.
+		if replace, err := t.associate(tmpl, tree); err != nil {
+			return nil, err
+		} else if replace {
+			tmpl.Tree = tree
+		}
+		tmpl.leftDelim = t.leftDelim
+		tmpl.rightDelim = t.rightDelim
+	}
+	return t, nil
+}
+
+// associate installs the new template into the group of templates associated
+// with t. It is an error to reuse a name except to overwrite an empty
+// template. The two are already known to share the common structure.
+// The boolean return value reports wither to store this tree as t.Tree.
+func (t *Template) associate(new *Template, tree *parse.Tree) (bool, error) {
+	if new.common != t.common {
+		panic("internal error: associate not common")
+	}
+	name := new.name
+	if old := t.tmpl[name]; old != nil {
+		oldIsEmpty := parse.IsEmptyTree(old.Root)
+		newIsEmpty := parse.IsEmptyTree(tree.Root)
+		if newIsEmpty {
+			// Whether old is empty or not, new is empty; no reason to replace old.
+			return false, nil
+		}
+		if !oldIsEmpty {
+			return false, fmt.Errorf("template: redefinition of template %q", name)
+		}
+	}
+	t.tmpl[name] = new
+	return true, nil
+}
diff --git a/vendor/github.com/alecthomas/units/COPYING b/vendor/github.com/alecthomas/units/COPYING
new file mode 100644
index 00000000..2993ec08
--- /dev/null
+++ b/vendor/github.com/alecthomas/units/COPYING
@@ -0,0 +1,19 @@
+Copyright (C) 2014 Alec Thomas
+
+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.
diff --git a/vendor/github.com/alecthomas/units/README.md b/vendor/github.com/alecthomas/units/README.md
new file mode 100644
index 00000000..bee884e3
--- /dev/null
+++ b/vendor/github.com/alecthomas/units/README.md
@@ -0,0 +1,11 @@
+# Units - Helpful unit multipliers and functions for Go
+
+The goal of this package is to have functionality similar to the [time](http://golang.org/pkg/time/) package.
+
+It allows for code like this:
+
+```go
+n, err := ParseBase2Bytes("1KB")
+// n == 1024
+n = units.Mebibyte * 512
+```
diff --git a/vendor/github.com/alecthomas/units/bytes.go b/vendor/github.com/alecthomas/units/bytes.go
new file mode 100644
index 00000000..eaadeb80
--- /dev/null
+++ b/vendor/github.com/alecthomas/units/bytes.go
@@ -0,0 +1,83 @@
+package units
+
+// Base2Bytes is the old non-SI power-of-2 byte scale (1024 bytes in a kilobyte,
+// etc.).
+type Base2Bytes int64
+
+// Base-2 byte units.
+const (
+	Kibibyte Base2Bytes = 1024
+	KiB                 = Kibibyte
+	Mebibyte            = Kibibyte * 1024
+	MiB                 = Mebibyte
+	Gibibyte            = Mebibyte * 1024
+	GiB                 = Gibibyte
+	Tebibyte            = Gibibyte * 1024
+	TiB                 = Tebibyte
+	Pebibyte            = Tebibyte * 1024
+	PiB                 = Pebibyte
+	Exbibyte            = Pebibyte * 1024
+	EiB                 = Exbibyte
+)
+
+var (
+	bytesUnitMap    = MakeUnitMap("iB", "B", 1024)
+	oldBytesUnitMap = MakeUnitMap("B", "B", 1024)
+)
+
+// ParseBase2Bytes supports both iB and B in base-2 multipliers. That is, KB
+// and KiB are both 1024.
+func ParseBase2Bytes(s string) (Base2Bytes, error) {
+	n, err := ParseUnit(s, bytesUnitMap)
+	if err != nil {
+		n, err = ParseUnit(s, oldBytesUnitMap)
+	}
+	return Base2Bytes(n), err
+}
+
+func (b Base2Bytes) String() string {
+	return ToString(int64(b), 1024, "iB", "B")
+}
+
+var (
+	metricBytesUnitMap = MakeUnitMap("B", "B", 1000)
+)
+
+// MetricBytes are SI byte units (1000 bytes in a kilobyte).
+type MetricBytes SI
+
+// SI base-10 byte units.
+const (
+	Kilobyte MetricBytes = 1000
+	KB                   = Kilobyte
+	Megabyte             = Kilobyte * 1000
+	MB                   = Megabyte
+	Gigabyte             = Megabyte * 1000
+	GB                   = Gigabyte
+	Terabyte             = Gigabyte * 1000
+	TB                   = Terabyte
+	Petabyte             = Terabyte * 1000
+	PB                   = Petabyte
+	Exabyte              = Petabyte * 1000
+	EB                   = Exabyte
+)
+
+// ParseMetricBytes parses base-10 metric byte units. That is, KB is 1000 bytes.
+func ParseMetricBytes(s string) (MetricBytes, error) {
+	n, err := ParseUnit(s, metricBytesUnitMap)
+	return MetricBytes(n), err
+}
+
+func (m MetricBytes) String() string {
+	return ToString(int64(m), 1000, "B", "B")
+}
+
+// ParseStrictBytes supports both iB and B suffixes for base 2 and metric,
+// respectively. That is, KiB represents 1024 and KB represents 1000.
+func ParseStrictBytes(s string) (int64, error) {
+	n, err := ParseUnit(s, bytesUnitMap)
+	if err != nil {
+		n, err = ParseUnit(s, metricBytesUnitMap)
+	}
+	return int64(n), err
+}
diff --git a/vendor/github.com/alecthomas/units/doc.go b/vendor/github.com/alecthomas/units/doc.go
new file mode 100644
index 00000000..156ae386
--- /dev/null
+++ b/vendor/github.com/alecthomas/units/doc.go
@@ -0,0 +1,13 @@
+// Package units provides helpful unit multipliers and functions for Go.
+//
+// The goal of this package is to have functionality similar to the time [1] package.
+//
+//
+// [1] http://golang.org/pkg/time/
+//
+// It allows for code like this:
+//
+//     n, err := ParseBase2Bytes("1KB")
+//     // n == 1024
+//     n = units.Mebibyte * 512
+package units
diff --git a/vendor/github.com/alecthomas/units/si.go b/vendor/github.com/alecthomas/units/si.go
new file mode 100644
index 00000000..8234a9d5
--- /dev/null
+++ b/vendor/github.com/alecthomas/units/si.go
@@ -0,0 +1,26 @@
+package units
+
+// SI units.
+type SI int64
+
+// SI unit multiples.
+const (
+	Kilo SI = 1000
+	Mega    = Kilo * 1000
+	Giga    = Mega * 1000
+	Tera    = Giga * 1000
+	Peta    = Tera * 1000
+	Exa     = Peta * 1000
+)
+
+func MakeUnitMap(suffix, shortSuffix string, scale int64) map[string]float64 {
+	return map[string]float64{
+		shortSuffix:  1,
+		"K" + suffix: float64(scale),
+		"M" + suffix: float64(scale * scale),
+		"G" + suffix: float64(scale * scale * scale),
+		"T" + suffix: float64(scale * scale * scale * scale),
+		"P" + suffix: float64(scale * scale * scale * scale * scale),
+		"E" + suffix: float64(scale * scale * scale * scale * scale * scale),
+	}
+}
diff --git a/vendor/github.com/alecthomas/units/util.go b/vendor/github.com/alecthomas/units/util.go
new file mode 100644
index 00000000..6527e92d
--- /dev/null
+++ b/vendor/github.com/alecthomas/units/util.go
@@ -0,0 +1,138 @@
+package units
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+var (
+	siUnits = []string{"", "K", "M", "G", "T", "P", "E"}
+)
+
+func ToString(n int64, scale int64, suffix, baseSuffix string) string {
+	mn := len(siUnits)
+	out := make([]string, mn)
+	for i, m := range siUnits {
+		if n%scale != 0 || i == 0 && n == 0 {
+			s := suffix
+			if i == 0 {
+				s = baseSuffix
+			}
+			out[mn-1-i] = fmt.Sprintf("%d%s%s", n%scale, m, s)
+		}
+		n /= scale
+		if n == 0 {
+			break
+		}
+	}
+	return strings.Join(out, "")
+}
+
+// Below code ripped straight from http://golang.org/src/pkg/time/format.go?s=33392:33438#L1123
+var errLeadingInt = errors.New("units: bad [0-9]*") // never printed
+
+// leadingInt consumes the leading [0-9]* from s.
+func leadingInt(s string) (x int64, rem string, err error) {
+	i := 0
+	for ; i < len(s); i++ {
+		c := s[i]
+		if c < '0' || c > '9' {
+			break
+		}
+		if x >= (1<<63-10)/10 {
+			// overflow
+			return 0, "", errLeadingInt
+		}
+		x = x*10 + int64(c) - '0'
+	}
+	return x, s[i:], nil
+}
+
+func ParseUnit(s string, unitMap map[string]float64) (int64, error) {
+	// [-+]?([0-9]*(\.[0-9]*)?[a-z]+)+
+	orig := s
+	f := float64(0)
+	neg := false
+
+	// Consume [-+]?
+	if s != "" {
+		c := s[0]
+		if c == '-' || c == '+' {
+			neg = c == '-'
+			s = s[1:]
+		}
+	}
+	// Special case: if all that is left is "0", this is zero.
+	if s == "0" {
+		return 0, nil
+	}
+	if s == "" {
+		return 0, errors.New("units: invalid " + orig)
+	}
+	for s != "" {
+		g := float64(0) // this element of the sequence
+
+		var x int64
+		var err error
+
+		// The next character must be [0-9.]
+		if !(s[0] == '.' || ('0' <= s[0] && s[0] <= '9')) {
+			return 0, errors.New("units: invalid " + orig)
+		}
+		// Consume [0-9]*
+		pl := len(s)
+		x, s, err = leadingInt(s)
+		if err != nil {
+			return 0, errors.New("units: invalid " + orig)
+		}
+		g = float64(x)
+		pre := pl != len(s) // whether we consumed anything before a period
+
+		// Consume (\.[0-9]*)?
+		post := false
+		if s != "" && s[0] == '.' {
+			s = s[1:]
+			pl := len(s)
+			x, s, err = leadingInt(s)
+			if err != nil {
+				return 0, errors.New("units: invalid " + orig)
+			}
+			scale := 1.0
+			for n := pl - len(s); n > 0; n-- {
+				scale *= 10
+			}
+			g += float64(x) / scale
+			post = pl != len(s)
+		}
+		if !pre && !post {
+			// no digits (e.g. ".s" or "-.s")
+			return 0, errors.New("units: invalid " + orig)
+		}
+
+		// Consume unit.
+		i := 0
+		for ; i < len(s); i++ {
+			c := s[i]
+			if c == '.' || ('0' <= c && c <= '9') {
+				break
+			}
+		}
+		u := s[:i]
+		s = s[i:]
+		unit, ok := unitMap[u]
+		if !ok {
+			return 0, errors.New("units: unknown unit " + u + " in " + orig)
+		}
+
+		f += g * unit
+	}
+
+	if neg {
+		f = -f
+	}
+	if f < float64(-1<<63) || f > float64(1<<63-1) {
+		return 0, errors.New("units: overflow parsing unit")
+	}
+	return int64(f), nil
+}
diff --git a/vendor/github.com/barakmich/glog/LICENSE b/vendor/github.com/barakmich/glog/LICENSE
new file mode 100644
index 00000000..37ec93a1
--- /dev/null
+++ b/vendor/github.com/barakmich/glog/LICENSE
@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/barakmich/glog/README b/vendor/github.com/barakmich/glog/README
new file mode 100644
index 00000000..5f9c1148
--- /dev/null
+++ b/vendor/github.com/barakmich/glog/README
@@ -0,0 +1,44 @@
+glog
+====
+
+Leveled execution logs for Go.
+
+This is an efficient pure Go implementation of leveled logs in the
+manner of the open source C++ package
+	http://code.google.com/p/google-glog
+
+By binding methods to booleans it is possible to use the log package
+without paying the expense of evaluating the arguments to the log.
+Through the -vmodule flag, the package also provides fine-grained
+control over logging at the file level.
+
+The comment from glog.go introduces the ideas:
+
+	Package glog implements logging analogous to the Google-internal
+	C++ INFO/ERROR/V setup.  It provides functions Info, Warning,
+	Error, Fatal, plus formatting variants such as Infof. It
+	also provides V-style logging controlled by the -v and
+	-vmodule=file=2 flags.
+	
+	Basic examples:
+	
+		glog.Info("Prepare to repel boarders")
+	
+		glog.Fatalf("Initialization failed: %s", err)
+	
+	See the documentation for the V function for an explanation
+	of these examples:
+	
+		if glog.V(2) {
+			glog.Info("Starting transaction...")
+		}
+	
+		glog.V(2).Infoln("Processed", nItems, "elements")
+
+
+The repository contains an open source version of the log package
+used inside Google. The master copy of the source lives inside
+Google, not here. The code in this repo is for export only and is not itself
+under development. Feature requests will be ignored.
+
+Send bug reports to golang-nuts@googlegroups.com.
diff --git a/vendor/github.com/barakmich/glog/glog.go b/vendor/github.com/barakmich/glog/glog.go
new file mode 100644
index 00000000..1c895761
--- /dev/null
+++ b/vendor/github.com/barakmich/glog/glog.go
@@ -0,0 +1,1118 @@
+// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
+//
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package glog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup.
+// It provides functions Info, Warning, Error, Fatal, plus formatting variants such as
+// Infof. It also provides V-style logging controlled by the -v and -vmodule=file=2 flags.
+//
+// Basic examples:
+//
+//  glog.Info("Prepare to repel boarders")
+//
+//  glog.Fatalf("Initialization failed: %s", err)
+//
+// See the documentation for the V function for an explanation of these examples:
+//
+//  if glog.V(2) {
+//      glog.Info("Starting transaction...")
+//  }
+//
+//  glog.V(2).Infoln("Processed", nItems, "elements")
+//
+// Log output is buffered and written periodically using Flush. Programs
+// should call Flush before exiting to guarantee all log output is written.
+//
+// By default, all log statements write to files in a temporary directory.
+// This package provides several flags that modify this behavior.
+//
+//  -logtostderr=false
+//      Logs are written to standard error instead of to files.
+//  -alsologtostderr=false
+//      Logs are written to standard error as well as to files.
+//  -stderrthreshold=ERROR
+//      Log events at or above this severity are logged to standard
+//      error as well as to files.
+//  -log_dir=""
+//      Log files will be written to this directory instead of the
+//      default temporary directory.
+//
+//  Other flags provide aids to debugging.
+//
+//  -log_backtrace_at=""
+//      When set to a file and line number holding a logging statement,
+//      such as
+//          -log_backtrace_at=gopherflakes.go:234
+//      a stack trace will be written to the Info log whenever execution
+//      hits that statement. (Unlike with -vmodule, the ".go" must be
+//      present.)
+//  -v=0
+//      Enable V-leveled logging at the specified level.
+//  -vmodule=""
+//      The syntax of the argument is a comma-separated list of pattern=N,
+//      where pattern is a literal file name (minus the ".go" suffix) or
+//      "glob" pattern and N is a V level. For instance,
+//          -vmodule=gopher*=3
+//      sets the V level to 3 in all Go files whose names begin "gopher".
+//
+package glog
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// severity identifies the sort of log: info, warning etc. It also implements
+// the flag.Value interface. The -stderrthreshold flag is of type severity and
+// should be modified only through the flag.Value interface. The values match
+// the corresponding constants in C++.
+type severity int32 // sync/atomic int32
+
+const (
+	infoLog severity = iota
+	warningLog
+	errorLog
+	fatalLog
+	numSeverity = 4
+)
+
+const severityChar = "IWEF"
+
+var severityName = []string{
+	infoLog:    "INFO",
+	warningLog: "WARNING",
+	errorLog:   "ERROR",
+	fatalLog:   "FATAL",
+}
+
+// get returns the value of the severity.
+func (s *severity) get() severity {
+	return severity(atomic.LoadInt32((*int32)(s)))
+}
+
+// set sets the value of the severity.
+func (s *severity) set(val severity) {
+	atomic.StoreInt32((*int32)(s), int32(val))
+}
+
+// String is part of the flag.Value interface.
+func (s *severity) String() string {
+	return strconv.FormatInt(int64(*s), 10)
+}
+
+// Get is part of the flag.Value interface.
+func (s *severity) Get() interface{} {
+	return *s
+}
+
+// Set is part of the flag.Value interface.
+func (s *severity) Set(value string) error {
+	var threshold severity
+	// Is it a known name?
+	if v, ok := severityByName(value); ok {
+		threshold = v
+	} else {
+		v, err := strconv.Atoi(value)
+		if err != nil {
+			return err
+		}
+		threshold = severity(v)
+	}
+	logging.stderrThreshold.set(threshold)
+	return nil
+}
+
+func severityByName(s string) (severity, bool) {
+	s = strings.ToUpper(s)
+	for i, name := range severityName {
+		if name == s {
+			return severity(i), true
+		}
+	}
+	return 0, false
+}
+
+// OutputStats tracks the number of output lines and bytes written.
+type OutputStats struct {
+	lines int64
+	bytes int64
+}
+
+// Lines returns the number of lines written.
+func (s *OutputStats) Lines() int64 {
+	return atomic.LoadInt64(&s.lines)
+}
+
+// Bytes returns the number of bytes written.
+func (s *OutputStats) Bytes() int64 {
+	return atomic.LoadInt64(&s.bytes)
+}
+
+// Stats tracks the number of lines of output and number of bytes
+// per severity level. Values must be read with atomic.LoadInt64.
+var Stats struct {
+	Info, Warning, Error OutputStats
+}
+
+var severityStats = [numSeverity]*OutputStats{
+	infoLog:    &Stats.Info,
+	warningLog: &Stats.Warning,
+	errorLog:   &Stats.Error,
+}
+
+// Level is exported because it appears in the arguments to V and is
+// the type of the v flag, which can be set programmatically.
+// It's a distinct type because we want to discriminate it from logType.
+// Variables of type level are only changed under logging.mu.
+// The -v flag is read only with atomic ops, so the state of the logging
+// module is consistent.
+
+// Level is treated as a sync/atomic int32.
+
+// Level specifies a level of verbosity for V logs. *Level implements
+// flag.Value; the -v flag is of type Level and should be modified
+// only through the flag.Value interface.
+type Level int32
+
+// get returns the value of the Level.
+func (l *Level) get() Level {
+	return Level(atomic.LoadInt32((*int32)(l)))
+}
+
+// set sets the value of the Level.
+func (l *Level) set(val Level) {
+	atomic.StoreInt32((*int32)(l), int32(val))
+}
+
+// String is part of the flag.Value interface.
+func (l *Level) String() string {
+	return strconv.FormatInt(int64(*l), 10)
+}
+
+// Get is part of the flag.Value interface.
+func (l *Level) Get() interface{} {
+	return *l
+}
+
+// Set is part of the flag.Value interface.
+func (l *Level) Set(value string) error {
+	v, err := strconv.Atoi(value)
+	if err != nil {
+		return err
+	}
+	logging.mu.Lock()
+	defer logging.mu.Unlock()
+	logging.setVState(Level(v), logging.vmodule.filter, false)
+	return nil
+}
+
+// moduleSpec represents the setting of the -vmodule flag.
+type moduleSpec struct {
+	filter []modulePat
+}
+
+// modulePat contains a filter for the -vmodule flag.
+// It holds a verbosity level and a file pattern to match.
+type modulePat struct {
+	pattern string
+	literal bool // The pattern is a literal string
+	level   Level
+}
+
+// match reports whether the file matches the pattern. It uses a string
+// comparison if the pattern contains no metacharacters.
+func (m *modulePat) match(file string) bool {
+	if m.literal {
+		return file == m.pattern
+	}
+	match, _ := filepath.Match(m.pattern, file)
+	return match
+}
+
+func (m *moduleSpec) String() string {
+	// Lock because the type is not atomic. TODO: clean this up.
+	logging.mu.Lock()
+	defer logging.mu.Unlock()
+	var b bytes.Buffer
+	for i, f := range m.filter {
+		if i > 0 {
+			b.WriteRune(',')
+		}
+		fmt.Fprintf(&b, "%s=%d", f.pattern, f.level)
+	}
+	return b.String()
+}
+
+// Get is part of the (Go 1.2)  flag.Getter interface. It always returns nil for this flag type since the
+// struct is not exported.
+func (m *moduleSpec) Get() interface{} {
+	return nil
+}
+
+var errVmoduleSyntax = errors.New("syntax error: expect comma-separated list of filename=N")
+
+// Syntax: -vmodule=recordio=2,file=1,gfs*=3
+func (m *moduleSpec) Set(value string) error {
+	var filter []modulePat
+	for _, pat := range strings.Split(value, ",") {
+		if len(pat) == 0 {
+			// Empty strings such as from a trailing comma can be ignored.
+			continue
+		}
+		patLev := strings.Split(pat, "=")
+		if len(patLev) != 2 || len(patLev[0]) == 0 || len(patLev[1]) == 0 {
+			return errVmoduleSyntax
+		}
+		pattern := patLev[0]
+		v, err := strconv.Atoi(patLev[1])
+		if err != nil {
+			return errors.New("syntax error: expect comma-separated list of filename=N")
+		}
+		if v < 0 {
+			return errors.New("negative value for vmodule level")
+		}
+		if v == 0 {
+			continue // Ignore. It's harmless but no point in paying the overhead.
+		}
+		// TODO: check syntax of filter?
+		filter = append(filter, modulePat{pattern, isLiteral(pattern), Level(v)})
+	}
+	logging.mu.Lock()
+	defer logging.mu.Unlock()
+	logging.setVState(logging.verbosity, filter, true)
+	return nil
+}
+
+// isLiteral reports whether the pattern is a literal string, that is, has no metacharacters
+// that require filepath.Match to be called to match the pattern.
+func isLiteral(pattern string) bool {
+	return !strings.ContainsAny(pattern, `*?[]\`)
+}
+
+// traceLocation represents the setting of the -log_backtrace_at flag.
+type traceLocation struct {
+	file string
+	line int
+}
+
+// isSet reports whether the trace location has been specified.
+// logging.mu is held.
+func (t *traceLocation) isSet() bool {
+	return t.line > 0
+}
+
+// match reports whether the specified file and line matches the trace location.
+// The argument file name is the full path, not the basename specified in the flag.
+// logging.mu is held.
+func (t *traceLocation) match(file string, line int) bool {
+	if t.line != line {
+		return false
+	}
+	if i := strings.LastIndex(file, "/"); i >= 0 {
+		file = file[i+1:]
+	}
+	return t.file == file
+}
+
+func (t *traceLocation) String() string {
+	// Lock because the type is not atomic. TODO: clean this up.
+	logging.mu.Lock()
+	defer logging.mu.Unlock()
+	return fmt.Sprintf("%s:%d", t.file, t.line)
+}
+
+// Get is part of the (Go 1.2) flag.Getter interface. It always returns nil for this flag type since the
+// struct is not exported
+func (t *traceLocation) Get() interface{} {
+	return nil
+}
+
+var errTraceSyntax = errors.New("syntax error: expect file.go:234")
+
+// Syntax: -log_backtrace_at=gopherflakes.go:234
+// Note that unlike vmodule the file extension is included here.
+func (t *traceLocation) Set(value string) error {
+	if value == "" {
+		// Unset.
+		t.line = 0
+		t.file = ""
+	}
+	fields := strings.Split(value, ":")
+	if len(fields) != 2 {
+		return errTraceSyntax
+	}
+	file, line := fields[0], fields[1]
+	if !strings.Contains(file, ".") {
+		return errTraceSyntax
+	}
+	v, err := strconv.Atoi(line)
+	if err != nil {
+		return errTraceSyntax
+	}
+	if v <= 0 {
+		return errors.New("negative or zero value for level")
+	}
+	logging.mu.Lock()
+	defer logging.mu.Unlock()
+	t.line = v
+	t.file = file
+	return nil
+}
+
+// flushSyncWriter is the interface satisfied by logging destinations.
+type flushSyncWriter interface {
+	Flush() error
+	Sync() error
+	io.Writer
+}
+
+func init() {
+	flag.BoolVar(&logging.toStderr, "logtostderr", false, "log to standard error instead of files")
+	flag.BoolVar(&logging.alsoToStderr, "alsologtostderr", false, "log to standard error as well as files")
+	flag.StringVar(&logging.logstashType, "logstashtype", "", "enable logstash logging and define the type")
+	flag.StringVar(&logging.logstashURL, "logstashurl", "172.17.42.1:5042", "logstash url and port")
+	flag.Var(&logging.verbosity, "v", "log level for V logs")
+	flag.Var(&logging.stderrThreshold, "stderrthreshold", "logs at or above this threshold go to stderr")
+	flag.Var(&logging.vmodule, "vmodule", "comma-separated list of pattern=N settings for file-filtered logging")
+	flag.Var(&logging.traceLocation, "log_backtrace_at", "when logging hits line file:N, emit a stack trace")
+
+	// Default stderrThreshold is ERROR.
+	logging.stderrThreshold = errorLog
+	logging.color = false
+
+	logging.setVState(0, nil, false)
+	go logging.flushDaemon()
+}
+
+// Programatic Method to set logging to stderr instead of file
+func SetToStderr(value bool) {
+	logging.toStderr = value
+}
+
+// Programatic Method to set logging to stderr and files
+func SetAlsoToStderr(value bool) {
+	logging.alsoToStderr = value
+}
+
+// Programatic Method to set logstash type
+func SetLogstashType(value string) {
+	logging.logstashType = value
+}
+
+// Programatic Method to set the logstash url
+func SetLogstashURL(value string) {
+	logging.logstashURL = value
+}
+
+// Programatic Method to set logging verbosity
+func SetVerbosity(value int) {
+	logging.verbosity = Level(value)
+}
+
+// Programatic Method to set logging verbosity
+func SetColorOutput(value bool) {
+	logging.color = value
+}
+
+// Programatic Method to set logging verbosity
+func GetVerbosity() Level {
+	return logging.verbosity
+}
+
+// Programatic Method to set stderr threshold
+func SetStderrThreshold(value string) error {
+	return logging.stderrThreshold.Set(value)
+}
+
+// Programatic Method to set vmodule
+func SetVModule(value string) error {
+	return logging.vmodule.Set(value)
+}
+
+func SetTraceLocation(value string) error {
+	return logging.traceLocation.Set(value)
+}
+
+// Flush flushes all pending log I/O.
+func Flush() {
+	logging.lockAndFlushAll()
+}
+
+// loggingT collects all the global state of the logging setup.
+type loggingT struct {
+	// Boolean flags. Not handled atomically because the flag.Value interface
+	// does not let us avoid the =true, and that shorthand is necessary for
+	// compatibility. TODO: does this matter enough to fix? Seems unlikely.
+	color bool // The -color flag.
+
+	toStderr     bool // The -logtostderr flag.
+	alsoToStderr bool // The -alsologtostderr flag.
+
+	// logstash
+	logstashType string
+	logstashURL  string
+	logstashChan chan string
+	logstashStop chan bool
+	logstashOnce sync.Once
+
+	// Level flag. Handled atomically.
+	stderrThreshold severity // The -stderrthreshold flag.
+
+	// freeList is a list of byte buffers, maintained under freeListMu.
+	freeList *buffer
+	// freeListMu maintains the free list. It is separate from the main mutex
+	// so buffers can be grabbed and printed to without holding the main lock,
+	// for better parallelization.
+	freeListMu sync.Mutex
+
+	// mu protects the remaining elements of this structure and is
+	// used to synchronize logging.
+	mu sync.Mutex
+	// file holds writer for each of the log types.
+	file [numSeverity]flushSyncWriter
+	// pcs is used in V to avoid an allocation when computing the caller's PC.
+	pcs [1]uintptr
+	// vmap is a cache of the V Level for each V() call site, identified by PC.
+	// It is wiped whenever the vmodule flag changes state.
+	vmap map[uintptr]Level
+	// filterLength stores the length of the vmodule filter chain. If greater
+	// than zero, it means vmodule is enabled. It may be read safely
+	// using sync.LoadInt32, but is only modified under mu.
+	filterLength int32
+	// traceLocation is the state of the -log_backtrace_at flag.
+	traceLocation traceLocation
+	// These flags are modified only under lock, although verbosity may be fetched
+	// safely using atomic.LoadInt32.
+	vmodule   moduleSpec // The state of the -vmodule flag.
+	verbosity Level      // V logging level, the value of the -v flag/
+}
+
+// buffer holds a byte Buffer for reuse. The zero value is ready for use.
+type buffer struct {
+	bytes.Buffer
+	tmp  [64]byte // temporary byte array for creating headers.
+	next *buffer
+}
+
+var logging loggingT
+
+// setVState sets a consistent state for V logging.
+// l.mu is held.
+func (l *loggingT) setVState(verbosity Level, filter []modulePat, setFilter bool) {
+	// Turn verbosity off so V will not fire while we are in transition.
+	logging.verbosity.set(0)
+	// Ditto for filter length.
+	logging.filterLength = 0
+
+	// Set the new filters and wipe the pc->Level map if the filter has changed.
+	if setFilter {
+		logging.vmodule.filter = filter
+		logging.vmap = make(map[uintptr]Level)
+	}
+
+	// Things are consistent now, so enable filtering and verbosity.
+	// They are enabled in order opposite to that in V.
+	atomic.StoreInt32(&logging.filterLength, int32(len(filter)))
+	logging.verbosity.set(verbosity)
+}
+
+// getBuffer returns a new, ready-to-use buffer.
+func (l *loggingT) getBuffer() *buffer {
+	l.freeListMu.Lock()
+	b := l.freeList
+	if b != nil {
+		l.freeList = b.next
+	}
+	l.freeListMu.Unlock()
+	if b == nil {
+		b = new(buffer)
+	} else {
+		b.next = nil
+		b.Reset()
+	}
+	return b
+}
+
+// putBuffer returns a buffer to the free list.
+func (l *loggingT) putBuffer(b *buffer) {
+	if b.Len() >= 256 {
+		// Let big buffers die a natural death.
+		return
+	}
+	l.freeListMu.Lock()
+	b.next = l.freeList
+	l.freeList = b
+	l.freeListMu.Unlock()
+}
+
+var timeNow = time.Now // Stubbed out for testing.
+
+/*
+header formats a log header as defined by the C++ implementation.
+It returns a buffer containing the formatted header.
+
+Log lines have this form:
+    Lmmdd hh:mm:ss.uuuuuu threadid file:line] msg...
+where the fields are defined as follows:
+    L                A single character, representing the log level (eg 'I' for INFO)
+    mm               The month (zero padded; ie May is '05')
+    dd               The day (zero padded)
+    hh:mm:ss.uuuuuu  Time in hours, minutes and fractional seconds
+    threadid         The space-padded thread ID as returned by GetTID()
+    file             The file name
+    line             The line number
+    msg              The user-supplied message
+*/
+func (l *loggingT) header(s severity) *buffer {
+	// Lmmdd hh:mm:ss.uuuuuu threadid file:line]
+	now := timeNow()
+	_, file, line, ok := runtime.Caller(3) // It's always the same number of frames to the user's call.
+	if !ok {
+		file = "???"
+		line = 1
+	} else {
+		slash := strings.LastIndex(file, "/")
+		if slash >= 0 {
+			file = file[slash+1:]
+		}
+	}
+	if line < 0 {
+		line = 0 // not a real line number, but acceptable to someDigits
+	}
+	if s > fatalLog {
+		s = infoLog // for safety.
+	}
+	buf := l.getBuffer()
+
+	// Avoid Fprintf, for speed. The format is so simple that we can do it quickly by hand.
+	// It's worth about 3X. Fprintf is hard.
+	_, month, day := now.Date()
+	hour, minute, second := now.Clock()
+	buf.tmp[0] = severityChar[s]
+	buf.twoDigits(1, int(month))
+	buf.twoDigits(3, day)
+	buf.tmp[5] = ' '
+	buf.twoDigits(6, hour)
+	buf.tmp[8] = ':'
+	buf.twoDigits(9, minute)
+	buf.tmp[11] = ':'
+	buf.twoDigits(12, second)
+	buf.tmp[14] = '.'
+	buf.nDigits(6, 15, now.Nanosecond()/1000)
+	buf.tmp[21] = ' '
+	buf.nDigits(5, 22, pid) // TODO: should be TID
+	buf.tmp[27] = ' '
+	buf.Write(buf.tmp[:28])
+	buf.WriteString(file)
+	buf.tmp[0] = ':'
+	n := buf.someDigits(1, line)
+	buf.tmp[n+1] = ']'
+	buf.tmp[n+2] = ' '
+	buf.Write(buf.tmp[:n+3])
+	return buf
+}
+
+// Some custom tiny helper functions to print the log header efficiently.
+
+const digits = "0123456789"
+
+// twoDigits formats a zero-prefixed two-digit integer at buf.tmp[i].
+func (buf *buffer) twoDigits(i, d int) {
+	buf.tmp[i+1] = digits[d%10]
+	d /= 10
+	buf.tmp[i] = digits[d%10]
+}
+
+// nDigits formats a zero-prefixed n-digit integer at buf.tmp[i].
+func (buf *buffer) nDigits(n, i, d int) {
+	for j := n - 1; j >= 0; j-- {
+		buf.tmp[i+j] = digits[d%10]
+		d /= 10
+	}
+}
+
+// someDigits formats a zero-prefixed variable-width integer at buf.tmp[i].
+func (buf *buffer) someDigits(i, d int) int {
+	// Print into the top, then copy down. We know there's space for at least
+	// a 10-digit number.
+	j := len(buf.tmp)
+	for {
+		j--
+		buf.tmp[j] = digits[d%10]
+		d /= 10
+		if d == 0 {
+			break
+		}
+	}
+	return copy(buf.tmp[i:], buf.tmp[j:])
+}
+
+func (l *loggingT) println(s severity, args ...interface{}) {
+	buf := l.header(s)
+	fmt.Fprintln(buf, args...)
+	l.output(s, buf)
+}
+
+func (l *loggingT) print(s severity, args ...interface{}) {
+	buf := l.header(s)
+	fmt.Fprint(buf, args...)
+	if buf.Bytes()[buf.Len()-1] != '\n' {
+		buf.WriteByte('\n')
+	}
+	l.output(s, buf)
+}
+
+func (l *loggingT) printf(s severity, format string, args ...interface{}) {
+	buf := l.header(s)
+	fmt.Fprintf(buf, format, args...)
+	if buf.Bytes()[buf.Len()-1] != '\n' {
+		buf.WriteByte('\n')
+	}
+	l.output(s, buf)
+}
+
+// output writes the data to the log files and releases the buffer.
+func (l *loggingT) output(s severity, buf *buffer) {
+	l.mu.Lock()
+	if l.traceLocation.isSet() {
+		_, file, line, ok := runtime.Caller(3) // It's always the same number of frames to the user's call (same as header).
+		if ok && l.traceLocation.match(file, line) {
+			buf.Write(stacks(false))
+		}
+	}
+	data := buf.Bytes()
+	if l.logstashType != "" {
+		l.logstashOnce.Do(l.startLogstash)
+		select {
+		case l.logstashChan <- string(data):
+		default:
+			fmt.Fprintln(os.Stderr, "Logstash buffer is full.")
+		}
+	}
+	stderrstring := string(data)
+	if l.color {
+		stderrstring = "" + stderrstring
+		switch s {
+		case fatalLog:
+			stderrstring = "\033[91m\033[1m" + stderrstring
+		case errorLog:
+			stderrstring = "\033[91m" + stderrstring
+		case warningLog:
+			stderrstring = "\033[38;5;208m" + stderrstring
+		case infoLog:
+			stderrstring = "\033[94m" + stderrstring
+		}
+		stderrstring = stderrstring + "\033[0m"
+	}
+	stderrdata := []byte(stderrstring)
+	if l.toStderr {
+		os.Stderr.Write(stderrdata)
+	} else {
+		if l.alsoToStderr || s >= l.stderrThreshold.get() {
+			os.Stderr.Write(stderrdata)
+		}
+		if l.file[s] == nil {
+			if err := l.createFiles(s); err != nil {
+				os.Stderr.Write(stderrdata) // Make sure the message appears somewhere.
+				l.exit(err)
+			}
+		}
+		switch s {
+		case fatalLog:
+			l.file[fatalLog].Write(data)
+			fallthrough
+		case errorLog:
+			l.file[errorLog].Write(data)
+			fallthrough
+		case warningLog:
+			l.file[warningLog].Write(data)
+			fallthrough
+		case infoLog:
+			l.file[infoLog].Write(data)
+		}
+	}
+	if s == fatalLog {
+		// Make sure we see the trace for the current goroutine on standard error.
+		if !l.toStderr {
+			os.Stderr.Write(stacks(false))
+		}
+		// Write the stack trace for all goroutines to the files.
+		trace := stacks(true)
+		logExitFunc = func(error) {} // If we get a write error, we'll still exit below.
+		for log := fatalLog; log >= infoLog; log-- {
+			if f := l.file[log]; f != nil { // Can be nil if -logtostderr is set.
+				f.Write(trace)
+			}
+		}
+		l.mu.Unlock()
+		timeoutFlush(10 * time.Second)
+		os.Exit(255) // C++ uses -1, which is silly because it's anded with 255 anyway.
+	}
+	l.putBuffer(buf)
+	l.mu.Unlock()
+	if stats := severityStats[s]; stats != nil {
+		atomic.AddInt64(&stats.lines, 1)
+		atomic.AddInt64(&stats.bytes, int64(len(data)))
+	}
+}
+
+// timeoutFlush calls Flush and returns when it completes or after timeout
+// elapses, whichever happens first.  This is needed because the hooks invoked
+// by Flush may deadlock when glog.Fatal is called from a hook that holds
+// a lock.
+func timeoutFlush(timeout time.Duration) {
+	done := make(chan bool, 1)
+	go func() {
+		Flush() // calls logging.lockAndFlushAll()
+		done <- true
+	}()
+	select {
+	case <-done:
+	case <-time.After(timeout):
+		fmt.Fprintln(os.Stderr, "glog: Flush took longer than", timeout)
+	}
+}
+
+// stacks is a wrapper for runtime.Stack that attempts to recover the data for all goroutines.
+func stacks(all bool) []byte {
+	// We don't know how big the traces are, so grow a few times if they don't fit. Start large, though.
+	n := 10000
+	if all {
+		n = 100000
+	}
+	var trace []byte
+	for i := 0; i < 5; i++ {
+		trace = make([]byte, n)
+		nbytes := runtime.Stack(trace, all)
+		if nbytes < len(trace) {
+			return trace[:nbytes]
+		}
+		n *= 2
+	}
+	return trace
+}
+
+// logExitFunc provides a simple mechanism to override the default behavior
+// of exiting on error. Used in testing and to guarantee we reach a required exit
+// for fatal logs. Instead, exit could be a function rather than a method but that
+// would make its use clumsier.
+var logExitFunc func(error)
+
+// exit is called if there is trouble creating or writing log files.
+// It flushes the logs and exits the program; there's no point in hanging around.
+// l.mu is held.
+func (l *loggingT) exit(err error) {
+	fmt.Fprintf(os.Stderr, "log: exiting because of error: %s\n", err)
+	// If logExitFunc is set, we do that instead of exiting.
+	if logExitFunc != nil {
+		logExitFunc(err)
+		return
+	}
+	l.flushAll()
+	os.Exit(2)
+}
+
+// syncBuffer joins a bufio.Writer to its underlying file, providing access to the
+// file's Sync method and providing a wrapper for the Write method that provides log
+// file rotation. There are conflicting methods, so the file cannot be embedded.
+// l.mu is held for all its methods.
+type syncBuffer struct {
+	logger *loggingT
+	*bufio.Writer
+	file   *os.File
+	sev    severity
+	nbytes uint64 // The number of bytes written to this file
+}
+
+func (sb *syncBuffer) Sync() error {
+	return sb.file.Sync()
+}
+
+func (sb *syncBuffer) Write(p []byte) (n int, err error) {
+	if sb.nbytes+uint64(len(p)) >= MaxSize {
+		if err := sb.rotateFile(time.Now()); err != nil {
+			sb.logger.exit(err)
+		}
+	}
+	n, err = sb.Writer.Write(p)
+	sb.nbytes += uint64(n)
+	if err != nil {
+		sb.logger.exit(err)
+	}
+	return
+}
+
+// rotateFile closes the syncBuffer's file and starts a new one.
+func (sb *syncBuffer) rotateFile(now time.Time) error {
+	if sb.file != nil {
+		sb.Flush()
+		sb.file.Close()
+	}
+	var err error
+	sb.file, _, err = create(severityName[sb.sev], now)
+	sb.nbytes = 0
+	if err != nil {
+		return err
+	}
+
+	sb.Writer = bufio.NewWriterSize(sb.file, bufferSize)
+
+	// Write header.
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "Log file created at: %s\n", now.Format("2006/01/02 15:04:05"))
+	fmt.Fprintf(&buf, "Running on machine: %s\n", host)
+	fmt.Fprintf(&buf, "Binary: Built with %s %s for %s/%s\n", runtime.Compiler, runtime.Version(), runtime.GOOS, runtime.GOARCH)
+	fmt.Fprintf(&buf, "Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu threadid file:line] msg\n")
+	n, err := sb.file.Write(buf.Bytes())
+	sb.nbytes += uint64(n)
+	return err
+}
+
+// bufferSize sizes the buffer associated with each log file. It's large
+// so that log records can accumulate without the logging thread blocking
+// on disk I/O. The flushDaemon will block instead.
+const bufferSize = 256 * 1024
+
+// createFiles creates all the log files for severity from sev down to infoLog.
+// l.mu is held.
+func (l *loggingT) createFiles(sev severity) error {
+	now := time.Now()
+	// Files are created in decreasing severity order, so as soon as we find one
+	// has already been created, we can stop.
+	for s := sev; s >= infoLog && l.file[s] == nil; s-- {
+		sb := &syncBuffer{
+			logger: l,
+			sev:    s,
+		}
+		if err := sb.rotateFile(now); err != nil {
+			return err
+		}
+		l.file[s] = sb
+	}
+	return nil
+}
+
+const flushInterval = 30 * time.Second
+
+// flushDaemon periodically flushes the log file buffers.
+func (l *loggingT) flushDaemon() {
+	for _ = range time.NewTicker(flushInterval).C {
+		l.lockAndFlushAll()
+	}
+}
+
+// lockAndFlushAll is like flushAll but locks l.mu first.
+func (l *loggingT) lockAndFlushAll() {
+	l.mu.Lock()
+	l.flushAll()
+	l.mu.Unlock()
+}
+
+// flushAll flushes all the logs and attempts to "sync" their data to disk.
+// l.mu is held.
+func (l *loggingT) flushAll() {
+	// Flush from fatal down, in case there's trouble flushing.
+	for s := fatalLog; s >= infoLog; s-- {
+		file := l.file[s]
+		if file != nil {
+			file.Flush() // ignore error
+			file.Sync()  // ignore error
+		}
+	}
+}
+
+// setV computes and remembers the V level for a given PC
+// when vmodule is enabled.
+// File pattern matching takes the basename of the file, stripped
+// of its .go suffix, and uses filepath.Match, which is a little more
+// general than the *? matching used in C++.
+// l.mu is held.
+func (l *loggingT) setV(pc uintptr) Level {
+	fn := runtime.FuncForPC(pc)
+	file, _ := fn.FileLine(pc)
+	// The file is something like /a/b/c/d.go. We want just the d.
+	if strings.HasSuffix(file, ".go") {
+		file = file[:len(file)-3]
+	}
+	if slash := strings.LastIndex(file, "/"); slash >= 0 {
+		file = file[slash+1:]
+	}
+	for _, filter := range l.vmodule.filter {
+		if filter.match(file) {
+			l.vmap[pc] = filter.level
+			return filter.level
+		}
+	}
+	l.vmap[pc] = 0
+	return 0
+}
+
+// Verbose is a boolean type that implements Infof (like Printf) etc.
+// See the documentation of V for more information.
+type Verbose bool
+
+// V reports whether verbosity at the call site is at least the requested level.
+// The returned value is a boolean of type Verbose, which implements Info, Infoln
+// and Infof. These methods will write to the Info log if called.
+// Thus, one may write either
+//  if glog.V(2) { glog.Info("log this") }
+// or
+//  glog.V(2).Info("log this")
+// The second form is shorter but the first is cheaper if logging is off because it does
+// not evaluate its arguments.
+//
+// Whether an individual call to V generates a log record depends on the setting of
+// the -v and --vmodule flags; both are off by default. If the level in the call to
+// V is at least the value of -v, or of -vmodule for the source file containing the
+// call, the V call will log.
+func V(level Level) Verbose {
+	// This function tries hard to be cheap unless there's work to do.
+	// The fast path is two atomic loads and compares.
+
+	// Here is a cheap but safe test to see if V logging is enabled globally.
+	if logging.verbosity.get() >= level {
+		return Verbose(true)
+	}
+
+	// It's off globally but it vmodule may still be set.
+	// Here is another cheap but safe test to see if vmodule is enabled.
+	if atomic.LoadInt32(&logging.filterLength) > 0 {
+		// Now we need a proper lock to use the logging structure. The pcs field
+		// is shared so we must lock before accessing it. This is fairly expensive,
+		// but if V logging is enabled we're slow anyway.
+		logging.mu.Lock()
+		defer logging.mu.Unlock()
+		if runtime.Callers(2, logging.pcs[:]) == 0 {
+			return Verbose(false)
+		}
+		v, ok := logging.vmap[logging.pcs[0]]
+		if !ok {
+			v = logging.setV(logging.pcs[0])
+		}
+		return Verbose(v >= level)
+	}
+	return Verbose(false)
+}
+
+// Info is equivalent to the global Info function, guarded by the value of v.
+// See the documentation of V for usage.
+func (v Verbose) Info(args ...interface{}) {
+	if v {
+		logging.print(infoLog, args...)
+	}
+}
+
+// Infoln is equivalent to the global Infoln function, guarded by the value of v.
+// See the documentation of V for usage.
+func (v Verbose) Infoln(args ...interface{}) {
+	if v {
+		logging.println(infoLog, args...)
+	}
+}
+
+// Infof is equivalent to the global Infof function, guarded by the value of v.
+// See the documentation of V for usage.
+func (v Verbose) Infof(format string, args ...interface{}) {
+	if v {
+		logging.printf(infoLog, format, args...)
+	}
+}
+
+// Info logs to the INFO log.
+// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
+func Info(args ...interface{}) {
+	logging.print(infoLog, args...)
+}
+
+// Infoln logs to the INFO log.
+// Arguments are handled in the manner of fmt.Println; a newline is appended if missing.
+func Infoln(args ...interface{}) {
+	logging.println(infoLog, args...)
+}
+
+// Infof logs to the INFO log.
+// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
+func Infof(format string, args ...interface{}) {
+	logging.printf(infoLog, format, args...)
+}
+
+// Warning logs to the WARNING and INFO logs.
+// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
+func Warning(args ...interface{}) {
+	logging.print(warningLog, args...)
+}
+
+// Warningln logs to the WARNING and INFO logs.
+// Arguments are handled in the manner of fmt.Println; a newline is appended if missing.
+func Warningln(args ...interface{}) {
+	logging.println(warningLog, args...)
+}
+
+// Warningf logs to the WARNING and INFO logs.
+// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
+func Warningf(format string, args ...interface{}) {
+	logging.printf(warningLog, format, args...)
+}
+
+// Error logs to the ERROR, WARNING, and INFO logs.
+// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
+func Error(args ...interface{}) {
+	logging.print(errorLog, args...)
+}
+
+// Errorln logs to the ERROR, WARNING, and INFO logs.
+// Arguments are handled in the manner of fmt.Println; a newline is appended if missing.
+func Errorln(args ...interface{}) {
+	logging.println(errorLog, args...)
+}
+
+// Errorf logs to the ERROR, WARNING, and INFO logs.
+// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
+func Errorf(format string, args ...interface{}) {
+	logging.printf(errorLog, format, args...)
+}
+
+// Fatal logs to the FATAL, ERROR, WARNING, and INFO logs,
+// including a stack trace of all running goroutines, then calls os.Exit(255).
+// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
+func Fatal(args ...interface{}) {
+	logging.print(fatalLog, args...)
+}
+
+// Fatalln logs to the FATAL, ERROR, WARNING, and INFO logs,
+// including a stack trace of all running goroutines, then calls os.Exit(255).
+// Arguments are handled in the manner of fmt.Println; a newline is appended if missing.
+func Fatalln(args ...interface{}) {
+	logging.println(fatalLog, args...)
+}
+
+// Fatalf logs to the FATAL, ERROR, WARNING, and INFO logs,
+// including a stack trace of all running goroutines, then calls os.Exit(255).
+// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
+func Fatalf(format string, args ...interface{}) {
+	logging.printf(fatalLog, format, args...)
+}
diff --git a/vendor/github.com/barakmich/glog/glog_file.go b/vendor/github.com/barakmich/glog/glog_file.go
new file mode 100644
index 00000000..8dcb2bc0
--- /dev/null
+++ b/vendor/github.com/barakmich/glog/glog_file.go
@@ -0,0 +1,124 @@
+// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
+//
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// File I/O for logs.
+
+package glog
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// MaxSize is the maximum size of a log file in bytes.
+var MaxSize uint64 = 1024 * 1024 * 1800
+
+// logDirs lists the candidate directories for new log files.
+var logDirs []string
+
+// If non-empty, overrides the choice of directory in which to write logs.
+// See createLogDirs for the full list of possible destinations.
+var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
+
+func createLogDirs() {
+	if *logDir != "" {
+		logDirs = append(logDirs, *logDir)
+	}
+	logDirs = append(logDirs, os.TempDir())
+}
+
+var (
+	pid      = os.Getpid()
+	program  = filepath.Base(os.Args[0])
+	host     = "unknownhost"
+	userName = "unknownuser"
+)
+
+func init() {
+	h, err := os.Hostname()
+	if err == nil {
+		host = shortHostname(h)
+	}
+
+	current, err := user.Current()
+	if err == nil {
+		userName = current.Username
+	}
+
+	// Sanitize userName since it may contain filepath separators on Windows.
+	userName = strings.Replace(userName, `\`, "_", -1)
+}
+
+// shortHostname returns its argument, truncating at the first period.
+// For instance, given "www.google.com" it returns "www".
+func shortHostname(hostname string) string {
+	if i := strings.Index(hostname, "."); i >= 0 {
+		return hostname[:i]
+	}
+	return hostname
+}
+
+// logName returns a new log file name containing tag, with start time t, and
+// the name for the symlink for tag.
+func logName(tag string, t time.Time) (name, link string) {
+	name = fmt.Sprintf("%s.%s.%s.log.%s.%04d%02d%02d-%02d%02d%02d.%d",
+		program,
+		host,
+		userName,
+		tag,
+		t.Year(),
+		t.Month(),
+		t.Day(),
+		t.Hour(),
+		t.Minute(),
+		t.Second(),
+		pid)
+	return name, program + "." + tag
+}
+
+var onceLogDirs sync.Once
+
+// create creates a new log file and returns the file and its filename, which
+// contains tag ("INFO", "FATAL", etc.) and t.  If the file is created
+// successfully, create also attempts to update the symlink for that tag, ignoring
+// errors.
+func create(tag string, t time.Time) (f *os.File, filename string, err error) {
+	onceLogDirs.Do(createLogDirs)
+	if len(logDirs) == 0 {
+		return nil, "", errors.New("log: no log dirs")
+	}
+	name, link := logName(tag, t)
+	var lastErr error
+	for _, dir := range logDirs {
+		fname := filepath.Join(dir, name)
+		f, err := os.Create(fname)
+		if err == nil {
+			symlink := filepath.Join(dir, link)
+			os.Remove(symlink)         // ignore err
+			os.Symlink(fname, symlink) // ignore err
+			return f, fname, nil
+		}
+		lastErr = err
+	}
+	return nil, "", fmt.Errorf("log: cannot create log: %v", lastErr)
+}
diff --git a/vendor/github.com/barakmich/glog/glog_logstash.go b/vendor/github.com/barakmich/glog/glog_logstash.go
new file mode 100644
index 00000000..8725f5b1
--- /dev/null
+++ b/vendor/github.com/barakmich/glog/glog_logstash.go
@@ -0,0 +1,71 @@
+package glog
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+	"time"
+)
+
+type logstashMessage struct {
+	Type    string `json:"type"`
+	Message string `json:"message"`
+}
+
+// handleLogstashMessages sends logs to logstash.
+func (l *loggingT) handleLogstashMessages() {
+	var conn net.Conn
+	ticker := time.Tick(1 * time.Second)
+	for {
+		select {
+		case _ = <-l.logstashStop:
+			conn.Close()
+			return
+		case _ = <-ticker:
+			var err error
+			if conn == nil {
+				fmt.Fprintln(os.Stderr, "Trying to connect to logstash server...")
+				conn, err = net.Dial("tcp", l.logstashURL)
+				if err != nil {
+					conn = nil
+				} else {
+					fmt.Fprintln(os.Stderr, "Connected to logstash server.")
+				}
+			}
+		case data := <-l.logstashChan:
+			lm := logstashMessage{}
+			lm.Type = l.logstashType
+			lm.Message = strings.TrimSpace(data)
+			packet, err := json.Marshal(lm)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, "Failed to marshal logstashMessage.")
+				continue
+			}
+			if conn != nil {
+				_, err := fmt.Fprintln(conn, string(packet))
+				if err != nil {
+					fmt.Fprintln(os.Stderr, "Not connected to logstash server, attempting reconnect.")
+					conn = nil
+					continue
+				}
+			} else {
+				// There is no connection, so the log line is dropped.
+				// Might be nice to add a buffer here so that we can ship
+				// logs after the connection is up.
+			}
+		}
+	}
+}
+
+// StartLogstash creates the logstash channel and kicks off handleLogstashMessages.
+func (l *loggingT) startLogstash() {
+	l.logstashChan = make(chan string, 100)
+	go l.handleLogstashMessages()
+}
+
+// StopLogstash signals handleLogstashMessages to exit.
+func (l *loggingT) StopLogstash() {
+	l.logstashStop <- true
+}
diff --git a/vendor/github.com/boltdb/bolt/.gitignore b/vendor/github.com/boltdb/bolt/.gitignore
new file mode 100644
index 00000000..b2bb382b
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/.gitignore
@@ -0,0 +1,3 @@
+*.prof
+*.test
+/bin/
diff --git a/vendor/github.com/boltdb/bolt/LICENSE b/vendor/github.com/boltdb/bolt/LICENSE
new file mode 100644
index 00000000..004e77fe
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Ben Johnson
+
+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.
diff --git a/vendor/github.com/boltdb/bolt/Makefile b/vendor/github.com/boltdb/bolt/Makefile
new file mode 100644
index 00000000..cfbed514
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/Makefile
@@ -0,0 +1,54 @@
+TEST=.
+BENCH=.
+COVERPROFILE=/tmp/c.out
+BRANCH=`git rev-parse --abbrev-ref HEAD`
+COMMIT=`git rev-parse --short HEAD`
+GOLDFLAGS="-X main.branch $(BRANCH) -X main.commit $(COMMIT)"
+
+default: build
+
+bench:
+	go test -v -test.run=NOTHINCONTAINSTHIS -test.bench=$(BENCH)
+
+# http://cloc.sourceforge.net/
+cloc:
+	@cloc --not-match-f='Makefile|_test.go' .
+
+cover: fmt
+	go test -coverprofile=$(COVERPROFILE) -test.run=$(TEST) $(COVERFLAG) .
+	go tool cover -html=$(COVERPROFILE)
+	rm $(COVERPROFILE)
+
+cpuprofile: fmt
+	@go test -c
+	@./bolt.test -test.v -test.run=$(TEST) -test.cpuprofile cpu.prof
+
+# go get github.com/kisielk/errcheck
+errcheck:
+	@echo "=== errcheck ==="
+	@errcheck github.com/boltdb/bolt
+
+fmt:
+	@go fmt ./...
+
+get:
+	@go get -d ./...
+
+build: get
+	@mkdir -p bin
+	@go build -ldflags=$(GOLDFLAGS) -a -o bin/bolt ./cmd/bolt
+
+test: fmt
+	@go get github.com/stretchr/testify/assert
+	@echo "=== TESTS ==="
+	@go test -v -cover -test.run=$(TEST)
+	@echo ""
+	@echo ""
+	@echo "=== CLI ==="
+	@go test -v -test.run=$(TEST) ./cmd/bolt
+	@echo ""
+	@echo ""
+	@echo "=== RACE DETECTOR ==="
+	@go test -v -race -test.run="TestSimulate_(100op|1000op)"
+
+.PHONY: bench cloc cover cpuprofile fmt memprofile test
diff --git a/vendor/github.com/boltdb/bolt/README.md b/vendor/github.com/boltdb/bolt/README.md
new file mode 100644
index 00000000..be392caf
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/README.md
@@ -0,0 +1,619 @@
+Bolt [![Build Status](https://drone.io/github.com/boltdb/bolt/status.png)](https://drone.io/github.com/boltdb/bolt/latest) [![Coverage Status](https://coveralls.io/repos/boltdb/bolt/badge.png?branch=master)](https://coveralls.io/r/boltdb/bolt?branch=master) [![GoDoc](https://godoc.org/github.com/boltdb/bolt?status.png)](https://godoc.org/github.com/boltdb/bolt) ![Version](http://img.shields.io/badge/version-1.0-green.png)
+====
+
+Bolt is a pure Go key/value store inspired by [Howard Chu's][hyc_symas] and
+the [LMDB project][lmdb]. The goal of the project is to provide a simple,
+fast, and reliable database for projects that don't require a full database
+server such as Postgres or MySQL.
+
+Since Bolt is meant to be used as such a low-level piece of functionality,
+simplicity is key. The API will be small and only focus on getting values
+and setting values. That's it.
+
+[hyc_symas]: https://twitter.com/hyc_symas
+[lmdb]: http://symas.com/mdb/
+
+
+## Project Status
+
+Bolt is stable and the API is fixed. Full unit test coverage and randomized
+black box testing are used to ensure database consistency and thread safety.
+Bolt is currently in high-load production environments serving databases as
+large as 1TB. Many companies such as Shopify and Heroku use Bolt-backed
+services every day.
+
+
+## Getting Started
+
+### Installing
+
+To start using Bolt, install Go and run `go get`:
+
+```sh
+$ go get github.com/boltdb/bolt/...
+```
+
+This will retrieve the library and install the `bolt` command line utility into
+your `$GOBIN` path.
+
+
+### Opening a database
+
+The top-level object in Bolt is a `DB`. It is represented as a single file on
+your disk and represents a consistent snapshot of your data.
+
+To open your database, simply use the `bolt.Open()` function:
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/boltdb/bolt"
+)
+
+func main() {
+	// Open the my.db data file in your current directory.
+	// It will be created if it doesn't exist.
+	db, err := bolt.Open("my.db", 0600, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	...
+}
+```
+
+Please note that Bolt obtains a file lock on the data file so multiple processes
+cannot open the same database at the same time. Opening an already open Bolt
+database will cause it to hang until the other process closes it. To prevent
+an indefinite wait you can pass a timeout option to the `Open()` function:
+
+```go
+db, err := bolt.Open("my.db", 0600, &bolt.Options{Timeout: 1 * time.Second})
+```
+
+
+### Transactions
+
+Bolt allows only one read-write transaction at a time but allows as many
+read-only transactions as you want at a time. Each transaction has a consistent
+view of the data as it existed when the transaction started.
+
+Individual transactions and all objects created from them (e.g. buckets, keys)
+are not thread safe. To work with data in multiple goroutines you must start
+a transaction for each one or use locking to ensure only one goroutine accesses
+a transaction at a time. Creating transaction from the `DB` is thread safe.
+
+Read-only transactions and read-write transactions should not depend on one
+another and generally shouldn't be opened simultaneously in the same goroutine.
+This can cause a deadlock as the read-write transaction needs to periodically
+re-map the data file but it cannot do so while a read-only transaction is open.
+
+
+#### Read-write transactions
+
+To start a read-write transaction, you can use the `DB.Update()` function:
+
+```go
+err := db.Update(func(tx *bolt.Tx) error {
+	...
+	return nil
+})
+```
+
+Inside the closure, you have a consistent view of the database. You commit the
+transaction by returning `nil` at the end. You can also rollback the transaction
+at any point by returning an error. All database operations are allowed inside
+a read-write transaction.
+
+Always check the return error as it will report any disk failures that can cause
+your transaction to not complete. If you return an error within your closure
+it will be passed through.
+
+
+#### Read-only transactions
+
+To start a read-only transaction, you can use the `DB.View()` function:
+
+```go
+err := db.View(func(tx *bolt.Tx) error {
+	...
+	return nil
+})
+```
+
+You also get a consistent view of the database within this closure, however,
+no mutating operations are allowed within a read-only transaction. You can only
+retrieve buckets, retrieve values, and copy the database within a read-only
+transaction.
+
+
+#### Batch read-write transactions
+
+Each `DB.Update()` waits for disk to commit the writes. This overhead
+can be minimized by combining multiple updates with the `DB.Batch()`
+function:
+
+```go
+err := db.Batch(func(tx *bolt.Tx) error {
+	...
+	return nil
+})
+```
+
+Concurrent Batch calls are opportunistically combined into larger
+transactions. Batch is only useful when there are multiple goroutines
+calling it.
+
+The trade-off is that `Batch` can call the given
+function multiple times, if parts of the transaction fail. The
+function must be idempotent and side effects must take effect only
+after a successful return from `DB.Batch()`.
+
+For example: don't display messages from inside the function, instead
+set variables in the enclosing scope:
+
+```go
+var id uint64
+err := db.Batch(func(tx *bolt.Tx) error {
+	// Find last key in bucket, decode as bigendian uint64, increment
+	// by one, encode back to []byte, and add new key.
+	...
+	id = newValue
+	return nil
+})
+if err != nil {
+	return ...
+}
+fmt.Println("Allocated ID %d", id)
+```
+
+
+#### Managing transactions manually
+
+The `DB.View()` and `DB.Update()` functions are wrappers around the `DB.Begin()`
+function. These helper functions will start the transaction, execute a function,
+and then safely close your transaction if an error is returned. This is the
+recommended way to use Bolt transactions.
+
+However, sometimes you may want to manually start and end your transactions.
+You can use the `Tx.Begin()` function directly but _please_ be sure to close the
+transaction.
+
+```go
+// Start a writable transaction.
+tx, err := db.Begin(true)
+if err != nil {
+    return err
+}
+defer tx.Rollback()
+
+// Use the transaction...
+_, err := tx.CreateBucket([]byte("MyBucket"))
+if err != nil {
+    return err
+}
+
+// Commit the transaction and check for error.
+if err := tx.Commit(); err != nil {
+    return err
+}
+```
+
+The first argument to `DB.Begin()` is a boolean stating if the transaction
+should be writable.
+
+
+### Using buckets
+
+Buckets are collections of key/value pairs within the database. All keys in a
+bucket must be unique. You can create a bucket using the `DB.CreateBucket()`
+function:
+
+```go
+db.Update(func(tx *bolt.Tx) error {
+	b, err := tx.CreateBucket([]byte("MyBucket"))
+	if err != nil {
+		return fmt.Errorf("create bucket: %s", err)
+	}
+	return nil
+})
+```
+
+You can also create a bucket only if it doesn't exist by using the
+`Tx.CreateBucketIfNotExists()` function. It's a common pattern to call this
+function for all your top-level buckets after you open your database so you can
+guarantee that they exist for future transactions.
+
+To delete a bucket, simply call the `Tx.DeleteBucket()` function.
+
+
+### Using key/value pairs
+
+To save a key/value pair to a bucket, use the `Bucket.Put()` function:
+
+```go
+db.Update(func(tx *bolt.Tx) error {
+	b := tx.Bucket([]byte("MyBucket"))
+	err := b.Put([]byte("answer"), []byte("42"))
+	return err
+})
+```
+
+This will set the value of the `"answer"` key to `"42"` in the `MyBucket`
+bucket. To retrieve this value, we can use the `Bucket.Get()` function:
+
+```go
+db.View(func(tx *bolt.Tx) error {
+	b := tx.Bucket([]byte("MyBucket"))
+	v := b.Get([]byte("answer"))
+	fmt.Printf("The answer is: %s\n", v)
+	return nil
+})
+```
+
+The `Get()` function does not return an error because its operation is
+guarenteed to work (unless there is some kind of system failure). If the key
+exists then it will return its byte slice value. If it doesn't exist then it
+will return `nil`. It's important to note that you can have a zero-length value
+set to a key which is different than the key not existing.
+
+Use the `Bucket.Delete()` function to delete a key from the bucket.
+
+Please note that values returned from `Get()` are only valid while the
+transaction is open. If you need to use a value outside of the transaction
+then you must use `copy()` to copy it to another byte slice.
+
+
+### Iterating over keys
+
+Bolt stores its keys in byte-sorted order within a bucket. This makes sequential
+iteration over these keys extremely fast. To iterate over keys we'll use a
+`Cursor`:
+
+```go
+db.View(func(tx *bolt.Tx) error {
+	b := tx.Bucket([]byte("MyBucket"))
+	c := b.Cursor()
+
+	for k, v := c.First(); k != nil; k, v = c.Next() {
+		fmt.Printf("key=%s, value=%s\n", k, v)
+	}
+
+	return nil
+})
+```
+
+The cursor allows you to move to a specific point in the list of keys and move
+forward or backward through the keys one at a time.
+
+The following functions are available on the cursor:
+
+```
+First()  Move to the first key.
+Last()   Move to the last key.
+Seek()   Move to a specific key.
+Next()   Move to the next key.
+Prev()   Move to the previous key.
+```
+
+When you have iterated to the end of the cursor then `Next()` will return `nil`.
+You must seek to a position using `First()`, `Last()`, or `Seek()` before
+calling `Next()` or `Prev()`. If you do not seek to a position then these
+functions will return `nil`.
+
+
+#### Prefix scans
+
+To iterate over a key prefix, you can combine `Seek()` and `bytes.HasPrefix()`:
+
+```go
+db.View(func(tx *bolt.Tx) error {
+	c := tx.Bucket([]byte("MyBucket")).Cursor()
+
+	prefix := []byte("1234")
+	for k, v := c.Seek(prefix); bytes.HasPrefix(k, prefix); k, v = c.Next() {
+		fmt.Printf("key=%s, value=%s\n", k, v)
+	}
+
+	return nil
+})
+```
+
+#### Range scans
+
+Another common use case is scanning over a range such as a time range. If you
+use a sortable time encoding such as RFC3339 then you can query a specific
+date range like this:
+
+```go
+db.View(func(tx *bolt.Tx) error {
+	// Assume our events bucket has RFC3339 encoded time keys.
+	c := tx.Bucket([]byte("Events")).Cursor()
+
+	// Our time range spans the 90's decade.
+	min := []byte("1990-01-01T00:00:00Z")
+	max := []byte("2000-01-01T00:00:00Z")
+
+	// Iterate over the 90's.
+	for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() {
+		fmt.Printf("%s: %s\n", k, v)
+	}
+
+	return nil
+})
+```
+
+
+#### ForEach()
+
+You can also use the function `ForEach()` if you know you'll be iterating over
+all the keys in a bucket:
+
+```go
+db.View(func(tx *bolt.Tx) error {
+	b := tx.Bucket([]byte("MyBucket"))
+	b.ForEach(func(k, v []byte) error {
+		fmt.Printf("key=%s, value=%s\n", k, v)
+		return nil
+	})
+	return nil
+})
+```
+
+
+### Nested buckets
+
+You can also store a bucket in a key to create nested buckets. The API is the
+same as the bucket management API on the `DB` object:
+
+```go
+func (*Bucket) CreateBucket(key []byte) (*Bucket, error)
+func (*Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error)
+func (*Bucket) DeleteBucket(key []byte) error
+```
+
+
+### Database backups
+
+Bolt is a single file so it's easy to backup. You can use the `Tx.WriteTo()`
+function to write a consistent view of the database to a writer. If you call
+this from a read-only transaction, it will perform a hot backup and not block
+your other database reads and writes. It will also use `O_DIRECT` when available
+to prevent page cache trashing.
+
+One common use case is to backup over HTTP so you can use tools like `cURL` to
+do database backups:
+
+```go
+func BackupHandleFunc(w http.ResponseWriter, req *http.Request) {
+	err := db.View(func(tx *bolt.Tx) error {
+		w.Header().Set("Content-Type", "application/octet-stream")
+		w.Header().Set("Content-Disposition", `attachment; filename="my.db"`)
+		w.Header().Set("Content-Length", strconv.Itoa(int(tx.Size())))
+		_, err := tx.WriteTo(w)
+		return err
+	})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+```
+
+Then you can backup using this command:
+
+```sh
+$ curl http://localhost/backup > my.db
+```
+
+Or you can open your browser to `http://localhost/backup` and it will download
+automatically.
+
+If you want to backup to another file you can use the `Tx.CopyFile()` helper
+function.
+
+
+### Statistics
+
+The database keeps a running count of many of the internal operations it
+performs so you can better understand what's going on. By grabbing a snapshot
+of these stats at two points in time we can see what operations were performed
+in that time range.
+
+For example, we could start a goroutine to log stats every 10 seconds:
+
+```go
+go func() {
+	// Grab the initial stats.
+	prev := db.Stats()
+
+	for {
+		// Wait for 10s.
+		time.Sleep(10 * time.Second)
+
+		// Grab the current stats and diff them.
+		stats := db.Stats()
+		diff := stats.Sub(&prev)
+
+		// Encode stats to JSON and print to STDERR.
+		json.NewEncoder(os.Stderr).Encode(diff)
+
+		// Save stats for the next loop.
+		prev = stats
+	}
+}()
+```
+
+It's also useful to pipe these stats to a service such as statsd for monitoring
+or to provide an HTTP endpoint that will perform a fixed-length sample.
+
+
+### Read-Only Mode
+
+Sometimes it is useful to create a shared, read-only Bolt database. To this,
+set the `Options.ReadOnly` flag when opening your database. Read-only mode
+uses a shared lock to allow multiple processes to read from the database but
+it will block any processes from opening the database in read-write mode.
+
+```go
+db, err := bolt.Open("my.db", 0666, &bolt.Options{ReadOnly: true})
+if err != nil {
+	log.Fatal(err)
+}
+```
+
+
+## Resources
+
+For more information on getting started with Bolt, check out the following articles:
+
+* [Intro to BoltDB: Painless Performant Persistence](http://npf.io/2014/07/intro-to-boltdb-painless-performant-persistence/) by [Nate Finch](https://github.com/natefinch).
+* [Bolt -- an embedded key/value database for Go](https://www.progville.com/go/bolt-embedded-db-golang/) by Progville
+
+
+## Comparison with other databases
+
+### Postgres, MySQL, & other relational databases
+
+Relational databases structure data into rows and are only accessible through
+the use of SQL. This approach provides flexibility in how you store and query
+your data but also incurs overhead in parsing and planning SQL statements. Bolt
+accesses all data by a byte slice key. This makes Bolt fast to read and write
+data by key but provides no built-in support for joining values together.
+
+Most relational databases (with the exception of SQLite) are standalone servers
+that run separately from your application. This gives your systems
+flexibility to connect multiple application servers to a single database
+server but also adds overhead in serializing and transporting data over the
+network. Bolt runs as a library included in your application so all data access
+has to go through your application's process. This brings data closer to your
+application but limits multi-process access to the data.
+
+
+### LevelDB, RocksDB
+
+LevelDB and its derivatives (RocksDB, HyperLevelDB) are similar to Bolt in that
+they are libraries bundled into the application, however, their underlying
+structure is a log-structured merge-tree (LSM tree). An LSM tree optimizes
+random writes by using a write ahead log and multi-tiered, sorted files called
+SSTables. Bolt uses a B+tree internally and only a single file. Both approaches
+have trade offs.
+
+If you require a high random write throughput (>10,000 w/sec) or you need to use
+spinning disks then LevelDB could be a good choice. If your application is
+read-heavy or does a lot of range scans then Bolt could be a good choice.
+
+One other important consideration is that LevelDB does not have transactions.
+It supports batch writing of key/values pairs and it supports read snapshots
+but it will not give you the ability to do a compare-and-swap operation safely.
+Bolt supports fully serializable ACID transactions.
+
+
+### LMDB
+
+Bolt was originally a port of LMDB so it is architecturally similar. Both use
+a B+tree, have ACID semantics with fully serializable transactions, and support
+lock-free MVCC using a single writer and multiple readers.
+
+The two projects have somewhat diverged. LMDB heavily focuses on raw performance
+while Bolt has focused on simplicity and ease of use. For example, LMDB allows
+several unsafe actions such as direct writes for the sake of performance. Bolt
+opts to disallow actions which can leave the database in a corrupted state. The
+only exception to this in Bolt is `DB.NoSync`.
+
+There are also a few differences in API. LMDB requires a maximum mmap size when
+opening an `mdb_env` whereas Bolt will handle incremental mmap resizing
+automatically. LMDB overloads the getter and setter functions with multiple
+flags whereas Bolt splits these specialized cases into their own functions.
+
+
+## Caveats & Limitations
+
+It's important to pick the right tool for the job and Bolt is no exception.
+Here are a few things to note when evaluating and using Bolt:
+
+* Bolt is good for read intensive workloads. Sequential write performance is
+  also fast but random writes can be slow. You can add a write-ahead log or
+  [transaction coalescer](https://github.com/boltdb/coalescer) in front of Bolt
+  to mitigate this issue.
+
+* Bolt uses a B+tree internally so there can be a lot of random page access.
+  SSDs provide a significant performance boost over spinning disks.
+
+* Try to avoid long running read transactions. Bolt uses copy-on-write so
+  old pages cannot be reclaimed while an old transaction is using them.
+
+* Byte slices returned from Bolt are only valid during a transaction. Once the
+  transaction has been committed or rolled back then the memory they point to
+  can be reused by a new page or can be unmapped from virtual memory and you'll
+  see an `unexpected fault address` panic when accessing it.
+
+* Be careful when using `Bucket.FillPercent`. Setting a high fill percent for
+  buckets that have random inserts will cause your database to have very poor
+  page utilization.
+
+* Use larger buckets in general. Smaller buckets causes poor page utilization
+  once they become larger than the page size (typically 4KB).
+
+* Bulk loading a lot of random writes into a new bucket can be slow as the
+  page will not split until the transaction is committed. Randomly inserting
+  more than 100,000 key/value pairs into a single new bucket in a single
+  transaction is not advised.
+
+* Bolt uses a memory-mapped file so the underlying operating system handles the
+  caching of the data. Typically, the OS will cache as much of the file as it
+  can in memory and will release memory as needed to other processes. This means
+  that Bolt can show very high memory usage when working with large databases.
+  However, this is expected and the OS will release memory as needed. Bolt can
+  handle databases much larger than the available physical RAM.
+
+* The data structures in the Bolt database are memory mapped so the data file
+  will be endian specific. This means that you cannot copy a Bolt file from a
+  little endian machine to a big endian machine and have it work. For most 
+  users this is not a concern since most modern CPUs are little endian.
+
+* Because of the way pages are laid out on disk, Bolt cannot truncate data files
+  and return free pages back to the disk. Instead, Bolt maintains a free list
+  of unused pages within its data file. These free pages can be reused by later
+  transactions. This works well for many use cases as databases generally tend
+  to grow. However, it's important to note that deleting large chunks of data
+  will not allow you to reclaim that space on disk.
+
+  For more information on page allocation, [see this comment][page-allocation].
+
+[page-allocation]: https://github.com/boltdb/bolt/issues/308#issuecomment-74811638
+
+
+## Other Projects Using Bolt
+
+Below is a list of public, open source projects that use Bolt:
+
+* [Operation Go: A Routine Mission](http://gocode.io) - An online programming game for Golang using Bolt for user accounts and a leaderboard.
+* [Bazil](https://github.com/bazillion/bazil) - A file system that lets your data reside where it is most convenient for it to reside.
+* [DVID](https://github.com/janelia-flyem/dvid) - Added Bolt as optional storage engine and testing it against Basho-tuned leveldb.
+* [Skybox Analytics](https://github.com/skybox/skybox) - A standalone funnel analysis tool for web analytics.
+* [Scuttlebutt](https://github.com/benbjohnson/scuttlebutt) - Uses Bolt to store and process all Twitter mentions of GitHub projects.
+* [Wiki](https://github.com/peterhellberg/wiki) - A tiny wiki using Goji, BoltDB and Blackfriday.
+* [ChainStore](https://github.com/nulayer/chainstore) - Simple key-value interface to a variety of storage engines organized as a chain of operations.
+* [MetricBase](https://github.com/msiebuhr/MetricBase) - Single-binary version of Graphite.
+* [Gitchain](https://github.com/gitchain/gitchain) - Decentralized, peer-to-peer Git repositories aka "Git meets Bitcoin".
+* [event-shuttle](https://github.com/sclasen/event-shuttle) - A Unix system service to collect and reliably deliver messages to Kafka.
+* [ipxed](https://github.com/kelseyhightower/ipxed) - Web interface and api for ipxed.
+* [BoltStore](https://github.com/yosssi/boltstore) - Session store using Bolt.
+* [photosite/session](http://godoc.org/bitbucket.org/kardianos/photosite/session) - Sessions for a photo viewing site.
+* [LedisDB](https://github.com/siddontang/ledisdb) - A high performance NoSQL, using Bolt as optional storage.
+* [ipLocator](https://github.com/AndreasBriese/ipLocator) - A fast ip-geo-location-server using bolt with bloom filters.
+* [cayley](https://github.com/google/cayley) - Cayley is an open-source graph database using Bolt as optional backend.
+* [bleve](http://www.blevesearch.com/) - A pure Go search engine similar to ElasticSearch that uses Bolt as the default storage backend.
+* [tentacool](https://github.com/optiflows/tentacool) - REST api server to manage system stuff (IP, DNS, Gateway...) on a linux server.
+* [SkyDB](https://github.com/skydb/sky) - Behavioral analytics database.
+* [Seaweed File System](https://github.com/chrislusf/weed-fs) - Highly scalable distributed key~file system with O(1) disk read.
+* [InfluxDB](http://influxdb.com) - Scalable datastore for metrics, events, and real-time analytics.
+* [Freehold](http://tshannon.bitbucket.org/freehold/) - An open, secure, and lightweight platform for your files and data.
+* [Prometheus Annotation Server](https://github.com/oliver006/prom_annotation_server) - Annotation server for PromDash & Prometheus service monitoring system.
+* [Consul](https://github.com/hashicorp/consul) - Consul is service discovery and configuration made easy. Distributed, highly available, and datacenter-aware.
+
+If you are using Bolt in a project please send a pull request to add it to the list.
diff --git a/vendor/github.com/boltdb/bolt/batch.go b/vendor/github.com/boltdb/bolt/batch.go
new file mode 100644
index 00000000..bef1f4aa
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/batch.go
@@ -0,0 +1,135 @@
+package bolt
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// Batch calls fn as part of a batch. It behaves similar to Update,
+// except:
+//
+// 1. concurrent Batch calls can be combined into a single Bolt
+// transaction.
+//
+// 2. the function passed to Batch may be called multiple times,
+// regardless of whether it returns error or not.
+//
+// This means that Batch function side effects must be idempotent and
+// take permanent effect only after a successful return is seen in
+// caller.
+//
+// Batch is only useful when there are multiple goroutines calling it.
+func (db *DB) Batch(fn func(*Tx) error) error {
+	errCh := make(chan error, 1)
+
+	db.batchMu.Lock()
+	if (db.batch == nil) || (db.batch != nil && len(db.batch.calls) >= db.MaxBatchSize) {
+		// There is no existing batch, or the existing batch is full; start a new one.
+		db.batch = &batch{
+			db: db,
+		}
+		db.batch.timer = time.AfterFunc(db.MaxBatchDelay, db.batch.trigger)
+	}
+	db.batch.calls = append(db.batch.calls, call{fn: fn, err: errCh})
+	if len(db.batch.calls) >= db.MaxBatchSize {
+		// wake up batch, it's ready to run
+		go db.batch.trigger()
+	}
+	db.batchMu.Unlock()
+
+	err := <-errCh
+	if err == trySolo {
+		err = db.Update(fn)
+	}
+	return err
+}
+
+type call struct {
+	fn  func(*Tx) error
+	err chan<- error
+}
+
+type batch struct {
+	db    *DB
+	timer *time.Timer
+	start sync.Once
+	calls []call
+}
+
+// trigger runs the batch if it hasn't already been run.
+func (b *batch) trigger() {
+	b.start.Do(b.run)
+}
+
+// run performs the transactions in the batch and communicates results
+// back to DB.Batch.
+func (b *batch) run() {
+	b.db.batchMu.Lock()
+	b.timer.Stop()
+	// Make sure no new work is added to this batch, but don't break
+	// other batches.
+	if b.db.batch == b {
+		b.db.batch = nil
+	}
+	b.db.batchMu.Unlock()
+
+retry:
+	for len(b.calls) > 0 {
+		var failIdx = -1
+		err := b.db.Update(func(tx *Tx) error {
+			for i, c := range b.calls {
+				if err := safelyCall(c.fn, tx); err != nil {
+					failIdx = i
+					return err
+				}
+			}
+			return nil
+		})
+
+		if failIdx >= 0 {
+			// take the failing transaction out of the batch. it's
+			// safe to shorten b.calls here because db.batch no longer
+			// points to us, and we hold the mutex anyway.
+			c := b.calls[failIdx]
+			b.calls[failIdx], b.calls = b.calls[len(b.calls)-1], b.calls[:len(b.calls)-1]
+			// tell the submitter re-run it solo, continue with the rest of the batch
+			c.err <- trySolo
+			continue retry
+		}
+
+		// pass success, or bolt internal errors, to all callers
+		for _, c := range b.calls {
+			if c.err != nil {
+				c.err <- err
+			}
+		}
+		break retry
+	}
+}
+
+// trySolo is a special sentinel error value used for signaling that a
+// transaction function should be re-run. It should never be seen by
+// callers.
+var trySolo = errors.New("batch function returned an error and should be re-run solo")
+
+type panicked struct {
+	reason interface{}
+}
+
+func (p panicked) Error() string {
+	if err, ok := p.reason.(error); ok {
+		return err.Error()
+	}
+	return fmt.Sprintf("panic: %v", p.reason)
+}
+
+func safelyCall(fn func(*Tx) error, tx *Tx) (err error) {
+	defer func() {
+		if p := recover(); p != nil {
+			err = panicked{p}
+		}
+	}()
+	return fn(tx)
+}
diff --git a/vendor/github.com/boltdb/bolt/bolt_386.go b/vendor/github.com/boltdb/bolt/bolt_386.go
new file mode 100644
index 00000000..e659bfb9
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_386.go
@@ -0,0 +1,7 @@
+package bolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0x7FFFFFFF // 2GB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0xFFFFFFF
diff --git a/vendor/github.com/boltdb/bolt/bolt_amd64.go b/vendor/github.com/boltdb/bolt/bolt_amd64.go
new file mode 100644
index 00000000..cca6b7eb
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_amd64.go
@@ -0,0 +1,7 @@
+package bolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0xFFFFFFFFFFFF // 256TB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0x7FFFFFFF
diff --git a/vendor/github.com/boltdb/bolt/bolt_arm.go b/vendor/github.com/boltdb/bolt/bolt_arm.go
new file mode 100644
index 00000000..e659bfb9
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_arm.go
@@ -0,0 +1,7 @@
+package bolt
+
+// maxMapSize represents the largest mmap size supported by Bolt.
+const maxMapSize = 0x7FFFFFFF // 2GB
+
+// maxAllocSize is the size used when creating array pointers.
+const maxAllocSize = 0xFFFFFFF
diff --git a/vendor/github.com/boltdb/bolt/bolt_linux.go b/vendor/github.com/boltdb/bolt/bolt_linux.go
new file mode 100644
index 00000000..e9d1c907
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_linux.go
@@ -0,0 +1,12 @@
+package bolt
+
+import (
+	"syscall"
+)
+
+var odirect = syscall.O_DIRECT
+
+// fdatasync flushes written data to a file descriptor.
+func fdatasync(db *DB) error {
+	return syscall.Fdatasync(int(db.file.Fd()))
+}
diff --git a/vendor/github.com/boltdb/bolt/bolt_openbsd.go b/vendor/github.com/boltdb/bolt/bolt_openbsd.go
new file mode 100644
index 00000000..7c1bef1a
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_openbsd.go
@@ -0,0 +1,29 @@
+package bolt
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+const (
+	msAsync      = 1 << iota // perform asynchronous writes
+	msSync                   // perform synchronous writes
+	msInvalidate             // invalidate cached data
+)
+
+var odirect int
+
+func msync(db *DB) error {
+	_, _, errno := syscall.Syscall(syscall.SYS_MSYNC, uintptr(unsafe.Pointer(db.data)), uintptr(db.datasz), msInvalidate)
+	if errno != 0 {
+		return errno
+	}
+	return nil
+}
+
+func fdatasync(db *DB) error {
+	if db.data != nil {
+		return msync(db)
+	}
+	return db.file.Sync()
+}
diff --git a/vendor/github.com/boltdb/bolt/bolt_unix.go b/vendor/github.com/boltdb/bolt/bolt_unix.go
new file mode 100644
index 00000000..266222a7
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_unix.go
@@ -0,0 +1,86 @@
+// +build !windows,!plan9
+
+package bolt
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// flock acquires an advisory lock on a file descriptor.
+func flock(f *os.File, exclusive bool, timeout time.Duration) error {
+	var t time.Time
+	for {
+		// If we're beyond our timeout then return an error.
+		// This can only occur after we've attempted a flock once.
+		if t.IsZero() {
+			t = time.Now()
+		} else if timeout > 0 && time.Since(t) > timeout {
+			return ErrTimeout
+		}
+		flag := syscall.LOCK_SH
+		if exclusive {
+			flag = syscall.LOCK_EX
+		}
+
+		// Otherwise attempt to obtain an exclusive lock.
+		err := syscall.Flock(int(f.Fd()), flag|syscall.LOCK_NB)
+		if err == nil {
+			return nil
+		} else if err != syscall.EWOULDBLOCK {
+			return err
+		}
+
+		// Wait for a bit and try again.
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// funlock releases an advisory lock on a file descriptor.
+func funlock(f *os.File) error {
+	return syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+}
+
+// mmap memory maps a DB's data file.
+func mmap(db *DB, sz int) error {
+	// Truncate and fsync to ensure file size metadata is flushed.
+	// https://github.com/boltdb/bolt/issues/284
+	if !db.NoGrowSync && !db.readOnly {
+		if err := db.file.Truncate(int64(sz)); err != nil {
+			return fmt.Errorf("file resize error: %s", err)
+		}
+		if err := db.file.Sync(); err != nil {
+			return fmt.Errorf("file sync error: %s", err)
+		}
+	}
+
+	// Map the data file to memory.
+	b, err := syscall.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED)
+	if err != nil {
+		return err
+	}
+
+	// Save the original byte slice and convert to a byte array pointer.
+	db.dataref = b
+	db.data = (*[maxMapSize]byte)(unsafe.Pointer(&b[0]))
+	db.datasz = sz
+	return nil
+}
+
+// munmap unmaps a DB's data file from memory.
+func munmap(db *DB) error {
+	// Ignore the unmap if we have no mapped data.
+	if db.dataref == nil {
+		return nil
+	}
+
+	// Unmap using the original byte slice.
+	err := syscall.Munmap(db.dataref)
+	db.dataref = nil
+	db.data = nil
+	db.datasz = 0
+	return err
+}
diff --git a/vendor/github.com/boltdb/bolt/bolt_windows.go b/vendor/github.com/boltdb/bolt/bolt_windows.go
new file mode 100644
index 00000000..8b782be5
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bolt_windows.go
@@ -0,0 +1,76 @@
+package bolt
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+var odirect int
+
+// fdatasync flushes written data to a file descriptor.
+func fdatasync(db *DB) error {
+	return db.file.Sync()
+}
+
+// flock acquires an advisory lock on a file descriptor.
+func flock(f *os.File, _ bool, _ time.Duration) error {
+	return nil
+}
+
+// funlock releases an advisory lock on a file descriptor.
+func funlock(f *os.File) error {
+	return nil
+}
+
+// mmap memory maps a DB's data file.
+// Based on: https://github.com/edsrzf/mmap-go
+func mmap(db *DB, sz int) error {
+	if !db.readOnly {
+		// Truncate the database to the size of the mmap.
+		if err := db.file.Truncate(int64(sz)); err != nil {
+			return fmt.Errorf("truncate: %s", err)
+		}
+	}
+
+	// Open a file mapping handle.
+	sizelo := uint32(sz >> 32)
+	sizehi := uint32(sz) & 0xffffffff
+	h, errno := syscall.CreateFileMapping(syscall.Handle(db.file.Fd()), nil, syscall.PAGE_READONLY, sizelo, sizehi, nil)
+	if h == 0 {
+		return os.NewSyscallError("CreateFileMapping", errno)
+	}
+
+	// Create the memory map.
+	addr, errno := syscall.MapViewOfFile(h, syscall.FILE_MAP_READ, 0, 0, uintptr(sz))
+	if addr == 0 {
+		return os.NewSyscallError("MapViewOfFile", errno)
+	}
+
+	// Close mapping handle.
+	if err := syscall.CloseHandle(syscall.Handle(h)); err != nil {
+		return os.NewSyscallError("CloseHandle", err)
+	}
+
+	// Convert to a byte array.
+	db.data = ((*[maxMapSize]byte)(unsafe.Pointer(addr)))
+	db.datasz = sz
+
+	return nil
+}
+
+// munmap unmaps a pointer from a file.
+// Based on: https://github.com/edsrzf/mmap-go
+func munmap(db *DB) error {
+	if db.data == nil {
+		return nil
+	}
+
+	addr := (uintptr)(unsafe.Pointer(&db.data[0]))
+	if err := syscall.UnmapViewOfFile(addr); err != nil {
+		return os.NewSyscallError("UnmapViewOfFile", err)
+	}
+	return nil
+}
diff --git a/vendor/github.com/boltdb/bolt/boltsync_unix.go b/vendor/github.com/boltdb/bolt/boltsync_unix.go
new file mode 100644
index 00000000..8db89776
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/boltsync_unix.go
@@ -0,0 +1,10 @@
+// +build !windows,!plan9,!linux,!openbsd
+
+package bolt
+
+var odirect int
+
+// fdatasync flushes written data to a file descriptor.
+func fdatasync(db *DB) error {
+	return db.file.Sync()
+}
diff --git a/vendor/github.com/boltdb/bolt/bucket.go b/vendor/github.com/boltdb/bolt/bucket.go
new file mode 100644
index 00000000..67669921
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/bucket.go
@@ -0,0 +1,743 @@
+package bolt
+
+import (
+	"bytes"
+	"fmt"
+	"unsafe"
+)
+
+const (
+	// MaxKeySize is the maximum length of a key, in bytes.
+	MaxKeySize = 32768
+
+	// MaxValueSize is the maximum length of a value, in bytes.
+	MaxValueSize = 4294967295
+)
+
+const (
+	maxUint = ^uint(0)
+	minUint = 0
+	maxInt  = int(^uint(0) >> 1)
+	minInt  = -maxInt - 1
+)
+
+const bucketHeaderSize = int(unsafe.Sizeof(bucket{}))
+
+const (
+	minFillPercent = 0.1
+	maxFillPercent = 1.0
+)
+
+// DefaultFillPercent is the percentage that split pages are filled.
+// This value can be changed by setting Bucket.FillPercent.
+const DefaultFillPercent = 0.5
+
+// Bucket represents a collection of key/value pairs inside the database.
+type Bucket struct {
+	*bucket
+	tx       *Tx                // the associated transaction
+	buckets  map[string]*Bucket // subbucket cache
+	page     *page              // inline page reference
+	rootNode *node              // materialized node for the root page.
+	nodes    map[pgid]*node     // node cache
+
+	// Sets the threshold for filling nodes when they split. By default,
+	// the bucket will fill to 50% but it can be useful to increase this
+	// amount if you know that your write workloads are mostly append-only.
+	//
+	// This is non-persisted across transactions so it must be set in every Tx.
+	FillPercent float64
+}
+
+// bucket represents the on-file representation of a bucket.
+// This is stored as the "value" of a bucket key. If the bucket is small enough,
+// then its root page can be stored inline in the "value", after the bucket
+// header. In the case of inline buckets, the "root" will be 0.
+type bucket struct {
+	root     pgid   // page id of the bucket's root-level page
+	sequence uint64 // monotonically incrementing, used by NextSequence()
+}
+
+// newBucket returns a new bucket associated with a transaction.
+func newBucket(tx *Tx) Bucket {
+	var b = Bucket{tx: tx, FillPercent: DefaultFillPercent}
+	if tx.writable {
+		b.buckets = make(map[string]*Bucket)
+		b.nodes = make(map[pgid]*node)
+	}
+	return b
+}
+
+// Tx returns the tx of the bucket.
+func (b *Bucket) Tx() *Tx {
+	return b.tx
+}
+
+// Root returns the root of the bucket.
+func (b *Bucket) Root() pgid {
+	return b.root
+}
+
+// Writable returns whether the bucket is writable.
+func (b *Bucket) Writable() bool {
+	return b.tx.writable
+}
+
+// Cursor creates a cursor associated with the bucket.
+// The cursor is only valid as long as the transaction is open.
+// Do not use a cursor after the transaction is closed.
+func (b *Bucket) Cursor() *Cursor {
+	// Update transaction statistics.
+	b.tx.stats.CursorCount++
+
+	// Allocate and return a cursor.
+	return &Cursor{
+		bucket: b,
+		stack:  make([]elemRef, 0),
+	}
+}
+
+// Bucket retrieves a nested bucket by name.
+// Returns nil if the bucket does not exist.
+func (b *Bucket) Bucket(name []byte) *Bucket {
+	if b.buckets != nil {
+		if child := b.buckets[string(name)]; child != nil {
+			return child
+		}
+	}
+
+	// Move cursor to key.
+	c := b.Cursor()
+	k, v, flags := c.seek(name)
+
+	// Return nil if the key doesn't exist or it is not a bucket.
+	if !bytes.Equal(name, k) || (flags&bucketLeafFlag) == 0 {
+		return nil
+	}
+
+	// Otherwise create a bucket and cache it.
+	var child = b.openBucket(v)
+	if b.buckets != nil {
+		b.buckets[string(name)] = child
+	}
+
+	return child
+}
+
+// Helper method that re-interprets a sub-bucket value
+// from a parent into a Bucket
+func (b *Bucket) openBucket(value []byte) *Bucket {
+	var child = newBucket(b.tx)
+
+	// If this is a writable transaction then we need to copy the bucket entry.
+	// Read-only transactions can point directly at the mmap entry.
+	if b.tx.writable {
+		child.bucket = &bucket{}
+		*child.bucket = *(*bucket)(unsafe.Pointer(&value[0]))
+	} else {
+		child.bucket = (*bucket)(unsafe.Pointer(&value[0]))
+	}
+
+	// Save a reference to the inline page if the bucket is inline.
+	if child.root == 0 {
+		child.page = (*page)(unsafe.Pointer(&value[bucketHeaderSize]))
+	}
+
+	return &child
+}
+
+// CreateBucket creates a new bucket at the given key and returns the new bucket.
+// Returns an error if the key already exists, if the bucket name is blank, or if the bucket name is too long.
+func (b *Bucket) CreateBucket(key []byte) (*Bucket, error) {
+	if b.tx.db == nil {
+		return nil, ErrTxClosed
+	} else if !b.tx.writable {
+		return nil, ErrTxNotWritable
+	} else if len(key) == 0 {
+		return nil, ErrBucketNameRequired
+	}
+
+	// Move cursor to correct position.
+	c := b.Cursor()
+	k, _, flags := c.seek(key)
+
+	// Return an error if there is an existing key.
+	if bytes.Equal(key, k) {
+		if (flags & bucketLeafFlag) != 0 {
+			return nil, ErrBucketExists
+		} else {
+			return nil, ErrIncompatibleValue
+		}
+	}
+
+	// Create empty, inline bucket.
+	var bucket = Bucket{
+		bucket:      &bucket{},
+		rootNode:    &node{isLeaf: true},
+		FillPercent: DefaultFillPercent,
+	}
+	var value = bucket.write()
+
+	// Insert into node.
+	key = cloneBytes(key)
+	c.node().put(key, key, value, 0, bucketLeafFlag)
+
+	// Since subbuckets are not allowed on inline buckets, we need to
+	// dereference the inline page, if it exists. This will cause the bucket
+	// to be treated as a regular, non-inline bucket for the rest of the tx.
+	b.page = nil
+
+	return b.Bucket(key), nil
+}
+
+// CreateBucketIfNotExists creates a new bucket if it doesn't already exist and returns a reference to it.
+// Returns an error if the bucket name is blank, or if the bucket name is too long.
+func (b *Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error) {
+	child, err := b.CreateBucket(key)
+	if err == ErrBucketExists {
+		return b.Bucket(key), nil
+	} else if err != nil {
+		return nil, err
+	}
+	return child, nil
+}
+
+// DeleteBucket deletes a bucket at the given key.
+// Returns an error if the bucket does not exists, or if the key represents a non-bucket value.
+func (b *Bucket) DeleteBucket(key []byte) error {
+	if b.tx.db == nil {
+		return ErrTxClosed
+	} else if !b.Writable() {
+		return ErrTxNotWritable
+	}
+
+	// Move cursor to correct position.
+	c := b.Cursor()
+	k, _, flags := c.seek(key)
+
+	// Return an error if bucket doesn't exist or is not a bucket.
+	if !bytes.Equal(key, k) {
+		return ErrBucketNotFound
+	} else if (flags & bucketLeafFlag) == 0 {
+		return ErrIncompatibleValue
+	}
+
+	// Recursively delete all child buckets.
+	child := b.Bucket(key)
+	err := child.ForEach(func(k, v []byte) error {
+		if v == nil {
+			if err := child.DeleteBucket(k); err != nil {
+				return fmt.Errorf("delete bucket: %s", err)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	// Remove cached copy.
+	delete(b.buckets, string(key))
+
+	// Release all bucket pages to freelist.
+	child.nodes = nil
+	child.rootNode = nil
+	child.free()
+
+	// Delete the node if we have a matching key.
+	c.node().del(key)
+
+	return nil
+}
+
+// Get retrieves the value for a key in the bucket.
+// Returns a nil value if the key does not exist or if the key is a nested bucket.
+// The returned value is only valid for the life of the transaction.
+func (b *Bucket) Get(key []byte) []byte {
+	k, v, flags := b.Cursor().seek(key)
+
+	// Return nil if this is a bucket.
+	if (flags & bucketLeafFlag) != 0 {
+		return nil
+	}
+
+	// If our target node isn't the same key as what's passed in then return nil.
+	if !bytes.Equal(key, k) {
+		return nil
+	}
+	return v
+}
+
+// Put sets the value for a key in the bucket.
+// If the key exist then its previous value will be overwritten.
+// Returns an error if the bucket was created from a read-only transaction, if the key is blank, if the key is too large, or if the value is too large.
+func (b *Bucket) Put(key []byte, value []byte) error {
+	if b.tx.db == nil {
+		return ErrTxClosed
+	} else if !b.Writable() {
+		return ErrTxNotWritable
+	} else if len(key) == 0 {
+		return ErrKeyRequired
+	} else if len(key) > MaxKeySize {
+		return ErrKeyTooLarge
+	} else if int64(len(value)) > MaxValueSize {
+		return ErrValueTooLarge
+	}
+
+	// Move cursor to correct position.
+	c := b.Cursor()
+	k, _, flags := c.seek(key)
+
+	// Return an error if there is an existing key with a bucket value.
+	if bytes.Equal(key, k) && (flags&bucketLeafFlag) != 0 {
+		return ErrIncompatibleValue
+	}
+
+	// Insert into node.
+	key = cloneBytes(key)
+	c.node().put(key, key, value, 0, 0)
+
+	return nil
+}
+
+// Delete removes a key from the bucket.
+// If the key does not exist then nothing is done and a nil error is returned.
+// Returns an error if the bucket was created from a read-only transaction.
+func (b *Bucket) Delete(key []byte) error {
+	if b.tx.db == nil {
+		return ErrTxClosed
+	} else if !b.Writable() {
+		return ErrTxNotWritable
+	}
+
+	// Move cursor to correct position.
+	c := b.Cursor()
+	_, _, flags := c.seek(key)
+
+	// Return an error if there is already existing bucket value.
+	if (flags & bucketLeafFlag) != 0 {
+		return ErrIncompatibleValue
+	}
+
+	// Delete the node if we have a matching key.
+	c.node().del(key)
+
+	return nil
+}
+
+// NextSequence returns an autoincrementing integer for the bucket.
+func (b *Bucket) NextSequence() (uint64, error) {
+	if b.tx.db == nil {
+		return 0, ErrTxClosed
+	} else if !b.Writable() {
+		return 0, ErrTxNotWritable
+	}
+
+	// Materialize the root node if it hasn't been already so that the
+	// bucket will be saved during commit.
+	if b.rootNode == nil {
+		_ = b.node(b.root, nil)
+	}
+
+	// Increment and return the sequence.
+	b.bucket.sequence++
+	return b.bucket.sequence, nil
+}
+
+// ForEach executes a function for each key/value pair in a bucket.
+// If the provided function returns an error then the iteration is stopped and
+// the error is returned to the caller.
+func (b *Bucket) ForEach(fn func(k, v []byte) error) error {
+	if b.tx.db == nil {
+		return ErrTxClosed
+	}
+	c := b.Cursor()
+	for k, v := c.First(); k != nil; k, v = c.Next() {
+		if err := fn(k, v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Stat returns stats on a bucket.
+func (b *Bucket) Stats() BucketStats {
+	var s, subStats BucketStats
+	pageSize := b.tx.db.pageSize
+	s.BucketN += 1
+	if b.root == 0 {
+		s.InlineBucketN += 1
+	}
+	b.forEachPage(func(p *page, depth int) {
+		if (p.flags & leafPageFlag) != 0 {
+			s.KeyN += int(p.count)
+
+			// used totals the used bytes for the page
+			used := pageHeaderSize
+
+			if p.count != 0 {
+				// If page has any elements, add all element headers.
+				used += leafPageElementSize * int(p.count-1)
+
+				// Add all element key, value sizes.
+				// The computation takes advantage of the fact that the position
+				// of the last element's key/value equals to the total of the sizes
+				// of all previous elements' keys and values.
+				// It also includes the last element's header.
+				lastElement := p.leafPageElement(p.count - 1)
+				used += int(lastElement.pos + lastElement.ksize + lastElement.vsize)
+			}
+
+			if b.root == 0 {
+				// For inlined bucket just update the inline stats
+				s.InlineBucketInuse += used
+			} else {
+				// For non-inlined bucket update all the leaf stats
+				s.LeafPageN++
+				s.LeafInuse += used
+				s.LeafOverflowN += int(p.overflow)
+
+				// Collect stats from sub-buckets.
+				// Do that by iterating over all element headers
+				// looking for the ones with the bucketLeafFlag.
+				for i := uint16(0); i < p.count; i++ {
+					e := p.leafPageElement(i)
+					if (e.flags & bucketLeafFlag) != 0 {
+						// For any bucket element, open the element value
+						// and recursively call Stats on the contained bucket.
+						subStats.Add(b.openBucket(e.value()).Stats())
+					}
+				}
+			}
+		} else if (p.flags & branchPageFlag) != 0 {
+			s.BranchPageN++
+			lastElement := p.branchPageElement(p.count - 1)
+
+			// used totals the used bytes for the page
+			// Add header and all element headers.
+			used := pageHeaderSize + (branchPageElementSize * int(p.count-1))
+
+			// Add size of all keys and values.
+			// Again, use the fact that last element's position equals to
+			// the total of key, value sizes of all previous elements.
+			used += int(lastElement.pos + lastElement.ksize)
+			s.BranchInuse += used
+			s.BranchOverflowN += int(p.overflow)
+		}
+
+		// Keep track of maximum page depth.
+		if depth+1 > s.Depth {
+			s.Depth = (depth + 1)
+		}
+	})
+
+	// Alloc stats can be computed from page counts and pageSize.
+	s.BranchAlloc = (s.BranchPageN + s.BranchOverflowN) * pageSize
+	s.LeafAlloc = (s.LeafPageN + s.LeafOverflowN) * pageSize
+
+	// Add the max depth of sub-buckets to get total nested depth.
+	s.Depth += subStats.Depth
+	// Add the stats for all sub-buckets
+	s.Add(subStats)
+	return s
+}
+
+// forEachPage iterates over every page in a bucket, including inline pages.
+func (b *Bucket) forEachPage(fn func(*page, int)) {
+	// If we have an inline page then just use that.
+	if b.page != nil {
+		fn(b.page, 0)
+		return
+	}
+
+	// Otherwise traverse the page hierarchy.
+	b.tx.forEachPage(b.root, 0, fn)
+}
+
+// forEachPageNode iterates over every page (or node) in a bucket.
+// This also includes inline pages.
+func (b *Bucket) forEachPageNode(fn func(*page, *node, int)) {
+	// If we have an inline page or root node then just use that.
+	if b.page != nil {
+		fn(b.page, nil, 0)
+		return
+	}
+	b._forEachPageNode(b.root, 0, fn)
+}
+
+func (b *Bucket) _forEachPageNode(pgid pgid, depth int, fn func(*page, *node, int)) {
+	var p, n = b.pageNode(pgid)
+
+	// Execute function.
+	fn(p, n, depth)
+
+	// Recursively loop over children.
+	if p != nil {
+		if (p.flags & branchPageFlag) != 0 {
+			for i := 0; i < int(p.count); i++ {
+				elem := p.branchPageElement(uint16(i))
+				b._forEachPageNode(elem.pgid, depth+1, fn)
+			}
+		}
+	} else {
+		if !n.isLeaf {
+			for _, inode := range n.inodes {
+				b._forEachPageNode(inode.pgid, depth+1, fn)
+			}
+		}
+	}
+}
+
+// spill writes all the nodes for this bucket to dirty pages.
+func (b *Bucket) spill() error {
+	// Spill all child buckets first.
+	for name, child := range b.buckets {
+		// If the child bucket is small enough and it has no child buckets then
+		// write it inline into the parent bucket's page. Otherwise spill it
+		// like a normal bucket and make the parent value a pointer to the page.
+		var value []byte
+		if child.inlineable() {
+			child.free()
+			value = child.write()
+		} else {
+			if err := child.spill(); err != nil {
+				return err
+			}
+
+			// Update the child bucket header in this bucket.
+			value = make([]byte, unsafe.Sizeof(bucket{}))
+			var bucket = (*bucket)(unsafe.Pointer(&value[0]))
+			*bucket = *child.bucket
+		}
+
+		// Skip writing the bucket if there are no materialized nodes.
+		if child.rootNode == nil {
+			continue
+		}
+
+		// Update parent node.
+		var c = b.Cursor()
+		k, _, flags := c.seek([]byte(name))
+		if !bytes.Equal([]byte(name), k) {
+			panic(fmt.Sprintf("misplaced bucket header: %x -> %x", []byte(name), k))
+		}
+		if flags&bucketLeafFlag == 0 {
+			panic(fmt.Sprintf("unexpected bucket header flag: %x", flags))
+		}
+		c.node().put([]byte(name), []byte(name), value, 0, bucketLeafFlag)
+	}
+
+	// Ignore if there's not a materialized root node.
+	if b.rootNode == nil {
+		return nil
+	}
+
+	// Spill nodes.
+	if err := b.rootNode.spill(); err != nil {
+		return err
+	}
+	b.rootNode = b.rootNode.root()
+
+	// Update the root node for this bucket.
+	if b.rootNode.pgid >= b.tx.meta.pgid {
+		panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", b.rootNode.pgid, b.tx.meta.pgid))
+	}
+	b.root = b.rootNode.pgid
+
+	return nil
+}
+
+// inlineable returns true if a bucket is small enough to be written inline
+// and if it contains no subbuckets. Otherwise returns false.
+func (b *Bucket) inlineable() bool {
+	var n = b.rootNode
+
+	// Bucket must only contain a single leaf node.
+	if n == nil || !n.isLeaf {
+		return false
+	}
+
+	// Bucket is not inlineable if it contains subbuckets or if it goes beyond
+	// our threshold for inline bucket size.
+	var size = pageHeaderSize
+	for _, inode := range n.inodes {
+		size += leafPageElementSize + len(inode.key) + len(inode.value)
+
+		if inode.flags&bucketLeafFlag != 0 {
+			return false
+		} else if size > b.maxInlineBucketSize() {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Returns the maximum total size of a bucket to make it a candidate for inlining.
+func (b *Bucket) maxInlineBucketSize() int {
+	return b.tx.db.pageSize / 4
+}
+
+// write allocates and writes a bucket to a byte slice.
+func (b *Bucket) write() []byte {
+	// Allocate the appropriate size.
+	var n = b.rootNode
+	var value = make([]byte, bucketHeaderSize+n.size())
+
+	// Write a bucket header.
+	var bucket = (*bucket)(unsafe.Pointer(&value[0]))
+	*bucket = *b.bucket
+
+	// Convert byte slice to a fake page and write the root node.
+	var p = (*page)(unsafe.Pointer(&value[bucketHeaderSize]))
+	n.write(p)
+
+	return value
+}
+
+// rebalance attempts to balance all nodes.
+func (b *Bucket) rebalance() {
+	for _, n := range b.nodes {
+		n.rebalance()
+	}
+	for _, child := range b.buckets {
+		child.rebalance()
+	}
+}
+
+// node creates a node from a page and associates it with a given parent.
+func (b *Bucket) node(pgid pgid, parent *node) *node {
+	_assert(b.nodes != nil, "nodes map expected")
+
+	// Retrieve node if it's already been created.
+	if n := b.nodes[pgid]; n != nil {
+		return n
+	}
+
+	// Otherwise create a node and cache it.
+	n := &node{bucket: b, parent: parent}
+	if parent == nil {
+		b.rootNode = n
+	} else {
+		parent.children = append(parent.children, n)
+	}
+
+	// Use the inline page if this is an inline bucket.
+	var p = b.page
+	if p == nil {
+		p = b.tx.page(pgid)
+	}
+
+	// Read the page into the node and cache it.
+	n.read(p)
+	b.nodes[pgid] = n
+
+	// Update statistics.
+	b.tx.stats.NodeCount++
+
+	return n
+}
+
+// free recursively frees all pages in the bucket.
+func (b *Bucket) free() {
+	if b.root == 0 {
+		return
+	}
+
+	var tx = b.tx
+	b.forEachPageNode(func(p *page, n *node, _ int) {
+		if p != nil {
+			tx.db.freelist.free(tx.meta.txid, p)
+		} else {
+			n.free()
+		}
+	})
+	b.root = 0
+}
+
+// dereference removes all references to the old mmap.
+func (b *Bucket) dereference() {
+	if b.rootNode != nil {
+		b.rootNode.root().dereference()
+	}
+
+	for _, child := range b.buckets {
+		child.dereference()
+	}
+}
+
+// pageNode returns the in-memory node, if it exists.
+// Otherwise returns the underlying page.
+func (b *Bucket) pageNode(id pgid) (*page, *node) {
+	// Inline buckets have a fake page embedded in their value so treat them
+	// differently. We'll return the rootNode (if available) or the fake page.
+	if b.root == 0 {
+		if id != 0 {
+			panic(fmt.Sprintf("inline bucket non-zero page access(2): %d != 0", id))
+		}
+		if b.rootNode != nil {
+			return nil, b.rootNode
+		}
+		return b.page, nil
+	}
+
+	// Check the node cache for non-inline buckets.
+	if b.nodes != nil {
+		if n := b.nodes[id]; n != nil {
+			return nil, n
+		}
+	}
+
+	// Finally lookup the page from the transaction if no node is materialized.
+	return b.tx.page(id), nil
+}
+
+// BucketStats records statistics about resources used by a bucket.
+type BucketStats struct {
+	// Page count statistics.
+	BranchPageN     int // number of logical branch pages
+	BranchOverflowN int // number of physical branch overflow pages
+	LeafPageN       int // number of logical leaf pages
+	LeafOverflowN   int // number of physical leaf overflow pages
+
+	// Tree statistics.
+	KeyN  int // number of keys/value pairs
+	Depth int // number of levels in B+tree
+
+	// Page size utilization.
+	BranchAlloc int // bytes allocated for physical branch pages
+	BranchInuse int // bytes actually used for branch data
+	LeafAlloc   int // bytes allocated for physical leaf pages
+	LeafInuse   int // bytes actually used for leaf data
+
+	// Bucket statistics
+	BucketN           int // total number of buckets including the top bucket
+	InlineBucketN     int // total number on inlined buckets
+	InlineBucketInuse int // bytes used for inlined buckets (also accounted for in LeafInuse)
+}
+
+func (s *BucketStats) Add(other BucketStats) {
+	s.BranchPageN += other.BranchPageN
+	s.BranchOverflowN += other.BranchOverflowN
+	s.LeafPageN += other.LeafPageN
+	s.LeafOverflowN += other.LeafOverflowN
+	s.KeyN += other.KeyN
+	if s.Depth < other.Depth {
+		s.Depth = other.Depth
+	}
+	s.BranchAlloc += other.BranchAlloc
+	s.BranchInuse += other.BranchInuse
+	s.LeafAlloc += other.LeafAlloc
+	s.LeafInuse += other.LeafInuse
+
+	s.BucketN += other.BucketN
+	s.InlineBucketN += other.InlineBucketN
+	s.InlineBucketInuse += other.InlineBucketInuse
+}
+
+// cloneBytes returns a copy of a given slice.
+func cloneBytes(v []byte) []byte {
+	var clone = make([]byte, len(v))
+	copy(clone, v)
+	return clone
+}
diff --git a/vendor/github.com/boltdb/bolt/cmd/bolt/main.go b/vendor/github.com/boltdb/bolt/cmd/bolt/main.go
new file mode 100644
index 00000000..a1f2ae8a
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/cmd/bolt/main.go
@@ -0,0 +1,1529 @@
+package main
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+	"unsafe"
+
+	"github.com/boltdb/bolt"
+)
+
+var (
+	// ErrUsage is returned when a usage message was printed and the process
+	// should simply exit with an error.
+	ErrUsage = errors.New("usage")
+
+	// ErrUnknownCommand is returned when a CLI command is not specified.
+	ErrUnknownCommand = errors.New("unknown command")
+
+	// ErrPathRequired is returned when the path to a Bolt database is not specified.
+	ErrPathRequired = errors.New("path required")
+
+	// ErrFileNotFound is returned when a Bolt database does not exist.
+	ErrFileNotFound = errors.New("file not found")
+
+	// ErrInvalidValue is returned when a benchmark reads an unexpected value.
+	ErrInvalidValue = errors.New("invalid value")
+
+	// ErrCorrupt is returned when a checking a data file finds errors.
+	ErrCorrupt = errors.New("invalid value")
+
+	// ErrNonDivisibleBatchSize is returned when the batch size can't be evenly
+	// divided by the iteration count.
+	ErrNonDivisibleBatchSize = errors.New("number of iterations must be divisible by the batch size")
+
+	// ErrPageIDRequired is returned when a required page id is not specified.
+	ErrPageIDRequired = errors.New("page id required")
+
+	// ErrPageNotFound is returned when specifying a page above the high water mark.
+	ErrPageNotFound = errors.New("page not found")
+
+	// ErrPageFreed is returned when reading a page that has already been freed.
+	ErrPageFreed = errors.New("page freed")
+)
+
+// PageHeaderSize represents the size of the bolt.page header.
+const PageHeaderSize = 16
+
+func main() {
+	m := NewMain()
+	if err := m.Run(os.Args[1:]...); err == ErrUsage {
+		os.Exit(2)
+	} else if err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
+	}
+}
+
+// Main represents the main program execution.
+type Main struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewMain returns a new instance of Main connect to the standard input/output.
+func NewMain() *Main {
+	return &Main{
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+	}
+}
+
+// Run executes the program.
+func (m *Main) Run(args ...string) error {
+	// Require a command at the beginning.
+	if len(args) == 0 || strings.HasPrefix(args[0], "-") {
+		fmt.Fprintln(m.Stderr, m.Usage())
+		return ErrUsage
+	}
+
+	// Execute command.
+	switch args[0] {
+	case "help":
+		fmt.Fprintln(m.Stderr, m.Usage())
+		return ErrUsage
+	case "bench":
+		return newBenchCommand(m).Run(args[1:]...)
+	case "check":
+		return newCheckCommand(m).Run(args[1:]...)
+	case "dump":
+		return newDumpCommand(m).Run(args[1:]...)
+	case "info":
+		return newInfoCommand(m).Run(args[1:]...)
+	case "page":
+		return newPageCommand(m).Run(args[1:]...)
+	case "pages":
+		return newPagesCommand(m).Run(args[1:]...)
+	case "stats":
+		return newStatsCommand(m).Run(args[1:]...)
+	default:
+		return ErrUnknownCommand
+	}
+}
+
+// Usage returns the help message.
+func (m *Main) Usage() string {
+	return strings.TrimLeft(`
+Bolt is a tool for inspecting bolt databases.
+
+Usage:
+
+	bolt command [arguments]
+
+The commands are:
+
+    bench       run synthetic benchmark against bolt
+    check       verifies integrity of bolt database
+    info        print basic info
+    help        print this screen
+    pages       print list of pages with their types
+    stats       iterate over all pages and generate usage stats
+
+Use "bolt [command] -h" for more information about a command.
+`, "\n")
+}
+
+// CheckCommand represents the "check" command execution.
+type CheckCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewCheckCommand returns a CheckCommand.
+func newCheckCommand(m *Main) *CheckCommand {
+	return &CheckCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the command.
+func (cmd *CheckCommand) Run(args ...string) error {
+	// Parse flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	help := fs.Bool("h", false, "")
+	if err := fs.Parse(args); err != nil {
+		return err
+	} else if *help {
+		fmt.Fprintln(cmd.Stderr, cmd.Usage())
+		return ErrUsage
+	}
+
+	// Require database path.
+	path := fs.Arg(0)
+	if path == "" {
+		return ErrPathRequired
+	} else if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ErrFileNotFound
+	}
+
+	// Open database.
+	db, err := bolt.Open(path, 0666, nil)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	// Perform consistency check.
+	return db.View(func(tx *bolt.Tx) error {
+		var count int
+		ch := tx.Check()
+	loop:
+		for {
+			select {
+			case err, ok := <-ch:
+				if !ok {
+					break loop
+				}
+				fmt.Fprintln(cmd.Stdout, err)
+				count++
+			}
+		}
+
+		// Print summary of errors.
+		if count > 0 {
+			fmt.Fprintf(cmd.Stdout, "%d errors found\n", count)
+			return ErrCorrupt
+		}
+
+		// Notify user that database is valid.
+		fmt.Fprintln(cmd.Stdout, "OK")
+		return nil
+	})
+}
+
+// Usage returns the help message.
+func (cmd *CheckCommand) Usage() string {
+	return strings.TrimLeft(`
+usage: bolt check PATH
+
+Check opens a database at PATH and runs an exhaustive check to verify that
+all pages are accessible or are marked as freed. It also verifies that no
+pages are double referenced.
+
+Verification errors will stream out as they are found and the process will
+return after all pages have been checked.
+`, "\n")
+}
+
+// InfoCommand represents the "info" command execution.
+type InfoCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewInfoCommand returns a InfoCommand.
+func newInfoCommand(m *Main) *InfoCommand {
+	return &InfoCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the command.
+func (cmd *InfoCommand) Run(args ...string) error {
+	// Parse flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	help := fs.Bool("h", false, "")
+	if err := fs.Parse(args); err != nil {
+		return err
+	} else if *help {
+		fmt.Fprintln(cmd.Stderr, cmd.Usage())
+		return ErrUsage
+	}
+
+	// Require database path.
+	path := fs.Arg(0)
+	if path == "" {
+		return ErrPathRequired
+	} else if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ErrFileNotFound
+	}
+
+	// Open the database.
+	db, err := bolt.Open(path, 0666, nil)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	// Print basic database info.
+	info := db.Info()
+	fmt.Fprintf(cmd.Stdout, "Page Size: %d\n", info.PageSize)
+
+	return nil
+}
+
+// Usage returns the help message.
+func (cmd *InfoCommand) Usage() string {
+	return strings.TrimLeft(`
+usage: bolt info PATH
+
+Info prints basic information about the Bolt database at PATH.
+`, "\n")
+}
+
+// DumpCommand represents the "dump" command execution.
+type DumpCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// newDumpCommand returns a DumpCommand.
+func newDumpCommand(m *Main) *DumpCommand {
+	return &DumpCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the command.
+func (cmd *DumpCommand) Run(args ...string) error {
+	// Parse flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	help := fs.Bool("h", false, "")
+	if err := fs.Parse(args); err != nil {
+		return err
+	} else if *help {
+		fmt.Fprintln(cmd.Stderr, cmd.Usage())
+		return ErrUsage
+	}
+
+	// Require database path and page id.
+	path := fs.Arg(0)
+	if path == "" {
+		return ErrPathRequired
+	} else if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ErrFileNotFound
+	}
+
+	// Read page ids.
+	pageIDs, err := atois(fs.Args()[1:])
+	if err != nil {
+		return err
+	} else if len(pageIDs) == 0 {
+		return ErrPageIDRequired
+	}
+
+	// Open database to retrieve page size.
+	pageSize, err := ReadPageSize(path)
+	if err != nil {
+		return err
+	}
+
+	// Open database file handler.
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = f.Close() }()
+
+	// Print each page listed.
+	for i, pageID := range pageIDs {
+		// Print a separator.
+		if i > 0 {
+			fmt.Fprintln(cmd.Stdout, "===============================================\n")
+		}
+
+		// Print page to stdout.
+		if err := cmd.PrintPage(cmd.Stdout, f, pageID, pageSize); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// PrintPage prints a given page as hexidecimal.
+func (cmd *DumpCommand) PrintPage(w io.Writer, r io.ReaderAt, pageID int, pageSize int) error {
+	const bytesPerLineN = 16
+
+	// Read page into buffer.
+	buf := make([]byte, pageSize)
+	addr := pageID * pageSize
+	if n, err := r.ReadAt(buf, int64(addr)); err != nil {
+		return err
+	} else if n != pageSize {
+		return io.ErrUnexpectedEOF
+	}
+
+	// Write out to writer in 16-byte lines.
+	var prev []byte
+	var skipped bool
+	for offset := 0; offset < pageSize; offset += bytesPerLineN {
+		// Retrieve current 16-byte line.
+		line := buf[offset : offset+bytesPerLineN]
+		isLastLine := (offset == (pageSize - bytesPerLineN))
+
+		// If it's the same as the previous line then print a skip.
+		if bytes.Equal(line, prev) && !isLastLine {
+			if !skipped {
+				fmt.Fprintf(w, "%07x *\n", addr+offset)
+				skipped = true
+			}
+		} else {
+			// Print line as hexadecimal in 2-byte groups.
+			fmt.Fprintf(w, "%07x %04x %04x %04x %04x %04x %04x %04x %04x\n", addr+offset,
+				line[0:2], line[2:4], line[4:6], line[6:8],
+				line[8:10], line[10:12], line[12:14], line[14:16],
+			)
+
+			skipped = false
+		}
+
+		// Save the previous line.
+		prev = line
+	}
+	fmt.Fprint(w, "\n")
+
+	return nil
+}
+
+// Usage returns the help message.
+func (cmd *DumpCommand) Usage() string {
+	return strings.TrimLeft(`
+usage: bolt dump -page PAGEID PATH
+
+Dump prints a hexidecimal dump of a single page.
+`, "\n")
+}
+
+// PageCommand represents the "page" command execution.
+type PageCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// newPageCommand returns a PageCommand.
+func newPageCommand(m *Main) *PageCommand {
+	return &PageCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the command.
+func (cmd *PageCommand) Run(args ...string) error {
+	// Parse flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	help := fs.Bool("h", false, "")
+	if err := fs.Parse(args); err != nil {
+		return err
+	} else if *help {
+		fmt.Fprintln(cmd.Stderr, cmd.Usage())
+		return ErrUsage
+	}
+
+	// Require database path and page id.
+	path := fs.Arg(0)
+	if path == "" {
+		return ErrPathRequired
+	} else if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ErrFileNotFound
+	}
+
+	// Read page ids.
+	pageIDs, err := atois(fs.Args()[1:])
+	if err != nil {
+		return err
+	} else if len(pageIDs) == 0 {
+		return ErrPageIDRequired
+	}
+
+	// Open database file handler.
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = f.Close() }()
+
+	// Print each page listed.
+	for i, pageID := range pageIDs {
+		// Print a separator.
+		if i > 0 {
+			fmt.Fprintln(cmd.Stdout, "===============================================\n")
+		}
+
+		// Retrieve page info and page size.
+		p, buf, err := ReadPage(path, pageID)
+		if err != nil {
+			return err
+		}
+
+		// Print basic page info.
+		fmt.Fprintf(cmd.Stdout, "Page ID:    %d\n", p.id)
+		fmt.Fprintf(cmd.Stdout, "Page Type:  %s\n", p.Type())
+		fmt.Fprintf(cmd.Stdout, "Total Size: %d bytes\n", len(buf))
+
+		// Print type-specific data.
+		switch p.Type() {
+		case "meta":
+			err = cmd.PrintMeta(cmd.Stdout, buf)
+		case "leaf":
+			err = cmd.PrintLeaf(cmd.Stdout, buf)
+		case "branch":
+			err = cmd.PrintBranch(cmd.Stdout, buf)
+		case "freelist":
+			err = cmd.PrintFreelist(cmd.Stdout, buf)
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// PrintMeta prints the data from the meta page.
+func (cmd *PageCommand) PrintMeta(w io.Writer, buf []byte) error {
+	m := (*meta)(unsafe.Pointer(&buf[PageHeaderSize]))
+	fmt.Fprintf(w, "Version:    %d\n", m.version)
+	fmt.Fprintf(w, "Page Size:  %d bytes\n", m.pageSize)
+	fmt.Fprintf(w, "Flags:      %08x\n", m.flags)
+	fmt.Fprintf(w, "Root:       <pgid=%d>\n", m.root.root)
+	fmt.Fprintf(w, "Freelist:   <pgid=%d>\n", m.freelist)
+	fmt.Fprintf(w, "HWM:        <pgid=%d>\n", m.pgid)
+	fmt.Fprintf(w, "Txn ID:     %d\n", m.txid)
+	fmt.Fprintf(w, "Checksum:   %016x\n", m.checksum)
+	fmt.Fprintf(w, "\n")
+	return nil
+}
+
+// PrintLeaf prints the data for a leaf page.
+func (cmd *PageCommand) PrintLeaf(w io.Writer, buf []byte) error {
+	p := (*page)(unsafe.Pointer(&buf[0]))
+
+	// Print number of items.
+	fmt.Fprintf(w, "Item Count: %d\n", p.count)
+	fmt.Fprintf(w, "\n")
+
+	// Print each key/value.
+	for i := uint16(0); i < p.count; i++ {
+		e := p.leafPageElement(i)
+
+		// Format key as string.
+		var k string
+		if isPrintable(string(e.key())) {
+			k = fmt.Sprintf("%q", string(e.key()))
+		} else {
+			k = fmt.Sprintf("%x", string(e.key()))
+		}
+
+		// Format value as string.
+		var v string
+		if (e.flags & uint32(bucketLeafFlag)) != 0 {
+			b := (*bucket)(unsafe.Pointer(&e.value()[0]))
+			v = fmt.Sprintf("<pgid=%d,seq=%d>", b.root, b.sequence)
+		} else if isPrintable(string(e.value())) {
+			k = fmt.Sprintf("%q", string(e.value()))
+		} else {
+			k = fmt.Sprintf("%x", string(e.value()))
+		}
+
+		fmt.Fprintf(w, "%s: %s\n", k, v)
+	}
+	fmt.Fprintf(w, "\n")
+	return nil
+}
+
+// PrintBranch prints the data for a leaf page.
+func (cmd *PageCommand) PrintBranch(w io.Writer, buf []byte) error {
+	p := (*page)(unsafe.Pointer(&buf[0]))
+
+	// Print number of items.
+	fmt.Fprintf(w, "Item Count: %d\n", p.count)
+	fmt.Fprintf(w, "\n")
+
+	// Print each key/value.
+	for i := uint16(0); i < p.count; i++ {
+		e := p.branchPageElement(i)
+
+		// Format key as string.
+		var k string
+		if isPrintable(string(e.key())) {
+			k = fmt.Sprintf("%q", string(e.key()))
+		} else {
+			k = fmt.Sprintf("%x", string(e.key()))
+		}
+
+		fmt.Fprintf(w, "%s: <pgid=%d>\n", k, e.pgid)
+	}
+	fmt.Fprintf(w, "\n")
+	return nil
+}
+
+// PrintFreelist prints the data for a freelist page.
+func (cmd *PageCommand) PrintFreelist(w io.Writer, buf []byte) error {
+	p := (*page)(unsafe.Pointer(&buf[0]))
+
+	// Print number of items.
+	fmt.Fprintf(w, "Item Count: %d\n", p.count)
+	fmt.Fprintf(w, "\n")
+
+	// Print each page in the freelist.
+	ids := (*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr))
+	for i := uint16(0); i < p.count; i++ {
+		fmt.Fprintf(w, "%d\n", ids[i])
+	}
+	fmt.Fprintf(w, "\n")
+	return nil
+}
+
+// PrintPage prints a given page as hexidecimal.
+func (cmd *PageCommand) PrintPage(w io.Writer, r io.ReaderAt, pageID int, pageSize int) error {
+	const bytesPerLineN = 16
+
+	// Read page into buffer.
+	buf := make([]byte, pageSize)
+	addr := pageID * pageSize
+	if n, err := r.ReadAt(buf, int64(addr)); err != nil {
+		return err
+	} else if n != pageSize {
+		return io.ErrUnexpectedEOF
+	}
+
+	// Write out to writer in 16-byte lines.
+	var prev []byte
+	var skipped bool
+	for offset := 0; offset < pageSize; offset += bytesPerLineN {
+		// Retrieve current 16-byte line.
+		line := buf[offset : offset+bytesPerLineN]
+		isLastLine := (offset == (pageSize - bytesPerLineN))
+
+		// If it's the same as the previous line then print a skip.
+		if bytes.Equal(line, prev) && !isLastLine {
+			if !skipped {
+				fmt.Fprintf(w, "%07x *\n", addr+offset)
+				skipped = true
+			}
+		} else {
+			// Print line as hexadecimal in 2-byte groups.
+			fmt.Fprintf(w, "%07x %04x %04x %04x %04x %04x %04x %04x %04x\n", addr+offset,
+				line[0:2], line[2:4], line[4:6], line[6:8],
+				line[8:10], line[10:12], line[12:14], line[14:16],
+			)
+
+			skipped = false
+		}
+
+		// Save the previous line.
+		prev = line
+	}
+	fmt.Fprint(w, "\n")
+
+	return nil
+}
+
+// Usage returns the help message.
+func (cmd *PageCommand) Usage() string {
+	return strings.TrimLeft(`
+usage: bolt page -page PATH pageid [pageid...]
+
+Page prints one or more pages in human readable format.
+`, "\n")
+}
+
+// PagesCommand represents the "pages" command execution.
+type PagesCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewPagesCommand returns a PagesCommand.
+func newPagesCommand(m *Main) *PagesCommand {
+	return &PagesCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the command.
+func (cmd *PagesCommand) Run(args ...string) error {
+	// Parse flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	help := fs.Bool("h", false, "")
+	if err := fs.Parse(args); err != nil {
+		return err
+	} else if *help {
+		fmt.Fprintln(cmd.Stderr, cmd.Usage())
+		return ErrUsage
+	}
+
+	// Require database path.
+	path := fs.Arg(0)
+	if path == "" {
+		return ErrPathRequired
+	} else if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ErrFileNotFound
+	}
+
+	// Open database.
+	db, err := bolt.Open(path, 0666, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = db.Close() }()
+
+	// Write header.
+	fmt.Fprintln(cmd.Stdout, "ID       TYPE       ITEMS  OVRFLW")
+	fmt.Fprintln(cmd.Stdout, "======== ========== ====== ======")
+
+	return db.Update(func(tx *bolt.Tx) error {
+		var id int
+		for {
+			p, err := tx.Page(id)
+			if err != nil {
+				return &PageError{ID: id, Err: err}
+			} else if p == nil {
+				break
+			}
+
+			// Only display count and overflow if this is a non-free page.
+			var count, overflow string
+			if p.Type != "free" {
+				count = strconv.Itoa(p.Count)
+				if p.OverflowCount > 0 {
+					overflow = strconv.Itoa(p.OverflowCount)
+				}
+			}
+
+			// Print table row.
+			fmt.Fprintf(cmd.Stdout, "%-8d %-10s %-6s %-6s\n", p.ID, p.Type, count, overflow)
+
+			// Move to the next non-overflow page.
+			id += 1
+			if p.Type != "free" {
+				id += p.OverflowCount
+			}
+		}
+		return nil
+	})
+}
+
+// Usage returns the help message.
+func (cmd *PagesCommand) Usage() string {
+	return strings.TrimLeft(`
+usage: bolt pages PATH
+
+Pages prints a table of pages with their type (meta, leaf, branch, freelist).
+Leaf and branch pages will show a key count in the "items" column while the
+freelist will show the number of free pages in the "items" column.
+
+The "overflow" column shows the number of blocks that the page spills over
+into. Normally there is no overflow but large keys and values can cause
+a single page to take up multiple blocks.
+`, "\n")
+}
+
+// StatsCommand represents the "stats" command execution.
+type StatsCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewStatsCommand returns a StatsCommand.
+func newStatsCommand(m *Main) *StatsCommand {
+	return &StatsCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the command.
+func (cmd *StatsCommand) Run(args ...string) error {
+	// Parse flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	help := fs.Bool("h", false, "")
+	if err := fs.Parse(args); err != nil {
+		return err
+	} else if *help {
+		fmt.Fprintln(cmd.Stderr, cmd.Usage())
+		return ErrUsage
+	}
+
+	// Require database path.
+	path, prefix := fs.Arg(0), fs.Arg(1)
+	if path == "" {
+		return ErrPathRequired
+	} else if _, err := os.Stat(path); os.IsNotExist(err) {
+		return ErrFileNotFound
+	}
+
+	// Open database.
+	db, err := bolt.Open(path, 0666, nil)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	return db.View(func(tx *bolt.Tx) error {
+		var s bolt.BucketStats
+		var count int
+		if err := tx.ForEach(func(name []byte, b *bolt.Bucket) error {
+			if bytes.HasPrefix(name, []byte(prefix)) {
+				s.Add(b.Stats())
+				count += 1
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+
+		fmt.Fprintf(cmd.Stdout, "Aggregate statistics for %d buckets\n\n", count)
+
+		fmt.Fprintln(cmd.Stdout, "Page count statistics")
+		fmt.Fprintf(cmd.Stdout, "\tNumber of logical branch pages: %d\n", s.BranchPageN)
+		fmt.Fprintf(cmd.Stdout, "\tNumber of physical branch overflow pages: %d\n", s.BranchOverflowN)
+		fmt.Fprintf(cmd.Stdout, "\tNumber of logical leaf pages: %d\n", s.LeafPageN)
+		fmt.Fprintf(cmd.Stdout, "\tNumber of physical leaf overflow pages: %d\n", s.LeafOverflowN)
+
+		fmt.Fprintln(cmd.Stdout, "Tree statistics")
+		fmt.Fprintf(cmd.Stdout, "\tNumber of keys/value pairs: %d\n", s.KeyN)
+		fmt.Fprintf(cmd.Stdout, "\tNumber of levels in B+tree: %d\n", s.Depth)
+
+		fmt.Fprintln(cmd.Stdout, "Page size utilization")
+		fmt.Fprintf(cmd.Stdout, "\tBytes allocated for physical branch pages: %d\n", s.BranchAlloc)
+		var percentage int
+		if s.BranchAlloc != 0 {
+			percentage = int(float32(s.BranchInuse) * 100.0 / float32(s.BranchAlloc))
+		}
+		fmt.Fprintf(cmd.Stdout, "\tBytes actually used for branch data: %d (%d%%)\n", s.BranchInuse, percentage)
+		fmt.Fprintf(cmd.Stdout, "\tBytes allocated for physical leaf pages: %d\n", s.LeafAlloc)
+		percentage = 0
+		if s.LeafAlloc != 0 {
+			percentage = int(float32(s.LeafInuse) * 100.0 / float32(s.LeafAlloc))
+		}
+		fmt.Fprintf(cmd.Stdout, "\tBytes actually used for leaf data: %d (%d%%)\n", s.LeafInuse, percentage)
+
+		fmt.Fprintln(cmd.Stdout, "Bucket statistics")
+		fmt.Fprintf(cmd.Stdout, "\tTotal number of buckets: %d\n", s.BucketN)
+		percentage = int(float32(s.InlineBucketN) * 100.0 / float32(s.BucketN))
+		fmt.Fprintf(cmd.Stdout, "\tTotal number on inlined buckets: %d (%d%%)\n", s.InlineBucketN, percentage)
+		percentage = 0
+		if s.LeafInuse != 0 {
+			percentage = int(float32(s.InlineBucketInuse) * 100.0 / float32(s.LeafInuse))
+		}
+		fmt.Fprintf(cmd.Stdout, "\tBytes used for inlined buckets: %d (%d%%)\n", s.InlineBucketInuse, percentage)
+
+		return nil
+	})
+}
+
+// Usage returns the help message.
+func (cmd *StatsCommand) Usage() string {
+	return strings.TrimLeft(`
+usage: bolt stats PATH
+
+Stats performs an extensive search of the database to track every page
+reference. It starts at the current meta page and recursively iterates
+through every accessible bucket.
+
+The following errors can be reported:
+
+    already freed
+        The page is referenced more than once in the freelist.
+
+    unreachable unfreed
+        The page is not referenced by a bucket or in the freelist.
+
+    reachable freed
+        The page is referenced by a bucket but is also in the freelist.
+
+    out of bounds
+        A page is referenced that is above the high water mark.
+
+    multiple references
+        A page is referenced by more than one other page.
+
+    invalid type
+        The page type is not "meta", "leaf", "branch", or "freelist".
+
+No errors should occur in your database. However, if for some reason you
+experience corruption, please submit a ticket to the Bolt project page:
+
+  https://github.com/boltdb/bolt/issues
+`, "\n")
+}
+
+var benchBucketName = []byte("bench")
+
+// BenchCommand represents the "bench" command execution.
+type BenchCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewBenchCommand returns a BenchCommand using the
+func newBenchCommand(m *Main) *BenchCommand {
+	return &BenchCommand{
+		Stdin:  m.Stdin,
+		Stdout: m.Stdout,
+		Stderr: m.Stderr,
+	}
+}
+
+// Run executes the "bench" command.
+func (cmd *BenchCommand) Run(args ...string) error {
+	// Parse CLI arguments.
+	options, err := cmd.ParseFlags(args)
+	if err != nil {
+		return err
+	}
+
+	// Remove path if "-work" is not set. Otherwise keep path.
+	if options.Work {
+		fmt.Fprintf(cmd.Stdout, "work: %s\n", options.Path)
+	} else {
+		defer os.Remove(options.Path)
+	}
+
+	// Create database.
+	db, err := bolt.Open(options.Path, 0666, nil)
+	if err != nil {
+		return err
+	}
+	db.NoSync = options.NoSync
+	defer db.Close()
+
+	// Write to the database.
+	var results BenchResults
+	if err := cmd.runWrites(db, options, &results); err != nil {
+		return fmt.Errorf("write: ", err)
+	}
+
+	// Read from the database.
+	if err := cmd.runReads(db, options, &results); err != nil {
+		return fmt.Errorf("bench: read: %s", err)
+	}
+
+	// Print results.
+	fmt.Fprintf(os.Stderr, "# Write\t%v\t(%v/op)\t(%v op/sec)\n", results.WriteDuration, results.WriteOpDuration(), results.WriteOpsPerSecond())
+	fmt.Fprintf(os.Stderr, "# Read\t%v\t(%v/op)\t(%v op/sec)\n", results.ReadDuration, results.ReadOpDuration(), results.ReadOpsPerSecond())
+	fmt.Fprintln(os.Stderr, "")
+	return nil
+}
+
+// ParseFlags parses the command line flags.
+func (cmd *BenchCommand) ParseFlags(args []string) (*BenchOptions, error) {
+	var options BenchOptions
+
+	// Parse flagset.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.StringVar(&options.ProfileMode, "profile-mode", "rw", "")
+	fs.StringVar(&options.WriteMode, "write-mode", "seq", "")
+	fs.StringVar(&options.ReadMode, "read-mode", "seq", "")
+	fs.IntVar(&options.Iterations, "count", 1000, "")
+	fs.IntVar(&options.BatchSize, "batch-size", 0, "")
+	fs.IntVar(&options.KeySize, "key-size", 8, "")
+	fs.IntVar(&options.ValueSize, "value-size", 32, "")
+	fs.StringVar(&options.CPUProfile, "cpuprofile", "", "")
+	fs.StringVar(&options.MemProfile, "memprofile", "", "")
+	fs.StringVar(&options.BlockProfile, "blockprofile", "", "")
+	fs.Float64Var(&options.FillPercent, "fill-percent", bolt.DefaultFillPercent, "")
+	fs.BoolVar(&options.NoSync, "no-sync", false, "")
+	fs.BoolVar(&options.Work, "work", false, "")
+	fs.StringVar(&options.Path, "path", "", "")
+	fs.SetOutput(cmd.Stderr)
+	if err := fs.Parse(args); err != nil {
+		return nil, err
+	}
+
+	// Set batch size to iteration size if not set.
+	// Require that batch size can be evenly divided by the iteration count.
+	if options.BatchSize == 0 {
+		options.BatchSize = options.Iterations
+	} else if options.Iterations%options.BatchSize != 0 {
+		return nil, ErrNonDivisibleBatchSize
+	}
+
+	// Generate temp path if one is not passed in.
+	if options.Path == "" {
+		f, err := ioutil.TempFile("", "bolt-bench-")
+		if err != nil {
+			return nil, fmt.Errorf("temp file: %s", err)
+		}
+		f.Close()
+		os.Remove(f.Name())
+		options.Path = f.Name()
+	}
+
+	return &options, nil
+}
+
+// Writes to the database.
+func (cmd *BenchCommand) runWrites(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	// Start profiling for writes.
+	if options.ProfileMode == "rw" || options.ProfileMode == "w" {
+		cmd.startProfiling(options)
+	}
+
+	t := time.Now()
+
+	var err error
+	switch options.WriteMode {
+	case "seq":
+		err = cmd.runWritesSequential(db, options, results)
+	case "rnd":
+		err = cmd.runWritesRandom(db, options, results)
+	case "seq-nest":
+		err = cmd.runWritesSequentialNested(db, options, results)
+	case "rnd-nest":
+		err = cmd.runWritesRandomNested(db, options, results)
+	default:
+		return fmt.Errorf("invalid write mode: %s", options.WriteMode)
+	}
+
+	// Save time to write.
+	results.WriteDuration = time.Since(t)
+
+	// Stop profiling for writes only.
+	if options.ProfileMode == "w" {
+		cmd.stopProfiling()
+	}
+
+	return err
+}
+
+func (cmd *BenchCommand) runWritesSequential(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	var i = uint32(0)
+	return cmd.runWritesWithSource(db, options, results, func() uint32 { i++; return i })
+}
+
+func (cmd *BenchCommand) runWritesRandom(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	return cmd.runWritesWithSource(db, options, results, func() uint32 { return r.Uint32() })
+}
+
+func (cmd *BenchCommand) runWritesSequentialNested(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	var i = uint32(0)
+	return cmd.runWritesWithSource(db, options, results, func() uint32 { i++; return i })
+}
+
+func (cmd *BenchCommand) runWritesRandomNested(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	return cmd.runWritesWithSource(db, options, results, func() uint32 { return r.Uint32() })
+}
+
+func (cmd *BenchCommand) runWritesWithSource(db *bolt.DB, options *BenchOptions, results *BenchResults, keySource func() uint32) error {
+	results.WriteOps = options.Iterations
+
+	for i := 0; i < options.Iterations; i += options.BatchSize {
+		if err := db.Update(func(tx *bolt.Tx) error {
+			b, _ := tx.CreateBucketIfNotExists(benchBucketName)
+			b.FillPercent = options.FillPercent
+
+			for j := 0; j < options.BatchSize; j++ {
+				key := make([]byte, options.KeySize)
+				value := make([]byte, options.ValueSize)
+
+				// Write key as uint32.
+				binary.BigEndian.PutUint32(key, keySource())
+
+				// Insert key/value.
+				if err := b.Put(key, value); err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (cmd *BenchCommand) runWritesNestedWithSource(db *bolt.DB, options *BenchOptions, results *BenchResults, keySource func() uint32) error {
+	results.WriteOps = options.Iterations
+
+	for i := 0; i < options.Iterations; i += options.BatchSize {
+		if err := db.Update(func(tx *bolt.Tx) error {
+			top, err := tx.CreateBucketIfNotExists(benchBucketName)
+			if err != nil {
+				return err
+			}
+			top.FillPercent = options.FillPercent
+
+			// Create bucket key.
+			name := make([]byte, options.KeySize)
+			binary.BigEndian.PutUint32(name, keySource())
+
+			// Create bucket.
+			b, err := top.CreateBucketIfNotExists(name)
+			if err != nil {
+				return err
+			}
+			b.FillPercent = options.FillPercent
+
+			for j := 0; j < options.BatchSize; j++ {
+				var key = make([]byte, options.KeySize)
+				var value = make([]byte, options.ValueSize)
+
+				// Generate key as uint32.
+				binary.BigEndian.PutUint32(key, keySource())
+
+				// Insert value into subbucket.
+				if err := b.Put(key, value); err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Reads from the database.
+func (cmd *BenchCommand) runReads(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	// Start profiling for reads.
+	if options.ProfileMode == "r" {
+		cmd.startProfiling(options)
+	}
+
+	t := time.Now()
+
+	var err error
+	switch options.ReadMode {
+	case "seq":
+		switch options.WriteMode {
+		case "seq-nest", "rnd-nest":
+			err = cmd.runReadsSequentialNested(db, options, results)
+		default:
+			err = cmd.runReadsSequential(db, options, results)
+		}
+	default:
+		return fmt.Errorf("invalid read mode: %s", options.ReadMode)
+	}
+
+	// Save read time.
+	results.ReadDuration = time.Since(t)
+
+	// Stop profiling for reads.
+	if options.ProfileMode == "rw" || options.ProfileMode == "r" {
+		cmd.stopProfiling()
+	}
+
+	return err
+}
+
+func (cmd *BenchCommand) runReadsSequential(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	return db.View(func(tx *bolt.Tx) error {
+		t := time.Now()
+
+		for {
+			var count int
+
+			c := tx.Bucket(benchBucketName).Cursor()
+			for k, v := c.First(); k != nil; k, v = c.Next() {
+				if v == nil {
+					return errors.New("invalid value")
+				}
+				count++
+			}
+
+			if options.WriteMode == "seq" && count != options.Iterations {
+				return fmt.Errorf("read seq: iter mismatch: expected %d, got %d", options.Iterations, count)
+			}
+
+			results.ReadOps += count
+
+			// Make sure we do this for at least a second.
+			if time.Since(t) >= time.Second {
+				break
+			}
+		}
+
+		return nil
+	})
+}
+
+func (cmd *BenchCommand) runReadsSequentialNested(db *bolt.DB, options *BenchOptions, results *BenchResults) error {
+	return db.View(func(tx *bolt.Tx) error {
+		t := time.Now()
+
+		for {
+			var count int
+			var top = tx.Bucket(benchBucketName)
+			if err := top.ForEach(func(name, _ []byte) error {
+				c := top.Bucket(name).Cursor()
+				for k, v := c.First(); k != nil; k, v = c.Next() {
+					if v == nil {
+						return ErrInvalidValue
+					}
+					count++
+				}
+				return nil
+			}); err != nil {
+				return err
+			}
+
+			if options.WriteMode == "seq-nest" && count != options.Iterations {
+				return fmt.Errorf("read seq-nest: iter mismatch: expected %d, got %d", options.Iterations, count)
+			}
+
+			results.ReadOps += count
+
+			// Make sure we do this for at least a second.
+			if time.Since(t) >= time.Second {
+				break
+			}
+		}
+
+		return nil
+	})
+}
+
+// File handlers for the various profiles.
+var cpuprofile, memprofile, blockprofile *os.File
+
+// Starts all profiles set on the options.
+func (cmd *BenchCommand) startProfiling(options *BenchOptions) {
+	var err error
+
+	// Start CPU profiling.
+	if options.CPUProfile != "" {
+		cpuprofile, err = os.Create(options.CPUProfile)
+		if err != nil {
+			fmt.Fprintf(cmd.Stderr, "bench: could not create cpu profile %q: %v\n", options.CPUProfile, err)
+			os.Exit(1)
+		}
+		pprof.StartCPUProfile(cpuprofile)
+	}
+
+	// Start memory profiling.
+	if options.MemProfile != "" {
+		memprofile, err = os.Create(options.MemProfile)
+		if err != nil {
+			fmt.Fprintf(cmd.Stderr, "bench: could not create memory profile %q: %v\n", options.MemProfile, err)
+			os.Exit(1)
+		}
+		runtime.MemProfileRate = 4096
+	}
+
+	// Start fatal profiling.
+	if options.BlockProfile != "" {
+		blockprofile, err = os.Create(options.BlockProfile)
+		if err != nil {
+			fmt.Fprintf(cmd.Stderr, "bench: could not create block profile %q: %v\n", options.BlockProfile, err)
+			os.Exit(1)
+		}
+		runtime.SetBlockProfileRate(1)
+	}
+}
+
+// Stops all profiles.
+func (cmd *BenchCommand) stopProfiling() {
+	if cpuprofile != nil {
+		pprof.StopCPUProfile()
+		cpuprofile.Close()
+		cpuprofile = nil
+	}
+
+	if memprofile != nil {
+		pprof.Lookup("heap").WriteTo(memprofile, 0)
+		memprofile.Close()
+		memprofile = nil
+	}
+
+	if blockprofile != nil {
+		pprof.Lookup("block").WriteTo(blockprofile, 0)
+		blockprofile.Close()
+		blockprofile = nil
+		runtime.SetBlockProfileRate(0)
+	}
+}
+
+// BenchOptions represents the set of options that can be passed to "bolt bench".
+type BenchOptions struct {
+	ProfileMode   string
+	WriteMode     string
+	ReadMode      string
+	Iterations    int
+	BatchSize     int
+	KeySize       int
+	ValueSize     int
+	CPUProfile    string
+	MemProfile    string
+	BlockProfile  string
+	StatsInterval time.Duration
+	FillPercent   float64
+	NoSync        bool
+	Work          bool
+	Path          string
+}
+
+// BenchResults represents the performance results of the benchmark.
+type BenchResults struct {
+	WriteOps      int
+	WriteDuration time.Duration
+	ReadOps       int
+	ReadDuration  time.Duration
+}
+
+// Returns the duration for a single write operation.
+func (r *BenchResults) WriteOpDuration() time.Duration {
+	if r.WriteOps == 0 {
+		return 0
+	}
+	return r.WriteDuration / time.Duration(r.WriteOps)
+}
+
+// Returns average number of write operations that can be performed per second.
+func (r *BenchResults) WriteOpsPerSecond() int {
+	var op = r.WriteOpDuration()
+	if op == 0 {
+		return 0
+	}
+	return int(time.Second) / int(op)
+}
+
+// Returns the duration for a single read operation.
+func (r *BenchResults) ReadOpDuration() time.Duration {
+	if r.ReadOps == 0 {
+		return 0
+	}
+	return r.ReadDuration / time.Duration(r.ReadOps)
+}
+
+// Returns average number of read operations that can be performed per second.
+func (r *BenchResults) ReadOpsPerSecond() int {
+	var op = r.ReadOpDuration()
+	if op == 0 {
+		return 0
+	}
+	return int(time.Second) / int(op)
+}
+
+type PageError struct {
+	ID  int
+	Err error
+}
+
+func (e *PageError) Error() string {
+	return fmt.Sprintf("page error: id=%d, err=%s", e.ID, e.Err)
+}
+
+// isPrintable returns true if the string is valid unicode and contains only printable runes.
+func isPrintable(s string) bool {
+	if !utf8.ValidString(s) {
+		return false
+	}
+	for _, ch := range s {
+		if !unicode.IsPrint(ch) {
+			return false
+		}
+	}
+	return true
+}
+
+// ReadPage reads page info & full page data from a path.
+// This is not transactionally safe.
+func ReadPage(path string, pageID int) (*page, []byte, error) {
+	// Find page size.
+	pageSize, err := ReadPageSize(path)
+	if err != nil {
+		return nil, nil, fmt.Errorf("read page size: %s", err)
+	}
+
+	// Open database file.
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer f.Close()
+
+	// Read one block into buffer.
+	buf := make([]byte, pageSize)
+	if n, err := f.ReadAt(buf, int64(pageID*pageSize)); err != nil {
+		return nil, nil, err
+	} else if n != len(buf) {
+		return nil, nil, io.ErrUnexpectedEOF
+	}
+
+	// Determine total number of blocks.
+	p := (*page)(unsafe.Pointer(&buf[0]))
+	overflowN := p.overflow
+
+	// Re-read entire page (with overflow) into buffer.
+	buf = make([]byte, (int(overflowN)+1)*pageSize)
+	if n, err := f.ReadAt(buf, int64(pageID*pageSize)); err != nil {
+		return nil, nil, err
+	} else if n != len(buf) {
+		return nil, nil, io.ErrUnexpectedEOF
+	}
+	p = (*page)(unsafe.Pointer(&buf[0]))
+
+	return p, buf, nil
+}
+
+// ReadPageSize reads page size a path.
+// This is not transactionally safe.
+func ReadPageSize(path string) (int, error) {
+	// Open database file.
+	f, err := os.Open(path)
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+
+	// Read 4KB chunk.
+	buf := make([]byte, 4096)
+	if _, err := io.ReadFull(f, buf); err != nil {
+		return 0, err
+	}
+
+	// Read page size from metadata.
+	m := (*meta)(unsafe.Pointer(&buf[PageHeaderSize]))
+	return int(m.pageSize), nil
+}
+
+// atois parses a slice of strings into integers.
+func atois(strs []string) ([]int, error) {
+	var a []int
+	for _, str := range strs {
+		i, err := strconv.Atoi(str)
+		if err != nil {
+			return nil, err
+		}
+		a = append(a, i)
+	}
+	return a, nil
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+const maxAllocSize = 0xFFFFFFF
+
+// DO NOT EDIT. Copied from the "bolt" package.
+const (
+	branchPageFlag   = 0x01
+	leafPageFlag     = 0x02
+	metaPageFlag     = 0x04
+	freelistPageFlag = 0x10
+)
+
+// DO NOT EDIT. Copied from the "bolt" package.
+const bucketLeafFlag = 0x01
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type pgid uint64
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type txid uint64
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type meta struct {
+	magic    uint32
+	version  uint32
+	pageSize uint32
+	flags    uint32
+	root     bucket
+	freelist pgid
+	pgid     pgid
+	txid     txid
+	checksum uint64
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type bucket struct {
+	root     pgid
+	sequence uint64
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type page struct {
+	id       pgid
+	flags    uint16
+	count    uint16
+	overflow uint32
+	ptr      uintptr
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+func (p *page) Type() string {
+	if (p.flags & branchPageFlag) != 0 {
+		return "branch"
+	} else if (p.flags & leafPageFlag) != 0 {
+		return "leaf"
+	} else if (p.flags & metaPageFlag) != 0 {
+		return "meta"
+	} else if (p.flags & freelistPageFlag) != 0 {
+		return "freelist"
+	}
+	return fmt.Sprintf("unknown<%02x>", p.flags)
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+func (p *page) leafPageElement(index uint16) *leafPageElement {
+	n := &((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index]
+	return n
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+func (p *page) branchPageElement(index uint16) *branchPageElement {
+	return &((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[index]
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type branchPageElement struct {
+	pos   uint32
+	ksize uint32
+	pgid  pgid
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+func (n *branchPageElement) key() []byte {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
+	return buf[n.pos : n.pos+n.ksize]
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+type leafPageElement struct {
+	flags uint32
+	pos   uint32
+	ksize uint32
+	vsize uint32
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+func (n *leafPageElement) key() []byte {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
+	return buf[n.pos : n.pos+n.ksize]
+}
+
+// DO NOT EDIT. Copied from the "bolt" package.
+func (n *leafPageElement) value() []byte {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
+	return buf[n.pos+n.ksize : n.pos+n.ksize+n.vsize]
+}
diff --git a/vendor/github.com/boltdb/bolt/cursor.go b/vendor/github.com/boltdb/bolt/cursor.go
new file mode 100644
index 00000000..006c5488
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/cursor.go
@@ -0,0 +1,384 @@
+package bolt
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+)
+
+// Cursor represents an iterator that can traverse over all key/value pairs in a bucket in sorted order.
+// Cursors see nested buckets with value == nil.
+// Cursors can be obtained from a transaction and are valid as long as the transaction is open.
+//
+// Keys and values returned from the cursor are only valid for the life of the transaction.
+//
+// Changing data while traversing with a cursor may cause it to be invalidated
+// and return unexpected keys and/or values. You must reposition your cursor
+// after mutating data.
+type Cursor struct {
+	bucket *Bucket
+	stack  []elemRef
+}
+
+// Bucket returns the bucket that this cursor was created from.
+func (c *Cursor) Bucket() *Bucket {
+	return c.bucket
+}
+
+// First moves the cursor to the first item in the bucket and returns its key and value.
+// If the bucket is empty then a nil key and value are returned.
+// The returned key and value are only valid for the life of the transaction.
+func (c *Cursor) First() (key []byte, value []byte) {
+	_assert(c.bucket.tx.db != nil, "tx closed")
+	c.stack = c.stack[:0]
+	p, n := c.bucket.pageNode(c.bucket.root)
+	c.stack = append(c.stack, elemRef{page: p, node: n, index: 0})
+	c.first()
+	k, v, flags := c.keyValue()
+	if (flags & uint32(bucketLeafFlag)) != 0 {
+		return k, nil
+	}
+	return k, v
+
+}
+
+// Last moves the cursor to the last item in the bucket and returns its key and value.
+// If the bucket is empty then a nil key and value are returned.
+// The returned key and value are only valid for the life of the transaction.
+func (c *Cursor) Last() (key []byte, value []byte) {
+	_assert(c.bucket.tx.db != nil, "tx closed")
+	c.stack = c.stack[:0]
+	p, n := c.bucket.pageNode(c.bucket.root)
+	ref := elemRef{page: p, node: n}
+	ref.index = ref.count() - 1
+	c.stack = append(c.stack, ref)
+	c.last()
+	k, v, flags := c.keyValue()
+	if (flags & uint32(bucketLeafFlag)) != 0 {
+		return k, nil
+	}
+	return k, v
+}
+
+// Next moves the cursor to the next item in the bucket and returns its key and value.
+// If the cursor is at the end of the bucket then a nil key and value are returned.
+// The returned key and value are only valid for the life of the transaction.
+func (c *Cursor) Next() (key []byte, value []byte) {
+	_assert(c.bucket.tx.db != nil, "tx closed")
+	k, v, flags := c.next()
+	if (flags & uint32(bucketLeafFlag)) != 0 {
+		return k, nil
+	}
+	return k, v
+}
+
+// Prev moves the cursor to the previous item in the bucket and returns its key and value.
+// If the cursor is at the beginning of the bucket then a nil key and value are returned.
+// The returned key and value are only valid for the life of the transaction.
+func (c *Cursor) Prev() (key []byte, value []byte) {
+	_assert(c.bucket.tx.db != nil, "tx closed")
+
+	// Attempt to move back one element until we're successful.
+	// Move up the stack as we hit the beginning of each page in our stack.
+	for i := len(c.stack) - 1; i >= 0; i-- {
+		elem := &c.stack[i]
+		if elem.index > 0 {
+			elem.index--
+			break
+		}
+		c.stack = c.stack[:i]
+	}
+
+	// If we've hit the end then return nil.
+	if len(c.stack) == 0 {
+		return nil, nil
+	}
+
+	// Move down the stack to find the last element of the last leaf under this branch.
+	c.last()
+	k, v, flags := c.keyValue()
+	if (flags & uint32(bucketLeafFlag)) != 0 {
+		return k, nil
+	}
+	return k, v
+}
+
+// Seek moves the cursor to a given key and returns it.
+// If the key does not exist then the next key is used. If no keys
+// follow, a nil key is returned.
+// The returned key and value are only valid for the life of the transaction.
+func (c *Cursor) Seek(seek []byte) (key []byte, value []byte) {
+	k, v, flags := c.seek(seek)
+
+	// If we ended up after the last element of a page then move to the next one.
+	if ref := &c.stack[len(c.stack)-1]; ref.index >= ref.count() {
+		k, v, flags = c.next()
+	}
+
+	if k == nil {
+		return nil, nil
+	} else if (flags & uint32(bucketLeafFlag)) != 0 {
+		return k, nil
+	}
+	return k, v
+}
+
+// Delete removes the current key/value under the cursor from the bucket.
+// Delete fails if current key/value is a bucket or if the transaction is not writable.
+func (c *Cursor) Delete() error {
+	if c.bucket.tx.db == nil {
+		return ErrTxClosed
+	} else if !c.bucket.Writable() {
+		return ErrTxNotWritable
+	}
+
+	key, _, flags := c.keyValue()
+	// Return an error if current value is a bucket.
+	if (flags & bucketLeafFlag) != 0 {
+		return ErrIncompatibleValue
+	}
+	c.node().del(key)
+
+	return nil
+}
+
+// seek moves the cursor to a given key and returns it.
+// If the key does not exist then the next key is used.
+func (c *Cursor) seek(seek []byte) (key []byte, value []byte, flags uint32) {
+	_assert(c.bucket.tx.db != nil, "tx closed")
+
+	// Start from root page/node and traverse to correct page.
+	c.stack = c.stack[:0]
+	c.search(seek, c.bucket.root)
+	ref := &c.stack[len(c.stack)-1]
+
+	// If the cursor is pointing to the end of page/node then return nil.
+	if ref.index >= ref.count() {
+		return nil, nil, 0
+	}
+
+	// If this is a bucket then return a nil value.
+	return c.keyValue()
+}
+
+// first moves the cursor to the first leaf element under the last page in the stack.
+func (c *Cursor) first() {
+	for {
+		// Exit when we hit a leaf page.
+		var ref = &c.stack[len(c.stack)-1]
+		if ref.isLeaf() {
+			break
+		}
+
+		// Keep adding pages pointing to the first element to the stack.
+		var pgid pgid
+		if ref.node != nil {
+			pgid = ref.node.inodes[ref.index].pgid
+		} else {
+			pgid = ref.page.branchPageElement(uint16(ref.index)).pgid
+		}
+		p, n := c.bucket.pageNode(pgid)
+		c.stack = append(c.stack, elemRef{page: p, node: n, index: 0})
+	}
+}
+
+// last moves the cursor to the last leaf element under the last page in the stack.
+func (c *Cursor) last() {
+	for {
+		// Exit when we hit a leaf page.
+		ref := &c.stack[len(c.stack)-1]
+		if ref.isLeaf() {
+			break
+		}
+
+		// Keep adding pages pointing to the last element in the stack.
+		var pgid pgid
+		if ref.node != nil {
+			pgid = ref.node.inodes[ref.index].pgid
+		} else {
+			pgid = ref.page.branchPageElement(uint16(ref.index)).pgid
+		}
+		p, n := c.bucket.pageNode(pgid)
+
+		var nextRef = elemRef{page: p, node: n}
+		nextRef.index = nextRef.count() - 1
+		c.stack = append(c.stack, nextRef)
+	}
+}
+
+// next moves to the next leaf element and returns the key and value.
+// If the cursor is at the last leaf element then it stays there and returns nil.
+func (c *Cursor) next() (key []byte, value []byte, flags uint32) {
+	// Attempt to move over one element until we're successful.
+	// Move up the stack as we hit the end of each page in our stack.
+	var i int
+	for i = len(c.stack) - 1; i >= 0; i-- {
+		elem := &c.stack[i]
+		if elem.index < elem.count()-1 {
+			elem.index++
+			break
+		}
+	}
+
+	// If we've hit the root page then stop and return. This will leave the
+	// cursor on the last element of the last page.
+	if i == -1 {
+		return nil, nil, 0
+	}
+
+	// Otherwise start from where we left off in the stack and find the
+	// first element of the first leaf page.
+	c.stack = c.stack[:i+1]
+	c.first()
+	return c.keyValue()
+}
+
+// search recursively performs a binary search against a given page/node until it finds a given key.
+func (c *Cursor) search(key []byte, pgid pgid) {
+	p, n := c.bucket.pageNode(pgid)
+	if p != nil && (p.flags&(branchPageFlag|leafPageFlag)) == 0 {
+		panic(fmt.Sprintf("invalid page type: %d: %x", p.id, p.flags))
+	}
+	e := elemRef{page: p, node: n}
+	c.stack = append(c.stack, e)
+
+	// If we're on a leaf page/node then find the specific node.
+	if e.isLeaf() {
+		c.nsearch(key)
+		return
+	}
+
+	if n != nil {
+		c.searchNode(key, n)
+		return
+	}
+	c.searchPage(key, p)
+}
+
+func (c *Cursor) searchNode(key []byte, n *node) {
+	var exact bool
+	index := sort.Search(len(n.inodes), func(i int) bool {
+		// TODO(benbjohnson): Optimize this range search. It's a bit hacky right now.
+		// sort.Search() finds the lowest index where f() != -1 but we need the highest index.
+		ret := bytes.Compare(n.inodes[i].key, key)
+		if ret == 0 {
+			exact = true
+		}
+		return ret != -1
+	})
+	if !exact && index > 0 {
+		index--
+	}
+	c.stack[len(c.stack)-1].index = index
+
+	// Recursively search to the next page.
+	c.search(key, n.inodes[index].pgid)
+}
+
+func (c *Cursor) searchPage(key []byte, p *page) {
+	// Binary search for the correct range.
+	inodes := p.branchPageElements()
+
+	var exact bool
+	index := sort.Search(int(p.count), func(i int) bool {
+		// TODO(benbjohnson): Optimize this range search. It's a bit hacky right now.
+		// sort.Search() finds the lowest index where f() != -1 but we need the highest index.
+		ret := bytes.Compare(inodes[i].key(), key)
+		if ret == 0 {
+			exact = true
+		}
+		return ret != -1
+	})
+	if !exact && index > 0 {
+		index--
+	}
+	c.stack[len(c.stack)-1].index = index
+
+	// Recursively search to the next page.
+	c.search(key, inodes[index].pgid)
+}
+
+// nsearch searches the leaf node on the top of the stack for a key.
+func (c *Cursor) nsearch(key []byte) {
+	e := &c.stack[len(c.stack)-1]
+	p, n := e.page, e.node
+
+	// If we have a node then search its inodes.
+	if n != nil {
+		index := sort.Search(len(n.inodes), func(i int) bool {
+			return bytes.Compare(n.inodes[i].key, key) != -1
+		})
+		e.index = index
+		return
+	}
+
+	// If we have a page then search its leaf elements.
+	inodes := p.leafPageElements()
+	index := sort.Search(int(p.count), func(i int) bool {
+		return bytes.Compare(inodes[i].key(), key) != -1
+	})
+	e.index = index
+}
+
+// keyValue returns the key and value of the current leaf element.
+func (c *Cursor) keyValue() ([]byte, []byte, uint32) {
+	ref := &c.stack[len(c.stack)-1]
+	if ref.count() == 0 || ref.index >= ref.count() {
+		return nil, nil, 0
+	}
+
+	// Retrieve value from node.
+	if ref.node != nil {
+		inode := &ref.node.inodes[ref.index]
+		return inode.key, inode.value, inode.flags
+	}
+
+	// Or retrieve value from page.
+	elem := ref.page.leafPageElement(uint16(ref.index))
+	return elem.key(), elem.value(), elem.flags
+}
+
+// node returns the node that the cursor is currently positioned on.
+func (c *Cursor) node() *node {
+	_assert(len(c.stack) > 0, "accessing a node with a zero-length cursor stack")
+
+	// If the top of the stack is a leaf node then just return it.
+	if ref := &c.stack[len(c.stack)-1]; ref.node != nil && ref.isLeaf() {
+		return ref.node
+	}
+
+	// Start from root and traverse down the hierarchy.
+	var n = c.stack[0].node
+	if n == nil {
+		n = c.bucket.node(c.stack[0].page.id, nil)
+	}
+	for _, ref := range c.stack[:len(c.stack)-1] {
+		_assert(!n.isLeaf, "expected branch node")
+		n = n.childAt(int(ref.index))
+	}
+	_assert(n.isLeaf, "expected leaf node")
+	return n
+}
+
+// elemRef represents a reference to an element on a given page/node.
+type elemRef struct {
+	page  *page
+	node  *node
+	index int
+}
+
+// isLeaf returns whether the ref is pointing at a leaf page/node.
+func (r *elemRef) isLeaf() bool {
+	if r.node != nil {
+		return r.node.isLeaf
+	}
+	return (r.page.flags & leafPageFlag) != 0
+}
+
+// count returns the number of inodes or page elements.
+func (r *elemRef) count() int {
+	if r.node != nil {
+		return len(r.node.inodes)
+	}
+	return int(r.page.count)
+}
diff --git a/vendor/github.com/boltdb/bolt/db.go b/vendor/github.com/boltdb/bolt/db.go
new file mode 100644
index 00000000..d39c4aa9
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/db.go
@@ -0,0 +1,792 @@
+package bolt
+
+import (
+	"fmt"
+	"hash/fnv"
+	"os"
+	"runtime"
+	"runtime/debug"
+	"strings"
+	"sync"
+	"time"
+	"unsafe"
+)
+
+// The largest step that can be taken when remapping the mmap.
+const maxMmapStep = 1 << 30 // 1GB
+
+// The data file format version.
+const version = 2
+
+// Represents a marker value to indicate that a file is a Bolt DB.
+const magic uint32 = 0xED0CDAED
+
+// IgnoreNoSync specifies whether the NoSync field of a DB is ignored when
+// syncing changes to a file.  This is required as some operating systems,
+// such as OpenBSD, do not have a unified buffer cache (UBC) and writes
+// must be synchronzied using the msync(2) syscall.
+const IgnoreNoSync = runtime.GOOS == "openbsd"
+
+// Default values if not set in a DB instance.
+const (
+	DefaultMaxBatchSize  int = 1000
+	DefaultMaxBatchDelay     = 10 * time.Millisecond
+)
+
+// DB represents a collection of buckets persisted to a file on disk.
+// All data access is performed through transactions which can be obtained through the DB.
+// All the functions on DB will return a ErrDatabaseNotOpen if accessed before Open() is called.
+type DB struct {
+	// When enabled, the database will perform a Check() after every commit.
+	// A panic is issued if the database is in an inconsistent state. This
+	// flag has a large performance impact so it should only be used for
+	// debugging purposes.
+	StrictMode bool
+
+	// Setting the NoSync flag will cause the database to skip fsync()
+	// calls after each commit. This can be useful when bulk loading data
+	// into a database and you can restart the bulk load in the event of
+	// a system failure or database corruption. Do not set this flag for
+	// normal use.
+	//
+	// If the package global IgnoreNoSync constant is true, this value is
+	// ignored.  See the comment on that constant for more details.
+	//
+	// THIS IS UNSAFE. PLEASE USE WITH CAUTION.
+	NoSync bool
+
+	// When true, skips the truncate call when growing the database.
+	// Setting this to true is only safe on non-ext3/ext4 systems.
+	// Skipping truncation avoids preallocation of hard drive space and
+	// bypasses a truncate() and fsync() syscall on remapping.
+	//
+	// https://github.com/boltdb/bolt/issues/284
+	NoGrowSync bool
+
+	// MaxBatchSize is the maximum size of a batch. Default value is
+	// copied from DefaultMaxBatchSize in Open.
+	//
+	// If <=0, disables batching.
+	//
+	// Do not change concurrently with calls to Batch.
+	MaxBatchSize int
+
+	// MaxBatchDelay is the maximum delay before a batch starts.
+	// Default value is copied from DefaultMaxBatchDelay in Open.
+	//
+	// If <=0, effectively disables batching.
+	//
+	// Do not change concurrently with calls to Batch.
+	MaxBatchDelay time.Duration
+
+	path     string
+	file     *os.File
+	dataref  []byte // mmap'ed readonly, write throws SEGV
+	data     *[maxMapSize]byte
+	datasz   int
+	meta0    *meta
+	meta1    *meta
+	pageSize int
+	opened   bool
+	rwtx     *Tx
+	txs      []*Tx
+	freelist *freelist
+	stats    Stats
+
+	batchMu sync.Mutex
+	batch   *batch
+
+	rwlock   sync.Mutex   // Allows only one writer at a time.
+	metalock sync.Mutex   // Protects meta page access.
+	mmaplock sync.RWMutex // Protects mmap access during remapping.
+	statlock sync.RWMutex // Protects stats access.
+
+	ops struct {
+		writeAt func(b []byte, off int64) (n int, err error)
+	}
+
+	// Read only mode.
+	// When true, Update() and Begin(true) return ErrDatabaseReadOnly immediately.
+	readOnly bool
+}
+
+// Path returns the path to currently open database file.
+func (db *DB) Path() string {
+	return db.path
+}
+
+// GoString returns the Go string representation of the database.
+func (db *DB) GoString() string {
+	return fmt.Sprintf("bolt.DB{path:%q}", db.path)
+}
+
+// String returns the string representation of the database.
+func (db *DB) String() string {
+	return fmt.Sprintf("DB<%q>", db.path)
+}
+
+// Open creates and opens a database at the given path.
+// If the file does not exist then it will be created automatically.
+// Passing in nil options will cause Bolt to open the database with the default options.
+func Open(path string, mode os.FileMode, options *Options) (*DB, error) {
+	var db = &DB{opened: true}
+
+	// Set default options if no options are provided.
+	if options == nil {
+		options = DefaultOptions
+	}
+	db.NoGrowSync = options.NoGrowSync
+
+	// Set default values for later DB operations.
+	db.MaxBatchSize = DefaultMaxBatchSize
+	db.MaxBatchDelay = DefaultMaxBatchDelay
+
+	flag := os.O_RDWR
+	if options.ReadOnly {
+		flag = os.O_RDONLY
+		db.readOnly = true
+	}
+
+	// Open data file and separate sync handler for metadata writes.
+	db.path = path
+	var err error
+	if db.file, err = os.OpenFile(db.path, flag|os.O_CREATE, mode); err != nil {
+		_ = db.close()
+		return nil, err
+	}
+
+	// Lock file so that other processes using Bolt in read-write mode cannot
+	// use the database  at the same time. This would cause corruption since
+	// the two processes would write meta pages and free pages separately.
+	// The database file is locked exclusively (only one process can grab the lock)
+	// if !options.ReadOnly.
+	// The database file is locked using the shared lock (more than one process may
+	// hold a lock at the same time) otherwise (options.ReadOnly is set).
+	if err := flock(db.file, !db.readOnly, options.Timeout); err != nil {
+		_ = db.close()
+		return nil, err
+	}
+
+	// Default values for test hooks
+	db.ops.writeAt = db.file.WriteAt
+
+	// Initialize the database if it doesn't exist.
+	if info, err := db.file.Stat(); err != nil {
+		return nil, fmt.Errorf("stat error: %s", err)
+	} else if info.Size() == 0 {
+		// Initialize new files with meta pages.
+		if err := db.init(); err != nil {
+			return nil, err
+		}
+	} else {
+		// Read the first meta page to determine the page size.
+		var buf [0x1000]byte
+		if _, err := db.file.ReadAt(buf[:], 0); err == nil {
+			m := db.pageInBuffer(buf[:], 0).meta()
+			if err := m.validate(); err != nil {
+				return nil, fmt.Errorf("meta0 error: %s", err)
+			}
+			db.pageSize = int(m.pageSize)
+		}
+	}
+
+	// Memory map the data file.
+	if err := db.mmap(0); err != nil {
+		_ = db.close()
+		return nil, err
+	}
+
+	// Read in the freelist.
+	db.freelist = newFreelist()
+	db.freelist.read(db.page(db.meta().freelist))
+
+	// Mark the database as opened and return.
+	return db, nil
+}
+
+// mmap opens the underlying memory-mapped file and initializes the meta references.
+// minsz is the minimum size that the new mmap can be.
+func (db *DB) mmap(minsz int) error {
+	db.mmaplock.Lock()
+	defer db.mmaplock.Unlock()
+
+	info, err := db.file.Stat()
+	if err != nil {
+		return fmt.Errorf("mmap stat error: %s", err)
+	} else if int(info.Size()) < db.pageSize*2 {
+		return fmt.Errorf("file size too small")
+	}
+
+	// Ensure the size is at least the minimum size.
+	var size = int(info.Size())
+	if size < minsz {
+		size = minsz
+	}
+	size, err = db.mmapSize(size)
+	if err != nil {
+		return err
+	}
+
+	// Dereference all mmap references before unmapping.
+	if db.rwtx != nil {
+		db.rwtx.root.dereference()
+	}
+
+	// Unmap existing data before continuing.
+	if err := db.munmap(); err != nil {
+		return err
+	}
+
+	// Memory-map the data file as a byte slice.
+	if err := mmap(db, size); err != nil {
+		return err
+	}
+
+	// Save references to the meta pages.
+	db.meta0 = db.page(0).meta()
+	db.meta1 = db.page(1).meta()
+
+	// Validate the meta pages.
+	if err := db.meta0.validate(); err != nil {
+		return fmt.Errorf("meta0 error: %s", err)
+	}
+	if err := db.meta1.validate(); err != nil {
+		return fmt.Errorf("meta1 error: %s", err)
+	}
+
+	return nil
+}
+
+// munmap unmaps the data file from memory.
+func (db *DB) munmap() error {
+	if err := munmap(db); err != nil {
+		return fmt.Errorf("unmap error: " + err.Error())
+	}
+	return nil
+}
+
+// mmapSize determines the appropriate size for the mmap given the current size
+// of the database. The minimum size is 1MB and doubles until it reaches 1GB.
+// Returns an error if the new mmap size is greater than the max allowed.
+func (db *DB) mmapSize(size int) (int, error) {
+	// Double the size from 32KB until 1GB.
+	for i := uint(15); i <= 30; i++ {
+		if size <= 1<<i {
+			return 1 << i, nil
+		}
+	}
+
+	// Verify the requested size is not above the maximum allowed.
+	if size > maxMapSize {
+		return 0, fmt.Errorf("mmap too large")
+	}
+
+	// If larger than 1GB then grow by 1GB at a time.
+	sz := int64(size)
+	if remainder := sz % int64(maxMmapStep); remainder > 0 {
+		sz += int64(maxMmapStep) - remainder
+	}
+
+	// Ensure that the mmap size is a multiple of the page size.
+	// This should always be true since we're incrementing in MBs.
+	pageSize := int64(db.pageSize)
+	if (sz % pageSize) != 0 {
+		sz = ((sz / pageSize) + 1) * pageSize
+	}
+
+	// If we've exceeded the max size then only grow up to the max size.
+	if sz > maxMapSize {
+		sz = maxMapSize
+	}
+
+	return int(sz), nil
+}
+
+// init creates a new database file and initializes its meta pages.
+func (db *DB) init() error {
+	// Set the page size to the OS page size.
+	db.pageSize = os.Getpagesize()
+
+	// Create two meta pages on a buffer.
+	buf := make([]byte, db.pageSize*4)
+	for i := 0; i < 2; i++ {
+		p := db.pageInBuffer(buf[:], pgid(i))
+		p.id = pgid(i)
+		p.flags = metaPageFlag
+
+		// Initialize the meta page.
+		m := p.meta()
+		m.magic = magic
+		m.version = version
+		m.pageSize = uint32(db.pageSize)
+		m.freelist = 2
+		m.root = bucket{root: 3}
+		m.pgid = 4
+		m.txid = txid(i)
+	}
+
+	// Write an empty freelist at page 3.
+	p := db.pageInBuffer(buf[:], pgid(2))
+	p.id = pgid(2)
+	p.flags = freelistPageFlag
+	p.count = 0
+
+	// Write an empty leaf page at page 4.
+	p = db.pageInBuffer(buf[:], pgid(3))
+	p.id = pgid(3)
+	p.flags = leafPageFlag
+	p.count = 0
+
+	// Write the buffer to our data file.
+	if _, err := db.ops.writeAt(buf, 0); err != nil {
+		return err
+	}
+	if err := fdatasync(db); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Close releases all database resources.
+// All transactions must be closed before closing the database.
+func (db *DB) Close() error {
+	db.rwlock.Lock()
+	defer db.rwlock.Unlock()
+
+	db.metalock.Lock()
+	defer db.metalock.Unlock()
+
+	db.mmaplock.RLock()
+	defer db.mmaplock.RUnlock()
+
+	return db.close()
+}
+
+func (db *DB) close() error {
+	db.opened = false
+
+	db.freelist = nil
+	db.path = ""
+
+	// Clear ops.
+	db.ops.writeAt = nil
+
+	// Close the mmap.
+	if err := db.munmap(); err != nil {
+		return err
+	}
+
+	// Close file handles.
+	if db.file != nil {
+		// No need to unlock read-only file.
+		if !db.readOnly {
+			// Unlock the file.
+			_ = funlock(db.file)
+		}
+
+		// Close the file descriptor.
+		if err := db.file.Close(); err != nil {
+			return fmt.Errorf("db file close: %s", err)
+		}
+		db.file = nil
+	}
+
+	return nil
+}
+
+// Begin starts a new transaction.
+// Multiple read-only transactions can be used concurrently but only one
+// write transaction can be used at a time. Starting multiple write transactions
+// will cause the calls to block and be serialized until the current write
+// transaction finishes.
+//
+// Transactions should not be depedent on one another. Opening a read
+// transaction and a write transaction in the same goroutine can cause the
+// writer to deadlock because the database periodically needs to re-mmap itself
+// as it grows and it cannot do that while a read transaction is open.
+//
+// IMPORTANT: You must close read-only transactions after you are finished or
+// else the database will not reclaim old pages.
+func (db *DB) Begin(writable bool) (*Tx, error) {
+	if writable {
+		return db.beginRWTx()
+	}
+	return db.beginTx()
+}
+
+func (db *DB) beginTx() (*Tx, error) {
+	// Lock the meta pages while we initialize the transaction. We obtain
+	// the meta lock before the mmap lock because that's the order that the
+	// write transaction will obtain them.
+	db.metalock.Lock()
+
+	// Obtain a read-only lock on the mmap. When the mmap is remapped it will
+	// obtain a write lock so all transactions must finish before it can be
+	// remapped.
+	db.mmaplock.RLock()
+
+	// Exit if the database is not open yet.
+	if !db.opened {
+		db.mmaplock.RUnlock()
+		db.metalock.Unlock()
+		return nil, ErrDatabaseNotOpen
+	}
+
+	// Create a transaction associated with the database.
+	t := &Tx{}
+	t.init(db)
+
+	// Keep track of transaction until it closes.
+	db.txs = append(db.txs, t)
+	n := len(db.txs)
+
+	// Unlock the meta pages.
+	db.metalock.Unlock()
+
+	// Update the transaction stats.
+	db.statlock.Lock()
+	db.stats.TxN++
+	db.stats.OpenTxN = n
+	db.statlock.Unlock()
+
+	return t, nil
+}
+
+func (db *DB) beginRWTx() (*Tx, error) {
+	// If the database was opened with Options.ReadOnly, return an error.
+	if db.readOnly {
+		return nil, ErrDatabaseReadOnly
+	}
+
+	// Obtain writer lock. This is released by the transaction when it closes.
+	// This enforces only one writer transaction at a time.
+	db.rwlock.Lock()
+
+	// Once we have the writer lock then we can lock the meta pages so that
+	// we can set up the transaction.
+	db.metalock.Lock()
+	defer db.metalock.Unlock()
+
+	// Exit if the database is not open yet.
+	if !db.opened {
+		db.rwlock.Unlock()
+		return nil, ErrDatabaseNotOpen
+	}
+
+	// Create a transaction associated with the database.
+	t := &Tx{writable: true}
+	t.init(db)
+	db.rwtx = t
+
+	// Free any pages associated with closed read-only transactions.
+	var minid txid = 0xFFFFFFFFFFFFFFFF
+	for _, t := range db.txs {
+		if t.meta.txid < minid {
+			minid = t.meta.txid
+		}
+	}
+	if minid > 0 {
+		db.freelist.release(minid - 1)
+	}
+
+	return t, nil
+}
+
+// removeTx removes a transaction from the database.
+func (db *DB) removeTx(tx *Tx) {
+	// Release the read lock on the mmap.
+	db.mmaplock.RUnlock()
+
+	// Use the meta lock to restrict access to the DB object.
+	db.metalock.Lock()
+
+	// Remove the transaction.
+	for i, t := range db.txs {
+		if t == tx {
+			db.txs = append(db.txs[:i], db.txs[i+1:]...)
+			break
+		}
+	}
+	n := len(db.txs)
+
+	// Unlock the meta pages.
+	db.metalock.Unlock()
+
+	// Merge statistics.
+	db.statlock.Lock()
+	db.stats.OpenTxN = n
+	db.stats.TxStats.add(&tx.stats)
+	db.statlock.Unlock()
+}
+
+// Update executes a function within the context of a read-write managed transaction.
+// If no error is returned from the function then the transaction is committed.
+// If an error is returned then the entire transaction is rolled back.
+// Any error that is returned from the function or returned from the commit is
+// returned from the Update() method.
+//
+// Attempting to manually commit or rollback within the function will cause a panic.
+func (db *DB) Update(fn func(*Tx) error) error {
+	t, err := db.Begin(true)
+	if err != nil {
+		return err
+	}
+
+	// Make sure the transaction rolls back in the event of a panic.
+	defer func() {
+		if t.db != nil {
+			t.rollback()
+		}
+	}()
+
+	// Mark as a managed tx so that the inner function cannot manually commit.
+	t.managed = true
+
+	// If an error is returned from the function then rollback and return error.
+	err = fn(t)
+	t.managed = false
+	if err != nil {
+		_ = t.Rollback()
+		return err
+	}
+
+	return t.Commit()
+}
+
+// View executes a function within the context of a managed read-only transaction.
+// Any error that is returned from the function is returned from the View() method.
+//
+// Attempting to manually rollback within the function will cause a panic.
+func (db *DB) View(fn func(*Tx) error) error {
+	t, err := db.Begin(false)
+	if err != nil {
+		return err
+	}
+
+	// Make sure the transaction rolls back in the event of a panic.
+	defer func() {
+		if t.db != nil {
+			t.rollback()
+		}
+	}()
+
+	// Mark as a managed tx so that the inner function cannot manually rollback.
+	t.managed = true
+
+	// If an error is returned from the function then pass it through.
+	err = fn(t)
+	t.managed = false
+	if err != nil {
+		_ = t.Rollback()
+		return err
+	}
+
+	if err := t.Rollback(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Sync executes fdatasync() against the database file handle.
+//
+// This is not necessary under normal operation, however, if you use NoSync
+// then it allows you to force the database file to sync against the disk.
+func (db *DB) Sync() error { return fdatasync(db) }
+
+// Stats retrieves ongoing performance stats for the database.
+// This is only updated when a transaction closes.
+func (db *DB) Stats() Stats {
+	db.statlock.RLock()
+	defer db.statlock.RUnlock()
+	return db.stats
+}
+
+// This is for internal access to the raw data bytes from the C cursor, use
+// carefully, or not at all.
+func (db *DB) Info() *Info {
+	return &Info{uintptr(unsafe.Pointer(&db.data[0])), db.pageSize}
+}
+
+// page retrieves a page reference from the mmap based on the current page size.
+func (db *DB) page(id pgid) *page {
+	pos := id * pgid(db.pageSize)
+	return (*page)(unsafe.Pointer(&db.data[pos]))
+}
+
+// pageInBuffer retrieves a page reference from a given byte array based on the current page size.
+func (db *DB) pageInBuffer(b []byte, id pgid) *page {
+	return (*page)(unsafe.Pointer(&b[id*pgid(db.pageSize)]))
+}
+
+// meta retrieves the current meta page reference.
+func (db *DB) meta() *meta {
+	if db.meta0.txid > db.meta1.txid {
+		return db.meta0
+	}
+	return db.meta1
+}
+
+// allocate returns a contiguous block of memory starting at a given page.
+func (db *DB) allocate(count int) (*page, error) {
+	// Allocate a temporary buffer for the page.
+	buf := make([]byte, count*db.pageSize)
+	p := (*page)(unsafe.Pointer(&buf[0]))
+	p.overflow = uint32(count - 1)
+
+	// Use pages from the freelist if they are available.
+	if p.id = db.freelist.allocate(count); p.id != 0 {
+		return p, nil
+	}
+
+	// Resize mmap() if we're at the end.
+	p.id = db.rwtx.meta.pgid
+	var minsz = int((p.id+pgid(count))+1) * db.pageSize
+	if minsz >= db.datasz {
+		if err := db.mmap(minsz); err != nil {
+			return nil, fmt.Errorf("mmap allocate error: %s", err)
+		}
+	}
+
+	// Move the page id high water mark.
+	db.rwtx.meta.pgid += pgid(count)
+
+	return p, nil
+}
+
+func (db *DB) IsReadOnly() bool {
+	return db.readOnly
+}
+
+// Options represents the options that can be set when opening a database.
+type Options struct {
+	// Timeout is the amount of time to wait to obtain a file lock.
+	// When set to zero it will wait indefinitely. This option is only
+	// available on Darwin and Linux.
+	Timeout time.Duration
+
+	// Sets the DB.NoGrowSync flag before memory mapping the file.
+	NoGrowSync bool
+
+	// Open database in read-only mode. Uses flock(..., LOCK_SH |LOCK_NB) to
+	// grab a shared lock (UNIX).
+	ReadOnly bool
+}
+
+// DefaultOptions represent the options used if nil options are passed into Open().
+// No timeout is used which will cause Bolt to wait indefinitely for a lock.
+var DefaultOptions = &Options{
+	Timeout:    0,
+	NoGrowSync: false,
+}
+
+// Stats represents statistics about the database.
+type Stats struct {
+	// Freelist stats
+	FreePageN     int // total number of free pages on the freelist
+	PendingPageN  int // total number of pending pages on the freelist
+	FreeAlloc     int // total bytes allocated in free pages
+	FreelistInuse int // total bytes used by the freelist
+
+	// Transaction stats
+	TxN     int // total number of started read transactions
+	OpenTxN int // number of currently open read transactions
+
+	TxStats TxStats // global, ongoing stats.
+}
+
+// Sub calculates and returns the difference between two sets of database stats.
+// This is useful when obtaining stats at two different points and time and
+// you need the performance counters that occurred within that time span.
+func (s *Stats) Sub(other *Stats) Stats {
+	if other == nil {
+		return *s
+	}
+	var diff Stats
+	diff.FreePageN = s.FreePageN
+	diff.PendingPageN = s.PendingPageN
+	diff.FreeAlloc = s.FreeAlloc
+	diff.FreelistInuse = s.FreelistInuse
+	diff.TxN = other.TxN - s.TxN
+	diff.TxStats = s.TxStats.Sub(&other.TxStats)
+	return diff
+}
+
+func (s *Stats) add(other *Stats) {
+	s.TxStats.add(&other.TxStats)
+}
+
+type Info struct {
+	Data     uintptr
+	PageSize int
+}
+
+type meta struct {
+	magic    uint32
+	version  uint32
+	pageSize uint32
+	flags    uint32
+	root     bucket
+	freelist pgid
+	pgid     pgid
+	txid     txid
+	checksum uint64
+}
+
+// validate checks the marker bytes and version of the meta page to ensure it matches this binary.
+func (m *meta) validate() error {
+	if m.checksum != 0 && m.checksum != m.sum64() {
+		return ErrChecksum
+	} else if m.magic != magic {
+		return ErrInvalid
+	} else if m.version != version {
+		return ErrVersionMismatch
+	}
+	return nil
+}
+
+// copy copies one meta object to another.
+func (m *meta) copy(dest *meta) {
+	*dest = *m
+}
+
+// write writes the meta onto a page.
+func (m *meta) write(p *page) {
+	if m.root.root >= m.pgid {
+		panic(fmt.Sprintf("root bucket pgid (%d) above high water mark (%d)", m.root.root, m.pgid))
+	} else if m.freelist >= m.pgid {
+		panic(fmt.Sprintf("freelist pgid (%d) above high water mark (%d)", m.freelist, m.pgid))
+	}
+
+	// Page id is either going to be 0 or 1 which we can determine by the transaction ID.
+	p.id = pgid(m.txid % 2)
+	p.flags |= metaPageFlag
+
+	// Calculate the checksum.
+	m.checksum = m.sum64()
+
+	m.copy(p.meta())
+}
+
+// generates the checksum for the meta.
+func (m *meta) sum64() uint64 {
+	var h = fnv.New64a()
+	_, _ = h.Write((*[unsafe.Offsetof(meta{}.checksum)]byte)(unsafe.Pointer(m))[:])
+	return h.Sum64()
+}
+
+// _assert will panic with a given formatted message if the given condition is false.
+func _assert(condition bool, msg string, v ...interface{}) {
+	if !condition {
+		panic(fmt.Sprintf("assertion failed: "+msg, v...))
+	}
+}
+
+func warn(v ...interface{})              { fmt.Fprintln(os.Stderr, v...) }
+func warnf(msg string, v ...interface{}) { fmt.Fprintf(os.Stderr, msg+"\n", v...) }
+
+func printstack() {
+	stack := strings.Join(strings.Split(string(debug.Stack()), "\n")[2:], "\n")
+	fmt.Fprintln(os.Stderr, stack)
+}
diff --git a/vendor/github.com/boltdb/bolt/doc.go b/vendor/github.com/boltdb/bolt/doc.go
new file mode 100644
index 00000000..cc937845
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/doc.go
@@ -0,0 +1,44 @@
+/*
+Package bolt implements a low-level key/value store in pure Go. It supports
+fully serializable transactions, ACID semantics, and lock-free MVCC with
+multiple readers and a single writer. Bolt can be used for projects that
+want a simple data store without the need to add large dependencies such as
+Postgres or MySQL.
+
+Bolt is a single-level, zero-copy, B+tree data store. This means that Bolt is
+optimized for fast read access and does not require recovery in the event of a
+system crash. Transactions which have not finished committing will simply be
+rolled back in the event of a crash.
+
+The design of Bolt is based on Howard Chu's LMDB database project.
+
+Bolt currently works on Windows, Mac OS X, and Linux.
+
+
+Basics
+
+There are only a few types in Bolt: DB, Bucket, Tx, and Cursor. The DB is
+a collection of buckets and is represented by a single file on disk. A bucket is
+a collection of unique keys that are associated with values.
+
+Transactions provide either read-only or read-write access to the database.
+Read-only transactions can retrieve key/value pairs and can use Cursors to
+iterate over the dataset sequentially. Read-write transactions can create and
+delete buckets and can insert and remove keys. Only one read-write transaction
+is allowed at a time.
+
+
+Caveats
+
+The database uses a read-only, memory-mapped data file to ensure that
+applications cannot corrupt the database, however, this means that keys and
+values returned from Bolt cannot be changed. Writing to a read-only byte slice
+will cause Go to panic.
+
+Keys and values retrieved from the database are only valid for the life of
+the transaction. When used outside the transaction, these byte slices can
+point to different data or can point to invalid memory which will cause a panic.
+
+
+*/
+package bolt
diff --git a/vendor/github.com/boltdb/bolt/errors.go b/vendor/github.com/boltdb/bolt/errors.go
new file mode 100644
index 00000000..6883786d
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/errors.go
@@ -0,0 +1,70 @@
+package bolt
+
+import "errors"
+
+// These errors can be returned when opening or calling methods on a DB.
+var (
+	// ErrDatabaseNotOpen is returned when a DB instance is accessed before it
+	// is opened or after it is closed.
+	ErrDatabaseNotOpen = errors.New("database not open")
+
+	// ErrDatabaseOpen is returned when opening a database that is
+	// already open.
+	ErrDatabaseOpen = errors.New("database already open")
+
+	// ErrInvalid is returned when a data file is not a Bolt-formatted database.
+	ErrInvalid = errors.New("invalid database")
+
+	// ErrVersionMismatch is returned when the data file was created with a
+	// different version of Bolt.
+	ErrVersionMismatch = errors.New("version mismatch")
+
+	// ErrChecksum is returned when either meta page checksum does not match.
+	ErrChecksum = errors.New("checksum error")
+
+	// ErrTimeout is returned when a database cannot obtain an exclusive lock
+	// on the data file after the timeout passed to Open().
+	ErrTimeout = errors.New("timeout")
+)
+
+// These errors can occur when beginning or committing a Tx.
+var (
+	// ErrTxNotWritable is returned when performing a write operation on a
+	// read-only transaction.
+	ErrTxNotWritable = errors.New("tx not writable")
+
+	// ErrTxClosed is returned when committing or rolling back a transaction
+	// that has already been committed or rolled back.
+	ErrTxClosed = errors.New("tx closed")
+
+	// ErrDatabaseReadOnly is returned when a mutating transaction is started on a
+	// read-only database.
+	ErrDatabaseReadOnly = errors.New("database is in read-only mode")
+)
+
+// These errors can occur when putting or deleting a value or a bucket.
+var (
+	// ErrBucketNotFound is returned when trying to access a bucket that has
+	// not been created yet.
+	ErrBucketNotFound = errors.New("bucket not found")
+
+	// ErrBucketExists is returned when creating a bucket that already exists.
+	ErrBucketExists = errors.New("bucket already exists")
+
+	// ErrBucketNameRequired is returned when creating a bucket with a blank name.
+	ErrBucketNameRequired = errors.New("bucket name required")
+
+	// ErrKeyRequired is returned when inserting a zero-length key.
+	ErrKeyRequired = errors.New("key required")
+
+	// ErrKeyTooLarge is returned when inserting a key that is larger than MaxKeySize.
+	ErrKeyTooLarge = errors.New("key too large")
+
+	// ErrValueTooLarge is returned when inserting a value that is larger than MaxValueSize.
+	ErrValueTooLarge = errors.New("value too large")
+
+	// ErrIncompatibleValue is returned when trying create or delete a bucket
+	// on an existing non-bucket key or when trying to create or delete a
+	// non-bucket key on an existing bucket key.
+	ErrIncompatibleValue = errors.New("incompatible value")
+)
diff --git a/vendor/github.com/boltdb/bolt/freelist.go b/vendor/github.com/boltdb/bolt/freelist.go
new file mode 100644
index 00000000..1346e82e
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/freelist.go
@@ -0,0 +1,241 @@
+package bolt
+
+import (
+	"fmt"
+	"sort"
+	"unsafe"
+)
+
+// freelist represents a list of all pages that are available for allocation.
+// It also tracks pages that have been freed but are still in use by open transactions.
+type freelist struct {
+	ids     []pgid          // all free and available free page ids.
+	pending map[txid][]pgid // mapping of soon-to-be free page ids by tx.
+	cache   map[pgid]bool   // fast lookup of all free and pending page ids.
+}
+
+// newFreelist returns an empty, initialized freelist.
+func newFreelist() *freelist {
+	return &freelist{
+		pending: make(map[txid][]pgid),
+		cache:   make(map[pgid]bool),
+	}
+}
+
+// size returns the size of the page after serialization.
+func (f *freelist) size() int {
+	return pageHeaderSize + (int(unsafe.Sizeof(pgid(0))) * f.count())
+}
+
+// count returns count of pages on the freelist
+func (f *freelist) count() int {
+	return f.free_count() + f.pending_count()
+}
+
+// free_count returns count of free pages
+func (f *freelist) free_count() int {
+	return len(f.ids)
+}
+
+// pending_count returns count of pending pages
+func (f *freelist) pending_count() int {
+	var count int
+	for _, list := range f.pending {
+		count += len(list)
+	}
+	return count
+}
+
+// all returns a list of all free ids and all pending ids in one sorted list.
+func (f *freelist) all() []pgid {
+	ids := make([]pgid, len(f.ids))
+	copy(ids, f.ids)
+
+	for _, list := range f.pending {
+		ids = append(ids, list...)
+	}
+
+	sort.Sort(pgids(ids))
+	return ids
+}
+
+// allocate returns the starting page id of a contiguous list of pages of a given size.
+// If a contiguous block cannot be found then 0 is returned.
+func (f *freelist) allocate(n int) pgid {
+	if len(f.ids) == 0 {
+		return 0
+	}
+
+	var initial, previd pgid
+	for i, id := range f.ids {
+		if id <= 1 {
+			panic(fmt.Sprintf("invalid page allocation: %d", id))
+		}
+
+		// Reset initial page if this is not contiguous.
+		if previd == 0 || id-previd != 1 {
+			initial = id
+		}
+
+		// If we found a contiguous block then remove it and return it.
+		if (id-initial)+1 == pgid(n) {
+			// If we're allocating off the beginning then take the fast path
+			// and just adjust the existing slice. This will use extra memory
+			// temporarily but the append() in free() will realloc the slice
+			// as is necessary.
+			if (i + 1) == n {
+				f.ids = f.ids[i+1:]
+			} else {
+				copy(f.ids[i-n+1:], f.ids[i+1:])
+				f.ids = f.ids[:len(f.ids)-n]
+			}
+
+			// Remove from the free cache.
+			for i := pgid(0); i < pgid(n); i++ {
+				delete(f.cache, initial+i)
+			}
+
+			return initial
+		}
+
+		previd = id
+	}
+	return 0
+}
+
+// free releases a page and its overflow for a given transaction id.
+// If the page is already free then a panic will occur.
+func (f *freelist) free(txid txid, p *page) {
+	if p.id <= 1 {
+		panic(fmt.Sprintf("cannot free page 0 or 1: %d", p.id))
+	}
+
+	// Free page and all its overflow pages.
+	var ids = f.pending[txid]
+	for id := p.id; id <= p.id+pgid(p.overflow); id++ {
+		// Verify that page is not already free.
+		if f.cache[id] {
+			panic(fmt.Sprintf("page %d already freed", id))
+		}
+
+		// Add to the freelist and cache.
+		ids = append(ids, id)
+		f.cache[id] = true
+	}
+	f.pending[txid] = ids
+}
+
+// release moves all page ids for a transaction id (or older) to the freelist.
+func (f *freelist) release(txid txid) {
+	for tid, ids := range f.pending {
+		if tid <= txid {
+			// Move transaction's pending pages to the available freelist.
+			// Don't remove from the cache since the page is still free.
+			f.ids = append(f.ids, ids...)
+			delete(f.pending, tid)
+		}
+	}
+	sort.Sort(pgids(f.ids))
+}
+
+// rollback removes the pages from a given pending tx.
+func (f *freelist) rollback(txid txid) {
+	// Remove page ids from cache.
+	for _, id := range f.pending[txid] {
+		delete(f.cache, id)
+	}
+
+	// Remove pages from pending list.
+	delete(f.pending, txid)
+}
+
+// freed returns whether a given page is in the free list.
+func (f *freelist) freed(pgid pgid) bool {
+	return f.cache[pgid]
+}
+
+// read initializes the freelist from a freelist page.
+func (f *freelist) read(p *page) {
+	// If the page.count is at the max uint16 value (64k) then it's considered
+	// an overflow and the size of the freelist is stored as the first element.
+	idx, count := 0, int(p.count)
+	if count == 0xFFFF {
+		idx = 1
+		count = int(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0])
+	}
+
+	// Copy the list of page ids from the freelist.
+	ids := ((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[idx:count]
+	f.ids = make([]pgid, len(ids))
+	copy(f.ids, ids)
+
+	// Make sure they're sorted.
+	sort.Sort(pgids(f.ids))
+
+	// Rebuild the page cache.
+	f.reindex()
+}
+
+// write writes the page ids onto a freelist page. All free and pending ids are
+// saved to disk since in the event of a program crash, all pending ids will
+// become free.
+func (f *freelist) write(p *page) error {
+	// Combine the old free pgids and pgids waiting on an open transaction.
+	ids := f.all()
+
+	// Update the header flag.
+	p.flags |= freelistPageFlag
+
+	// The page.count can only hold up to 64k elements so if we overflow that
+	// number then we handle it by putting the size in the first element.
+	if len(ids) < 0xFFFF {
+		p.count = uint16(len(ids))
+		copy(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[:], ids)
+	} else {
+		p.count = 0xFFFF
+		((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0] = pgid(len(ids))
+		copy(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[1:], ids)
+	}
+
+	return nil
+}
+
+// reload reads the freelist from a page and filters out pending items.
+func (f *freelist) reload(p *page) {
+	f.read(p)
+
+	// Build a cache of only pending pages.
+	pcache := make(map[pgid]bool)
+	for _, pendingIDs := range f.pending {
+		for _, pendingID := range pendingIDs {
+			pcache[pendingID] = true
+		}
+	}
+
+	// Check each page in the freelist and build a new available freelist
+	// with any pages not in the pending lists.
+	var a []pgid
+	for _, id := range f.ids {
+		if !pcache[id] {
+			a = append(a, id)
+		}
+	}
+	f.ids = a
+
+	// Once the available list is rebuilt then rebuild the free cache so that
+	// it includes the available and pending free pages.
+	f.reindex()
+}
+
+// reindex rebuilds the free cache based on available and pending free lists.
+func (f *freelist) reindex() {
+	f.cache = make(map[pgid]bool)
+	for _, id := range f.ids {
+		f.cache[id] = true
+	}
+	for _, pendingIDs := range f.pending {
+		for _, pendingID := range pendingIDs {
+			f.cache[pendingID] = true
+		}
+	}
+}
diff --git a/vendor/github.com/boltdb/bolt/node.go b/vendor/github.com/boltdb/bolt/node.go
new file mode 100644
index 00000000..c9fb21c7
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/node.go
@@ -0,0 +1,636 @@
+package bolt
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"unsafe"
+)
+
+// node represents an in-memory, deserialized page.
+type node struct {
+	bucket     *Bucket
+	isLeaf     bool
+	unbalanced bool
+	spilled    bool
+	key        []byte
+	pgid       pgid
+	parent     *node
+	children   nodes
+	inodes     inodes
+}
+
+// root returns the top-level node this node is attached to.
+func (n *node) root() *node {
+	if n.parent == nil {
+		return n
+	}
+	return n.parent.root()
+}
+
+// minKeys returns the minimum number of inodes this node should have.
+func (n *node) minKeys() int {
+	if n.isLeaf {
+		return 1
+	}
+	return 2
+}
+
+// size returns the size of the node after serialization.
+func (n *node) size() int {
+	sz, elsz := pageHeaderSize, n.pageElementSize()
+	for i := 0; i < len(n.inodes); i++ {
+		item := &n.inodes[i]
+		sz += elsz + len(item.key) + len(item.value)
+	}
+	return sz
+}
+
+// sizeLessThan returns true if the node is less than a given size.
+// This is an optimization to avoid calculating a large node when we only need
+// to know if it fits inside a certain page size.
+func (n *node) sizeLessThan(v int) bool {
+	sz, elsz := pageHeaderSize, n.pageElementSize()
+	for i := 0; i < len(n.inodes); i++ {
+		item := &n.inodes[i]
+		sz += elsz + len(item.key) + len(item.value)
+		if sz >= v {
+			return false
+		}
+	}
+	return true
+}
+
+// pageElementSize returns the size of each page element based on the type of node.
+func (n *node) pageElementSize() int {
+	if n.isLeaf {
+		return leafPageElementSize
+	}
+	return branchPageElementSize
+}
+
+// childAt returns the child node at a given index.
+func (n *node) childAt(index int) *node {
+	if n.isLeaf {
+		panic(fmt.Sprintf("invalid childAt(%d) on a leaf node", index))
+	}
+	return n.bucket.node(n.inodes[index].pgid, n)
+}
+
+// childIndex returns the index of a given child node.
+func (n *node) childIndex(child *node) int {
+	index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, child.key) != -1 })
+	return index
+}
+
+// numChildren returns the number of children.
+func (n *node) numChildren() int {
+	return len(n.inodes)
+}
+
+// nextSibling returns the next node with the same parent.
+func (n *node) nextSibling() *node {
+	if n.parent == nil {
+		return nil
+	}
+	index := n.parent.childIndex(n)
+	if index >= n.parent.numChildren()-1 {
+		return nil
+	}
+	return n.parent.childAt(index + 1)
+}
+
+// prevSibling returns the previous node with the same parent.
+func (n *node) prevSibling() *node {
+	if n.parent == nil {
+		return nil
+	}
+	index := n.parent.childIndex(n)
+	if index == 0 {
+		return nil
+	}
+	return n.parent.childAt(index - 1)
+}
+
+// put inserts a key/value.
+func (n *node) put(oldKey, newKey, value []byte, pgid pgid, flags uint32) {
+	if pgid >= n.bucket.tx.meta.pgid {
+		panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", pgid, n.bucket.tx.meta.pgid))
+	} else if len(oldKey) <= 0 {
+		panic("put: zero-length old key")
+	} else if len(newKey) <= 0 {
+		panic("put: zero-length new key")
+	}
+
+	// Find insertion index.
+	index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, oldKey) != -1 })
+
+	// Add capacity and shift nodes if we don't have an exact match and need to insert.
+	exact := (len(n.inodes) > 0 && index < len(n.inodes) && bytes.Equal(n.inodes[index].key, oldKey))
+	if !exact {
+		n.inodes = append(n.inodes, inode{})
+		copy(n.inodes[index+1:], n.inodes[index:])
+	}
+
+	inode := &n.inodes[index]
+	inode.flags = flags
+	inode.key = newKey
+	inode.value = value
+	inode.pgid = pgid
+	_assert(len(inode.key) > 0, "put: zero-length inode key")
+}
+
+// del removes a key from the node.
+func (n *node) del(key []byte) {
+	// Find index of key.
+	index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, key) != -1 })
+
+	// Exit if the key isn't found.
+	if index >= len(n.inodes) || !bytes.Equal(n.inodes[index].key, key) {
+		return
+	}
+
+	// Delete inode from the node.
+	n.inodes = append(n.inodes[:index], n.inodes[index+1:]...)
+
+	// Mark the node as needing rebalancing.
+	n.unbalanced = true
+}
+
+// read initializes the node from a page.
+func (n *node) read(p *page) {
+	n.pgid = p.id
+	n.isLeaf = ((p.flags & leafPageFlag) != 0)
+	n.inodes = make(inodes, int(p.count))
+
+	for i := 0; i < int(p.count); i++ {
+		inode := &n.inodes[i]
+		if n.isLeaf {
+			elem := p.leafPageElement(uint16(i))
+			inode.flags = elem.flags
+			inode.key = elem.key()
+			inode.value = elem.value()
+		} else {
+			elem := p.branchPageElement(uint16(i))
+			inode.pgid = elem.pgid
+			inode.key = elem.key()
+		}
+		_assert(len(inode.key) > 0, "read: zero-length inode key")
+	}
+
+	// Save first key so we can find the node in the parent when we spill.
+	if len(n.inodes) > 0 {
+		n.key = n.inodes[0].key
+		_assert(len(n.key) > 0, "read: zero-length node key")
+	} else {
+		n.key = nil
+	}
+}
+
+// write writes the items onto one or more pages.
+func (n *node) write(p *page) {
+	// Initialize page.
+	if n.isLeaf {
+		p.flags |= leafPageFlag
+	} else {
+		p.flags |= branchPageFlag
+	}
+
+	if len(n.inodes) >= 0xFFFF {
+		panic(fmt.Sprintf("inode overflow: %d (pgid=%d)", len(n.inodes), p.id))
+	}
+	p.count = uint16(len(n.inodes))
+
+	// Loop over each item and write it to the page.
+	b := (*[maxAllocSize]byte)(unsafe.Pointer(&p.ptr))[n.pageElementSize()*len(n.inodes):]
+	for i, item := range n.inodes {
+		_assert(len(item.key) > 0, "write: zero-length inode key")
+
+		// Write the page element.
+		if n.isLeaf {
+			elem := p.leafPageElement(uint16(i))
+			elem.pos = uint32(uintptr(unsafe.Pointer(&b[0])) - uintptr(unsafe.Pointer(elem)))
+			elem.flags = item.flags
+			elem.ksize = uint32(len(item.key))
+			elem.vsize = uint32(len(item.value))
+		} else {
+			elem := p.branchPageElement(uint16(i))
+			elem.pos = uint32(uintptr(unsafe.Pointer(&b[0])) - uintptr(unsafe.Pointer(elem)))
+			elem.ksize = uint32(len(item.key))
+			elem.pgid = item.pgid
+			_assert(elem.pgid != p.id, "write: circular dependency occurred")
+		}
+
+		// If the length of key+value is larger than the max allocation size
+		// then we need to reallocate the byte array pointer.
+		//
+		// See: https://github.com/boltdb/bolt/pull/335
+		klen, vlen := len(item.key), len(item.value)
+		if len(b) < klen+vlen {
+			b = (*[maxAllocSize]byte)(unsafe.Pointer(&b[0]))[:]
+		}
+
+		// Write data for the element to the end of the page.
+		copy(b[0:], item.key)
+		b = b[klen:]
+		copy(b[0:], item.value)
+		b = b[vlen:]
+	}
+
+	// DEBUG ONLY: n.dump()
+}
+
+// split breaks up a node into multiple smaller nodes, if appropriate.
+// This should only be called from the spill() function.
+func (n *node) split(pageSize int) []*node {
+	var nodes []*node
+
+	node := n
+	for {
+		// Split node into two.
+		a, b := node.splitTwo(pageSize)
+		nodes = append(nodes, a)
+
+		// If we can't split then exit the loop.
+		if b == nil {
+			break
+		}
+
+		// Set node to b so it gets split on the next iteration.
+		node = b
+	}
+
+	return nodes
+}
+
+// splitTwo breaks up a node into two smaller nodes, if appropriate.
+// This should only be called from the split() function.
+func (n *node) splitTwo(pageSize int) (*node, *node) {
+	// Ignore the split if the page doesn't have at least enough nodes for
+	// two pages or if the nodes can fit in a single page.
+	if len(n.inodes) <= (minKeysPerPage*2) || n.sizeLessThan(pageSize) {
+		return n, nil
+	}
+
+	// Determine the threshold before starting a new node.
+	var fillPercent = n.bucket.FillPercent
+	if fillPercent < minFillPercent {
+		fillPercent = minFillPercent
+	} else if fillPercent > maxFillPercent {
+		fillPercent = maxFillPercent
+	}
+	threshold := int(float64(pageSize) * fillPercent)
+
+	// Determine split position and sizes of the two pages.
+	splitIndex, _ := n.splitIndex(threshold)
+
+	// Split node into two separate nodes.
+	// If there's no parent then we'll need to create one.
+	if n.parent == nil {
+		n.parent = &node{bucket: n.bucket, children: []*node{n}}
+	}
+
+	// Create a new node and add it to the parent.
+	next := &node{bucket: n.bucket, isLeaf: n.isLeaf, parent: n.parent}
+	n.parent.children = append(n.parent.children, next)
+
+	// Split inodes across two nodes.
+	next.inodes = n.inodes[splitIndex:]
+	n.inodes = n.inodes[:splitIndex]
+
+	// Update the statistics.
+	n.bucket.tx.stats.Split++
+
+	return n, next
+}
+
+// splitIndex finds the position where a page will fill a given threshold.
+// It returns the index as well as the size of the first page.
+// This is only be called from split().
+func (n *node) splitIndex(threshold int) (index, sz int) {
+	sz = pageHeaderSize
+
+	// Loop until we only have the minimum number of keys required for the second page.
+	for i := 0; i < len(n.inodes)-minKeysPerPage; i++ {
+		index = i
+		inode := n.inodes[i]
+		elsize := n.pageElementSize() + len(inode.key) + len(inode.value)
+
+		// If we have at least the minimum number of keys and adding another
+		// node would put us over the threshold then exit and return.
+		if i >= minKeysPerPage && sz+elsize > threshold {
+			break
+		}
+
+		// Add the element size to the total size.
+		sz += elsize
+	}
+
+	return
+}
+
+// spill writes the nodes to dirty pages and splits nodes as it goes.
+// Returns an error if dirty pages cannot be allocated.
+func (n *node) spill() error {
+	var tx = n.bucket.tx
+	if n.spilled {
+		return nil
+	}
+
+	// Spill child nodes first. Child nodes can materialize sibling nodes in
+	// the case of split-merge so we cannot use a range loop. We have to check
+	// the children size on every loop iteration.
+	sort.Sort(n.children)
+	for i := 0; i < len(n.children); i++ {
+		if err := n.children[i].spill(); err != nil {
+			return err
+		}
+	}
+
+	// We no longer need the child list because it's only used for spill tracking.
+	n.children = nil
+
+	// Split nodes into appropriate sizes. The first node will always be n.
+	var nodes = n.split(tx.db.pageSize)
+	for _, node := range nodes {
+		// Add node's page to the freelist if it's not new.
+		if node.pgid > 0 {
+			tx.db.freelist.free(tx.meta.txid, tx.page(node.pgid))
+			node.pgid = 0
+		}
+
+		// Allocate contiguous space for the node.
+		p, err := tx.allocate((node.size() / tx.db.pageSize) + 1)
+		if err != nil {
+			return err
+		}
+
+		// Write the node.
+		if p.id >= tx.meta.pgid {
+			panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", p.id, tx.meta.pgid))
+		}
+		node.pgid = p.id
+		node.write(p)
+		node.spilled = true
+
+		// Insert into parent inodes.
+		if node.parent != nil {
+			var key = node.key
+			if key == nil {
+				key = node.inodes[0].key
+			}
+
+			node.parent.put(key, node.inodes[0].key, nil, node.pgid, 0)
+			node.key = node.inodes[0].key
+			_assert(len(node.key) > 0, "spill: zero-length node key")
+		}
+
+		// Update the statistics.
+		tx.stats.Spill++
+	}
+
+	// If the root node split and created a new root then we need to spill that
+	// as well. We'll clear out the children to make sure it doesn't try to respill.
+	if n.parent != nil && n.parent.pgid == 0 {
+		n.children = nil
+		return n.parent.spill()
+	}
+
+	return nil
+}
+
+// rebalance attempts to combine the node with sibling nodes if the node fill
+// size is below a threshold or if there are not enough keys.
+func (n *node) rebalance() {
+	if !n.unbalanced {
+		return
+	}
+	n.unbalanced = false
+
+	// Update statistics.
+	n.bucket.tx.stats.Rebalance++
+
+	// Ignore if node is above threshold (25%) and has enough keys.
+	var threshold = n.bucket.tx.db.pageSize / 4
+	if n.size() > threshold && len(n.inodes) > n.minKeys() {
+		return
+	}
+
+	// Root node has special handling.
+	if n.parent == nil {
+		// If root node is a branch and only has one node then collapse it.
+		if !n.isLeaf && len(n.inodes) == 1 {
+			// Move root's child up.
+			child := n.bucket.node(n.inodes[0].pgid, n)
+			n.isLeaf = child.isLeaf
+			n.inodes = child.inodes[:]
+			n.children = child.children
+
+			// Reparent all child nodes being moved.
+			for _, inode := range n.inodes {
+				if child, ok := n.bucket.nodes[inode.pgid]; ok {
+					child.parent = n
+				}
+			}
+
+			// Remove old child.
+			child.parent = nil
+			delete(n.bucket.nodes, child.pgid)
+			child.free()
+		}
+
+		return
+	}
+
+	// If node has no keys then just remove it.
+	if n.numChildren() == 0 {
+		n.parent.del(n.key)
+		n.parent.removeChild(n)
+		delete(n.bucket.nodes, n.pgid)
+		n.free()
+		n.parent.rebalance()
+		return
+	}
+
+	_assert(n.parent.numChildren() > 1, "parent must have at least 2 children")
+
+	// Destination node is right sibling if idx == 0, otherwise left sibling.
+	var target *node
+	var useNextSibling = (n.parent.childIndex(n) == 0)
+	if useNextSibling {
+		target = n.nextSibling()
+	} else {
+		target = n.prevSibling()
+	}
+
+	// If target node has extra nodes then just move one over.
+	if target.numChildren() > target.minKeys() {
+		if useNextSibling {
+			// Reparent and move node.
+			if child, ok := n.bucket.nodes[target.inodes[0].pgid]; ok {
+				child.parent.removeChild(child)
+				child.parent = n
+				child.parent.children = append(child.parent.children, child)
+			}
+			n.inodes = append(n.inodes, target.inodes[0])
+			target.inodes = target.inodes[1:]
+
+			// Update target key on parent.
+			target.parent.put(target.key, target.inodes[0].key, nil, target.pgid, 0)
+			target.key = target.inodes[0].key
+			_assert(len(target.key) > 0, "rebalance(1): zero-length node key")
+		} else {
+			// Reparent and move node.
+			if child, ok := n.bucket.nodes[target.inodes[len(target.inodes)-1].pgid]; ok {
+				child.parent.removeChild(child)
+				child.parent = n
+				child.parent.children = append(child.parent.children, child)
+			}
+			n.inodes = append(n.inodes, inode{})
+			copy(n.inodes[1:], n.inodes)
+			n.inodes[0] = target.inodes[len(target.inodes)-1]
+			target.inodes = target.inodes[:len(target.inodes)-1]
+		}
+
+		// Update parent key for node.
+		n.parent.put(n.key, n.inodes[0].key, nil, n.pgid, 0)
+		n.key = n.inodes[0].key
+		_assert(len(n.key) > 0, "rebalance(2): zero-length node key")
+
+		return
+	}
+
+	// If both this node and the target node are too small then merge them.
+	if useNextSibling {
+		// Reparent all child nodes being moved.
+		for _, inode := range target.inodes {
+			if child, ok := n.bucket.nodes[inode.pgid]; ok {
+				child.parent.removeChild(child)
+				child.parent = n
+				child.parent.children = append(child.parent.children, child)
+			}
+		}
+
+		// Copy over inodes from target and remove target.
+		n.inodes = append(n.inodes, target.inodes...)
+		n.parent.del(target.key)
+		n.parent.removeChild(target)
+		delete(n.bucket.nodes, target.pgid)
+		target.free()
+	} else {
+		// Reparent all child nodes being moved.
+		for _, inode := range n.inodes {
+			if child, ok := n.bucket.nodes[inode.pgid]; ok {
+				child.parent.removeChild(child)
+				child.parent = target
+				child.parent.children = append(child.parent.children, child)
+			}
+		}
+
+		// Copy over inodes to target and remove node.
+		target.inodes = append(target.inodes, n.inodes...)
+		n.parent.del(n.key)
+		n.parent.removeChild(n)
+		delete(n.bucket.nodes, n.pgid)
+		n.free()
+	}
+
+	// Either this node or the target node was deleted from the parent so rebalance it.
+	n.parent.rebalance()
+}
+
+// removes a node from the list of in-memory children.
+// This does not affect the inodes.
+func (n *node) removeChild(target *node) {
+	for i, child := range n.children {
+		if child == target {
+			n.children = append(n.children[:i], n.children[i+1:]...)
+			return
+		}
+	}
+}
+
+// dereference causes the node to copy all its inode key/value references to heap memory.
+// This is required when the mmap is reallocated so inodes are not pointing to stale data.
+func (n *node) dereference() {
+	if n.key != nil {
+		key := make([]byte, len(n.key))
+		copy(key, n.key)
+		n.key = key
+		_assert(n.pgid == 0 || len(n.key) > 0, "dereference: zero-length node key on existing node")
+	}
+
+	for i := range n.inodes {
+		inode := &n.inodes[i]
+
+		key := make([]byte, len(inode.key))
+		copy(key, inode.key)
+		inode.key = key
+		_assert(len(inode.key) > 0, "dereference: zero-length inode key")
+
+		value := make([]byte, len(inode.value))
+		copy(value, inode.value)
+		inode.value = value
+	}
+
+	// Recursively dereference children.
+	for _, child := range n.children {
+		child.dereference()
+	}
+
+	// Update statistics.
+	n.bucket.tx.stats.NodeDeref++
+}
+
+// free adds the node's underlying page to the freelist.
+func (n *node) free() {
+	if n.pgid != 0 {
+		n.bucket.tx.db.freelist.free(n.bucket.tx.meta.txid, n.bucket.tx.page(n.pgid))
+		n.pgid = 0
+	}
+}
+
+// dump writes the contents of the node to STDERR for debugging purposes.
+/*
+func (n *node) dump() {
+	// Write node header.
+	var typ = "branch"
+	if n.isLeaf {
+		typ = "leaf"
+	}
+	warnf("[NODE %d {type=%s count=%d}]", n.pgid, typ, len(n.inodes))
+
+	// Write out abbreviated version of each item.
+	for _, item := range n.inodes {
+		if n.isLeaf {
+			if item.flags&bucketLeafFlag != 0 {
+				bucket := (*bucket)(unsafe.Pointer(&item.value[0]))
+				warnf("+L %08x -> (bucket root=%d)", trunc(item.key, 4), bucket.root)
+			} else {
+				warnf("+L %08x -> %08x", trunc(item.key, 4), trunc(item.value, 4))
+			}
+		} else {
+			warnf("+B %08x -> pgid=%d", trunc(item.key, 4), item.pgid)
+		}
+	}
+	warn("")
+}
+*/
+
+type nodes []*node
+
+func (s nodes) Len() int           { return len(s) }
+func (s nodes) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s nodes) Less(i, j int) bool { return bytes.Compare(s[i].inodes[0].key, s[j].inodes[0].key) == -1 }
+
+// inode represents an internal node inside of a node.
+// It can be used to point to elements in a page or point
+// to an element which hasn't been added to a page yet.
+type inode struct {
+	flags uint32
+	pgid  pgid
+	key   []byte
+	value []byte
+}
+
+type inodes []inode
diff --git a/vendor/github.com/boltdb/bolt/page.go b/vendor/github.com/boltdb/bolt/page.go
new file mode 100644
index 00000000..bc0d3332
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/page.go
@@ -0,0 +1,134 @@
+package bolt
+
+import (
+	"fmt"
+	"os"
+	"unsafe"
+)
+
+const pageHeaderSize = int(unsafe.Offsetof(((*page)(nil)).ptr))
+
+const minKeysPerPage = 2
+
+const branchPageElementSize = int(unsafe.Sizeof(branchPageElement{}))
+const leafPageElementSize = int(unsafe.Sizeof(leafPageElement{}))
+
+const (
+	branchPageFlag   = 0x01
+	leafPageFlag     = 0x02
+	metaPageFlag     = 0x04
+	freelistPageFlag = 0x10
+)
+
+const (
+	bucketLeafFlag = 0x01
+)
+
+type pgid uint64
+
+type page struct {
+	id       pgid
+	flags    uint16
+	count    uint16
+	overflow uint32
+	ptr      uintptr
+}
+
+// typ returns a human readable page type string used for debugging.
+func (p *page) typ() string {
+	if (p.flags & branchPageFlag) != 0 {
+		return "branch"
+	} else if (p.flags & leafPageFlag) != 0 {
+		return "leaf"
+	} else if (p.flags & metaPageFlag) != 0 {
+		return "meta"
+	} else if (p.flags & freelistPageFlag) != 0 {
+		return "freelist"
+	}
+	return fmt.Sprintf("unknown<%02x>", p.flags)
+}
+
+// meta returns a pointer to the metadata section of the page.
+func (p *page) meta() *meta {
+	return (*meta)(unsafe.Pointer(&p.ptr))
+}
+
+// leafPageElement retrieves the leaf node by index
+func (p *page) leafPageElement(index uint16) *leafPageElement {
+	n := &((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index]
+	return n
+}
+
+// leafPageElements retrieves a list of leaf nodes.
+func (p *page) leafPageElements() []leafPageElement {
+	return ((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[:]
+}
+
+// branchPageElement retrieves the branch node by index
+func (p *page) branchPageElement(index uint16) *branchPageElement {
+	return &((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[index]
+}
+
+// branchPageElements retrieves a list of branch nodes.
+func (p *page) branchPageElements() []branchPageElement {
+	return ((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[:]
+}
+
+// dump writes n bytes of the page to STDERR as hex output.
+func (p *page) hexdump(n int) {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(p))[:n]
+	fmt.Fprintf(os.Stderr, "%x\n", buf)
+}
+
+type pages []*page
+
+func (s pages) Len() int           { return len(s) }
+func (s pages) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s pages) Less(i, j int) bool { return s[i].id < s[j].id }
+
+// branchPageElement represents a node on a branch page.
+type branchPageElement struct {
+	pos   uint32
+	ksize uint32
+	pgid  pgid
+}
+
+// key returns a byte slice of the node key.
+func (n *branchPageElement) key() []byte {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
+	return (*[maxAllocSize]byte)(unsafe.Pointer(&buf[n.pos]))[:n.ksize]
+}
+
+// leafPageElement represents a node on a leaf page.
+type leafPageElement struct {
+	flags uint32
+	pos   uint32
+	ksize uint32
+	vsize uint32
+}
+
+// key returns a byte slice of the node key.
+func (n *leafPageElement) key() []byte {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
+	return (*[maxAllocSize]byte)(unsafe.Pointer(&buf[n.pos]))[:n.ksize]
+}
+
+// value returns a byte slice of the node value.
+func (n *leafPageElement) value() []byte {
+	buf := (*[maxAllocSize]byte)(unsafe.Pointer(n))
+	return (*[maxAllocSize]byte)(unsafe.Pointer(&buf[n.pos+n.ksize]))[:n.vsize]
+}
+
+// PageInfo represents human readable information about a page.
+type PageInfo struct {
+	ID            int
+	Type          string
+	Count         int
+	OverflowCount int
+}
+
+type pgids []pgid
+
+func (s pgids) Len() int           { return len(s) }
+func (s pgids) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s pgids) Less(i, j int) bool { return s[i] < s[j] }
diff --git a/vendor/github.com/boltdb/bolt/tx.go b/vendor/github.com/boltdb/bolt/tx.go
new file mode 100644
index 00000000..6b52b2c8
--- /dev/null
+++ b/vendor/github.com/boltdb/bolt/tx.go
@@ -0,0 +1,611 @@
+package bolt
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sort"
+	"time"
+	"unsafe"
+)
+
+// txid represents the internal transaction identifier.
+type txid uint64
+
+// Tx represents a read-only or read/write transaction on the database.
+// Read-only transactions can be used for retrieving values for keys and creating cursors.
+// Read/write transactions can create and remove buckets and create and remove keys.
+//
+// IMPORTANT: You must commit or rollback transactions when you are done with
+// them. Pages can not be reclaimed by the writer until no more transactions
+// are using them. A long running read transaction can cause the database to
+// quickly grow.
+type Tx struct {
+	writable       bool
+	managed        bool
+	db             *DB
+	meta           *meta
+	root           Bucket
+	pages          map[pgid]*page
+	stats          TxStats
+	commitHandlers []func()
+}
+
+// init initializes the transaction.
+func (tx *Tx) init(db *DB) {
+	tx.db = db
+	tx.pages = nil
+
+	// Copy the meta page since it can be changed by the writer.
+	tx.meta = &meta{}
+	db.meta().copy(tx.meta)
+
+	// Copy over the root bucket.
+	tx.root = newBucket(tx)
+	tx.root.bucket = &bucket{}
+	*tx.root.bucket = tx.meta.root
+
+	// Increment the transaction id and add a page cache for writable transactions.
+	if tx.writable {
+		tx.pages = make(map[pgid]*page)
+		tx.meta.txid += txid(1)
+	}
+}
+
+// ID returns the transaction id.
+func (tx *Tx) ID() int {
+	return int(tx.meta.txid)
+}
+
+// DB returns a reference to the database that created the transaction.
+func (tx *Tx) DB() *DB {
+	return tx.db
+}
+
+// Size returns current database size in bytes as seen by this transaction.
+func (tx *Tx) Size() int64 {
+	return int64(tx.meta.pgid) * int64(tx.db.pageSize)
+}
+
+// Writable returns whether the transaction can perform write operations.
+func (tx *Tx) Writable() bool {
+	return tx.writable
+}
+
+// Cursor creates a cursor associated with the root bucket.
+// All items in the cursor will return a nil value because all root bucket keys point to buckets.
+// The cursor is only valid as long as the transaction is open.
+// Do not use a cursor after the transaction is closed.
+func (tx *Tx) Cursor() *Cursor {
+	return tx.root.Cursor()
+}
+
+// Stats retrieves a copy of the current transaction statistics.
+func (tx *Tx) Stats() TxStats {
+	return tx.stats
+}
+
+// Bucket retrieves a bucket by name.
+// Returns nil if the bucket does not exist.
+func (tx *Tx) Bucket(name []byte) *Bucket {
+	return tx.root.Bucket(name)
+}
+
+// CreateBucket creates a new bucket.
+// Returns an error if the bucket already exists, if the bucket name is blank, or if the bucket name is too long.
+func (tx *Tx) CreateBucket(name []byte) (*Bucket, error) {
+	return tx.root.CreateBucket(name)
+}
+
+// CreateBucketIfNotExists creates a new bucket if it doesn't already exist.
+// Returns an error if the bucket name is blank, or if the bucket name is too long.
+func (tx *Tx) CreateBucketIfNotExists(name []byte) (*Bucket, error) {
+	return tx.root.CreateBucketIfNotExists(name)
+}
+
+// DeleteBucket deletes a bucket.
+// Returns an error if the bucket cannot be found or if the key represents a non-bucket value.
+func (tx *Tx) DeleteBucket(name []byte) error {
+	return tx.root.DeleteBucket(name)
+}
+
+// ForEach executes a function for each bucket in the root.
+// If the provided function returns an error then the iteration is stopped and
+// the error is returned to the caller.
+func (tx *Tx) ForEach(fn func(name []byte, b *Bucket) error) error {
+	return tx.root.ForEach(func(k, v []byte) error {
+		if err := fn(k, tx.root.Bucket(k)); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// OnCommit adds a handler function to be executed after the transaction successfully commits.
+func (tx *Tx) OnCommit(fn func()) {
+	tx.commitHandlers = append(tx.commitHandlers, fn)
+}
+
+// Commit writes all changes to disk and updates the meta page.
+// Returns an error if a disk write error occurs, or if Commit is
+// called on a read-only transaction.
+func (tx *Tx) Commit() error {
+	_assert(!tx.managed, "managed tx commit not allowed")
+	if tx.db == nil {
+		return ErrTxClosed
+	} else if !tx.writable {
+		return ErrTxNotWritable
+	}
+
+	// TODO(benbjohnson): Use vectorized I/O to write out dirty pages.
+
+	// Rebalance nodes which have had deletions.
+	var startTime = time.Now()
+	tx.root.rebalance()
+	if tx.stats.Rebalance > 0 {
+		tx.stats.RebalanceTime += time.Since(startTime)
+	}
+
+	// spill data onto dirty pages.
+	startTime = time.Now()
+	if err := tx.root.spill(); err != nil {
+		tx.rollback()
+		return err
+	}
+	tx.stats.SpillTime += time.Since(startTime)
+
+	// Free the old root bucket.
+	tx.meta.root.root = tx.root.root
+
+	// Free the freelist and allocate new pages for it. This will overestimate
+	// the size of the freelist but not underestimate the size (which would be bad).
+	tx.db.freelist.free(tx.meta.txid, tx.db.page(tx.meta.freelist))
+	p, err := tx.allocate((tx.db.freelist.size() / tx.db.pageSize) + 1)
+	if err != nil {
+		tx.rollback()
+		return err
+	}
+	if err := tx.db.freelist.write(p); err != nil {
+		tx.rollback()
+		return err
+	}
+	tx.meta.freelist = p.id
+
+	// Write dirty pages to disk.
+	startTime = time.Now()
+	if err := tx.write(); err != nil {
+		tx.rollback()
+		return err
+	}
+
+	// If strict mode is enabled then perform a consistency check.
+	// Only the first consistency error is reported in the panic.
+	if tx.db.StrictMode {
+		if err, ok := <-tx.Check(); ok {
+			panic("check fail: " + err.Error())
+		}
+	}
+
+	// Write meta to disk.
+	if err := tx.writeMeta(); err != nil {
+		tx.rollback()
+		return err
+	}
+	tx.stats.WriteTime += time.Since(startTime)
+
+	// Finalize the transaction.
+	tx.close()
+
+	// Execute commit handlers now that the locks have been removed.
+	for _, fn := range tx.commitHandlers {
+		fn()
+	}
+
+	return nil
+}
+
+// Rollback closes the transaction and ignores all previous updates. Read-only
+// transactions must be rolled back and not committed.
+func (tx *Tx) Rollback() error {
+	_assert(!tx.managed, "managed tx rollback not allowed")
+	if tx.db == nil {
+		return ErrTxClosed
+	}
+	tx.rollback()
+	return nil
+}
+
+func (tx *Tx) rollback() {
+	if tx.db == nil {
+		return
+	}
+	if tx.writable {
+		tx.db.freelist.rollback(tx.meta.txid)
+		tx.db.freelist.reload(tx.db.page(tx.db.meta().freelist))
+	}
+	tx.close()
+}
+
+func (tx *Tx) close() {
+	if tx.db == nil {
+		return
+	}
+	if tx.writable {
+		// Grab freelist stats.
+		var freelistFreeN = tx.db.freelist.free_count()
+		var freelistPendingN = tx.db.freelist.pending_count()
+		var freelistAlloc = tx.db.freelist.size()
+
+		// Remove writer lock.
+		tx.db.rwlock.Unlock()
+
+		// Merge statistics.
+		tx.db.statlock.Lock()
+		tx.db.stats.FreePageN = freelistFreeN
+		tx.db.stats.PendingPageN = freelistPendingN
+		tx.db.stats.FreeAlloc = (freelistFreeN + freelistPendingN) * tx.db.pageSize
+		tx.db.stats.FreelistInuse = freelistAlloc
+		tx.db.stats.TxStats.add(&tx.stats)
+		tx.db.statlock.Unlock()
+	} else {
+		tx.db.removeTx(tx)
+	}
+	tx.db = nil
+}
+
+// Copy writes the entire database to a writer.
+// This function exists for backwards compatibility. Use WriteTo() in
+func (tx *Tx) Copy(w io.Writer) error {
+	_, err := tx.WriteTo(w)
+	return err
+}
+
+// WriteTo writes the entire database to a writer.
+// If err == nil then exactly tx.Size() bytes will be written into the writer.
+func (tx *Tx) WriteTo(w io.Writer) (n int64, err error) {
+	// Attempt to open reader directly.
+	var f *os.File
+	if f, err = os.OpenFile(tx.db.path, os.O_RDONLY|odirect, 0); err != nil {
+		// Fallback to a regular open if that doesn't work.
+		if f, err = os.OpenFile(tx.db.path, os.O_RDONLY, 0); err != nil {
+			return 0, err
+		}
+	}
+
+	// Copy the meta pages.
+	tx.db.metalock.Lock()
+	n, err = io.CopyN(w, f, int64(tx.db.pageSize*2))
+	tx.db.metalock.Unlock()
+	if err != nil {
+		_ = f.Close()
+		return n, fmt.Errorf("meta copy: %s", err)
+	}
+
+	// Copy data pages.
+	wn, err := io.CopyN(w, f, tx.Size()-int64(tx.db.pageSize*2))
+	n += wn
+	if err != nil {
+		_ = f.Close()
+		return n, err
+	}
+
+	return n, f.Close()
+}
+
+// CopyFile copies the entire database to file at the given path.
+// A reader transaction is maintained during the copy so it is safe to continue
+// using the database while a copy is in progress.
+func (tx *Tx) CopyFile(path string, mode os.FileMode) error {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, mode)
+	if err != nil {
+		return err
+	}
+
+	err = tx.Copy(f)
+	if err != nil {
+		_ = f.Close()
+		return err
+	}
+	return f.Close()
+}
+
+// Check performs several consistency checks on the database for this transaction.
+// An error is returned if any inconsistency is found.
+//
+// It can be safely run concurrently on a writable transaction. However, this
+// incurs a high cost for large databases and databases with a lot of subbuckets
+// because of caching. This overhead can be removed if running on a read-only
+// transaction, however, it is not safe to execute other writer transactions at
+// the same time.
+func (tx *Tx) Check() <-chan error {
+	ch := make(chan error)
+	go tx.check(ch)
+	return ch
+}
+
+func (tx *Tx) check(ch chan error) {
+	// Check if any pages are double freed.
+	freed := make(map[pgid]bool)
+	for _, id := range tx.db.freelist.all() {
+		if freed[id] {
+			ch <- fmt.Errorf("page %d: already freed", id)
+		}
+		freed[id] = true
+	}
+
+	// Track every reachable page.
+	reachable := make(map[pgid]*page)
+	reachable[0] = tx.page(0) // meta0
+	reachable[1] = tx.page(1) // meta1
+	for i := uint32(0); i <= tx.page(tx.meta.freelist).overflow; i++ {
+		reachable[tx.meta.freelist+pgid(i)] = tx.page(tx.meta.freelist)
+	}
+
+	// Recursively check buckets.
+	tx.checkBucket(&tx.root, reachable, freed, ch)
+
+	// Ensure all pages below high water mark are either reachable or freed.
+	for i := pgid(0); i < tx.meta.pgid; i++ {
+		_, isReachable := reachable[i]
+		if !isReachable && !freed[i] {
+			ch <- fmt.Errorf("page %d: unreachable unfreed", int(i))
+		}
+	}
+
+	// Close the channel to signal completion.
+	close(ch)
+}
+
+func (tx *Tx) checkBucket(b *Bucket, reachable map[pgid]*page, freed map[pgid]bool, ch chan error) {
+	// Ignore inline buckets.
+	if b.root == 0 {
+		return
+	}
+
+	// Check every page used by this bucket.
+	b.tx.forEachPage(b.root, 0, func(p *page, _ int) {
+		if p.id > tx.meta.pgid {
+			ch <- fmt.Errorf("page %d: out of bounds: %d", int(p.id), int(b.tx.meta.pgid))
+		}
+
+		// Ensure each page is only referenced once.
+		for i := pgid(0); i <= pgid(p.overflow); i++ {
+			var id = p.id + i
+			if _, ok := reachable[id]; ok {
+				ch <- fmt.Errorf("page %d: multiple references", int(id))
+			}
+			reachable[id] = p
+		}
+
+		// We should only encounter un-freed leaf and branch pages.
+		if freed[p.id] {
+			ch <- fmt.Errorf("page %d: reachable freed", int(p.id))
+		} else if (p.flags&branchPageFlag) == 0 && (p.flags&leafPageFlag) == 0 {
+			ch <- fmt.Errorf("page %d: invalid type: %s", int(p.id), p.typ())
+		}
+	})
+
+	// Check each bucket within this bucket.
+	_ = b.ForEach(func(k, v []byte) error {
+		if child := b.Bucket(k); child != nil {
+			tx.checkBucket(child, reachable, freed, ch)
+		}
+		return nil
+	})
+}
+
+// allocate returns a contiguous block of memory starting at a given page.
+func (tx *Tx) allocate(count int) (*page, error) {
+	p, err := tx.db.allocate(count)
+	if err != nil {
+		return nil, err
+	}
+
+	// Save to our page cache.
+	tx.pages[p.id] = p
+
+	// Update statistics.
+	tx.stats.PageCount++
+	tx.stats.PageAlloc += count * tx.db.pageSize
+
+	return p, nil
+}
+
+// write writes any dirty pages to disk.
+func (tx *Tx) write() error {
+	// Sort pages by id.
+	pages := make(pages, 0, len(tx.pages))
+	for _, p := range tx.pages {
+		pages = append(pages, p)
+	}
+	sort.Sort(pages)
+
+	// Write pages to disk in order.
+	for _, p := range pages {
+		size := (int(p.overflow) + 1) * tx.db.pageSize
+		offset := int64(p.id) * int64(tx.db.pageSize)
+
+		// Write out page in "max allocation" sized chunks.
+		ptr := (*[maxAllocSize]byte)(unsafe.Pointer(p))
+		for {
+			// Limit our write to our max allocation size.
+			sz := size
+			if sz > maxAllocSize-1 {
+				sz = maxAllocSize - 1
+			}
+
+			// Write chunk to disk.
+			buf := ptr[:sz]
+			if _, err := tx.db.ops.writeAt(buf, offset); err != nil {
+				return err
+			}
+
+			// Update statistics.
+			tx.stats.Write++
+
+			// Exit inner for loop if we've written all the chunks.
+			size -= sz
+			if size == 0 {
+				break
+			}
+
+			// Otherwise move offset forward and move pointer to next chunk.
+			offset += int64(sz)
+			ptr = (*[maxAllocSize]byte)(unsafe.Pointer(&ptr[sz]))
+		}
+	}
+
+	// Ignore file sync if flag is set on DB.
+	if !tx.db.NoSync || IgnoreNoSync {
+		if err := fdatasync(tx.db); err != nil {
+			return err
+		}
+	}
+
+	// Clear out page cache.
+	tx.pages = make(map[pgid]*page)
+
+	return nil
+}
+
+// writeMeta writes the meta to the disk.
+func (tx *Tx) writeMeta() error {
+	// Create a temporary buffer for the meta page.
+	buf := make([]byte, tx.db.pageSize)
+	p := tx.db.pageInBuffer(buf, 0)
+	tx.meta.write(p)
+
+	// Write the meta page to file.
+	if _, err := tx.db.ops.writeAt(buf, int64(p.id)*int64(tx.db.pageSize)); err != nil {
+		return err
+	}
+	if !tx.db.NoSync || IgnoreNoSync {
+		if err := fdatasync(tx.db); err != nil {
+			return err
+		}
+	}
+
+	// Update statistics.
+	tx.stats.Write++
+
+	return nil
+}
+
+// page returns a reference to the page with a given id.
+// If page has been written to then a temporary bufferred page is returned.
+func (tx *Tx) page(id pgid) *page {
+	// Check the dirty pages first.
+	if tx.pages != nil {
+		if p, ok := tx.pages[id]; ok {
+			return p
+		}
+	}
+
+	// Otherwise return directly from the mmap.
+	return tx.db.page(id)
+}
+
+// forEachPage iterates over every page within a given page and executes a function.
+func (tx *Tx) forEachPage(pgid pgid, depth int, fn func(*page, int)) {
+	p := tx.page(pgid)
+
+	// Execute function.
+	fn(p, depth)
+
+	// Recursively loop over children.
+	if (p.flags & branchPageFlag) != 0 {
+		for i := 0; i < int(p.count); i++ {
+			elem := p.branchPageElement(uint16(i))
+			tx.forEachPage(elem.pgid, depth+1, fn)
+		}
+	}
+}
+
+// Page returns page information for a given page number.
+// This is only safe for concurrent use when used by a writable transaction.
+func (tx *Tx) Page(id int) (*PageInfo, error) {
+	if tx.db == nil {
+		return nil, ErrTxClosed
+	} else if pgid(id) >= tx.meta.pgid {
+		return nil, nil
+	}
+
+	// Build the page info.
+	p := tx.db.page(pgid(id))
+	info := &PageInfo{
+		ID:            id,
+		Count:         int(p.count),
+		OverflowCount: int(p.overflow),
+	}
+
+	// Determine the type (or if it's free).
+	if tx.db.freelist.freed(pgid(id)) {
+		info.Type = "free"
+	} else {
+		info.Type = p.typ()
+	}
+
+	return info, nil
+}
+
+// TxStats represents statistics about the actions performed by the transaction.
+type TxStats struct {
+	// Page statistics.
+	PageCount int // number of page allocations
+	PageAlloc int // total bytes allocated
+
+	// Cursor statistics.
+	CursorCount int // number of cursors created
+
+	// Node statistics
+	NodeCount int // number of node allocations
+	NodeDeref int // number of node dereferences
+
+	// Rebalance statistics.
+	Rebalance     int           // number of node rebalances
+	RebalanceTime time.Duration // total time spent rebalancing
+
+	// Split/Spill statistics.
+	Split     int           // number of nodes split
+	Spill     int           // number of nodes spilled
+	SpillTime time.Duration // total time spent spilling
+
+	// Write statistics.
+	Write     int           // number of writes performed
+	WriteTime time.Duration // total time spent writing to disk
+}
+
+func (s *TxStats) add(other *TxStats) {
+	s.PageCount += other.PageCount
+	s.PageAlloc += other.PageAlloc
+	s.CursorCount += other.CursorCount
+	s.NodeCount += other.NodeCount
+	s.NodeDeref += other.NodeDeref
+	s.Rebalance += other.Rebalance
+	s.RebalanceTime += other.RebalanceTime
+	s.Split += other.Split
+	s.Spill += other.Spill
+	s.SpillTime += other.SpillTime
+	s.Write += other.Write
+	s.WriteTime += other.WriteTime
+}
+
+// Sub calculates and returns the difference between two sets of transaction stats.
+// This is useful when obtaining stats at two different points and time and
+// you need the performance counters that occurred within that time span.
+func (s *TxStats) Sub(other *TxStats) TxStats {
+	var diff TxStats
+	diff.PageCount = s.PageCount - other.PageCount
+	diff.PageAlloc = s.PageAlloc - other.PageAlloc
+	diff.CursorCount = s.CursorCount - other.CursorCount
+	diff.NodeCount = s.NodeCount - other.NodeCount
+	diff.NodeDeref = s.NodeDeref - other.NodeDeref
+	diff.Rebalance = s.Rebalance - other.Rebalance
+	diff.RebalanceTime = s.RebalanceTime - other.RebalanceTime
+	diff.Split = s.Split - other.Split
+	diff.Spill = s.Spill - other.Spill
+	diff.SpillTime = s.SpillTime - other.SpillTime
+	diff.Write = s.Write - other.Write
+	diff.WriteTime = s.WriteTime - other.WriteTime
+	return diff
+}
diff --git a/vendor/github.com/coreos/go-systemd/journal/send.go b/vendor/github.com/coreos/go-systemd/journal/send.go
new file mode 100644
index 00000000..aa8fb5b0
--- /dev/null
+++ b/vendor/github.com/coreos/go-systemd/journal/send.go
@@ -0,0 +1,166 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package journal provides write bindings to the systemd journal
+package journal
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+// Priority of a journal message
+type Priority int
+
+const (
+	PriEmerg Priority = iota
+	PriAlert
+	PriCrit
+	PriErr
+	PriWarning
+	PriNotice
+	PriInfo
+	PriDebug
+)
+
+var conn net.Conn
+
+func init() {
+	var err error
+	conn, err = net.Dial("unixgram", "/run/systemd/journal/socket")
+	if err != nil {
+		conn = nil
+	}
+}
+
+// Enabled returns true if the systemd journal is available for logging
+func Enabled() bool {
+	return conn != nil
+}
+
+// Send a message to the systemd journal. vars is a map of journald fields to
+// values.  Fields must be composed of uppercase letters, numbers, and
+// underscores, but must not start with an underscore. Within these
+// restrictions, any arbitrary field name may be used.  Some names have special
+// significance: see the journalctl documentation
+// (http://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html)
+// for more details.  vars may be nil.
+func Send(message string, priority Priority, vars map[string]string) error {
+	if conn == nil {
+		return journalError("could not connect to journald socket")
+	}
+
+	data := new(bytes.Buffer)
+	appendVariable(data, "PRIORITY", strconv.Itoa(int(priority)))
+	appendVariable(data, "MESSAGE", message)
+	for k, v := range vars {
+		appendVariable(data, k, v)
+	}
+
+	_, err := io.Copy(conn, data)
+	if err != nil && isSocketSpaceError(err) {
+		file, err := tempFd()
+		if err != nil {
+			return journalError(err.Error())
+		}
+		_, err = io.Copy(file, data)
+		if err != nil {
+			return journalError(err.Error())
+		}
+
+		rights := syscall.UnixRights(int(file.Fd()))
+
+		/* this connection should always be a UnixConn, but better safe than sorry */
+		unixConn, ok := conn.(*net.UnixConn)
+		if !ok {
+			return journalError("can't send file through non-Unix connection")
+		}
+		unixConn.WriteMsgUnix([]byte{}, rights, nil)
+	} else if err != nil {
+		return journalError(err.Error())
+	}
+	return nil
+}
+
+func appendVariable(w io.Writer, name, value string) {
+	if !validVarName(name) {
+		journalError("variable name contains invalid character, ignoring")
+	}
+	if strings.ContainsRune(value, '\n') {
+		/* When the value contains a newline, we write:
+		 * - the variable name, followed by a newline
+		 * - the size (in 64bit little endian format)
+		 * - the data, followed by a newline
+		 */
+		fmt.Fprintln(w, name)
+		binary.Write(w, binary.LittleEndian, uint64(len(value)))
+		fmt.Fprintln(w, value)
+	} else {
+		/* just write the variable and value all on one line */
+		fmt.Fprintf(w, "%s=%s\n", name, value)
+	}
+}
+
+func validVarName(name string) bool {
+	/* The variable name must be in uppercase and consist only of characters,
+	 * numbers and underscores, and may not begin with an underscore. (from the docs)
+	 */
+
+	valid := name[0] != '_'
+	for _, c := range name {
+		valid = valid && ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_'
+	}
+	return valid
+}
+
+func isSocketSpaceError(err error) bool {
+	opErr, ok := err.(*net.OpError)
+	if !ok {
+		return false
+	}
+
+	sysErr, ok := opErr.Err.(syscall.Errno)
+	if !ok {
+		return false
+	}
+
+	return sysErr == syscall.EMSGSIZE || sysErr == syscall.ENOBUFS
+}
+
+func tempFd() (*os.File, error) {
+	file, err := ioutil.TempFile("/dev/shm/", "journal.XXXXX")
+	if err != nil {
+		return nil, err
+	}
+	syscall.Unlink(file.Name())
+	if err != nil {
+		return nil, err
+	}
+	return file, nil
+}
+
+func journalError(s string) error {
+	s = "journal error: " + s
+	fmt.Fprintln(os.Stderr, s)
+	return errors.New(s)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/README.md b/vendor/github.com/coreos/pkg/capnslog/README.md
new file mode 100644
index 00000000..1053dd00
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/README.md
@@ -0,0 +1,38 @@
+# CoreOS Log
+
+There are far too many logging packages out there, with varying degrees of licenses, far too many features (colorization, all sorts of log frameworks) or are just a pain to use (lack of `Fatalln()`?)
+
+## Design Principles
+
+* `package main` is the place where logging gets turned on and routed
+
+A library should not touch log options, only generate log entries. Libraries are silent until main lets them speak.
+
+* All log options are runtime-configurable. 
+
+Still the job of `main` to expose these configurations. `main` may delegate this to, say, a configuration webhook, but does so explicitly. 
+
+* There is one log object per package. It is registered under its repository and package name.
+
+`main` activates logging for its repository and any dependency repositories it would also like to have output in its logstream. `main` also dictates at which level each subpackage logs.
+
+* There is *one* output stream, and it is an `io.Writer` composed with a formatter.
+
+Splitting streams is probably not the job of your program, but rather, your log aggregation framework. If you must split output streams, again, `main` configures this and you can write a very simple two-output struct that satisfies io.Writer.
+
+Fancy colorful formatting and JSON output are beyond the scope of a basic logging framework -- they're application/log-collector dependant. These are, at best, provided as options, but more likely, provided by your application.
+
+* Log objects are an interface
+
+An object knows best how to print itself. Log objects can collect more interesting metadata if they wish, however, because text isn't going away anytime soon, they must all be marshalable to text. The simplest log object is a string, which returns itself. If you wish to do more fancy tricks for printing your log objects, see also JSON output -- introspect and write a formatter which can handle your advanced log interface. Making strings is the only thing guaranteed.
+
+* Log levels have specific meanings:
+
+  * Critical: Unrecoverable. Must fail.
+  * Error: Data has been lost, a request has failed for a bad reason, or a required resource has been lost
+  * Warning: (Hopefully) Temporary conditions that may cause errors, but may work fine. A replica disappearing (that may reconnect) is a warning.
+  * Notice: Normal, but important (uncommon) log information.
+  * Info: Normal, working log information, everything is fine, but helpful notices for auditing or common operations.
+  * Debug: Everything is still fine, but even common operations may be logged, and less helpful but more quantity of notices.
+  * Trace: Anything goes, from logging every function call as part of a common operation, to tracing execution of a query.
+
diff --git a/vendor/github.com/coreos/pkg/capnslog/example/hello_dolly.go b/vendor/github.com/coreos/pkg/capnslog/example/hello_dolly.go
new file mode 100644
index 00000000..8082ea03
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/example/hello_dolly.go
@@ -0,0 +1,57 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"flag"
+	oldlog "log"
+
+	"github.com/coreos/pkg/capnslog"
+)
+
+var logLevel = capnslog.INFO
+var log = capnslog.NewPackageLogger("github.com/coreos/pkg/capnslog/cmd", "main")
+var dlog = capnslog.NewPackageLogger("github.com/coreos/pkg/capnslog/cmd", "dolly")
+
+func init() {
+	flag.Var(&logLevel, "log-level", "Global log level.")
+}
+
+func main() {
+	rl := capnslog.MustRepoLogger("github.com/coreos/pkg/capnslog/cmd")
+
+	// We can parse the log level configs from the command line
+	flag.Parse()
+	if flag.NArg() > 1 {
+		cfg, err := rl.ParseLogLevelConfig(flag.Arg(1))
+		if err != nil {
+			log.Fatal(err)
+		}
+		rl.SetLogLevel(cfg)
+		log.Infof("Setting output to %s", flag.Arg(1))
+	}
+
+	// Send some messages at different levels to the different packages
+	dlog.Infof("Hello Dolly")
+	dlog.Warningf("Well hello, Dolly")
+	log.Errorf("It's so nice to have you back where you belong")
+	dlog.Debugf("You're looking swell, Dolly")
+	dlog.Tracef("I can tell, Dolly")
+
+	// We also have control over the built-in "log" package.
+	capnslog.SetGlobalLogLevel(logLevel)
+	oldlog.Println("You're still glowin', you're still crowin', you're still lookin' strong")
+	log.Fatalf("Dolly'll never go away again")
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/formatters.go b/vendor/github.com/coreos/pkg/capnslog/formatters.go
new file mode 100644
index 00000000..99ec6f82
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/formatters.go
@@ -0,0 +1,106 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package capnslog
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"runtime"
+	"strings"
+	"time"
+)
+
+type Formatter interface {
+	Format(pkg string, level LogLevel, depth int, entries ...interface{})
+	Flush()
+}
+
+func NewStringFormatter(w io.Writer) *StringFormatter {
+	return &StringFormatter{
+		w: bufio.NewWriter(w),
+	}
+}
+
+type StringFormatter struct {
+	w *bufio.Writer
+}
+
+func (s *StringFormatter) Format(pkg string, l LogLevel, i int, entries ...interface{}) {
+	now := time.Now().UTC()
+	s.w.WriteString(now.Format(time.RFC3339))
+	s.w.WriteByte(' ')
+	writeEntries(s.w, pkg, l, i, entries...)
+	s.Flush()
+}
+
+func writeEntries(w *bufio.Writer, pkg string, _ LogLevel, _ int, entries ...interface{}) {
+	if pkg != "" {
+		w.WriteString(pkg + ": ")
+	}
+	str := fmt.Sprint(entries...)
+	endsInNL := strings.HasSuffix(str, "\n")
+	w.WriteString(str)
+	if !endsInNL {
+		w.WriteString("\n")
+	}
+}
+
+func (s *StringFormatter) Flush() {
+	s.w.Flush()
+}
+
+func NewPrettyFormatter(w io.Writer, debug bool) Formatter {
+	return &PrettyFormatter{
+		w:     bufio.NewWriter(w),
+		debug: debug,
+	}
+}
+
+type PrettyFormatter struct {
+	w     *bufio.Writer
+	debug bool
+}
+
+func (c *PrettyFormatter) Format(pkg string, l LogLevel, depth int, entries ...interface{}) {
+	now := time.Now()
+	ts := now.Format("2006-01-02 15:04:05")
+	c.w.WriteString(ts)
+	ms := now.Nanosecond() / 1000
+	c.w.WriteString(fmt.Sprintf(".%06d", ms))
+	if c.debug {
+		_, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call.
+		if !ok {
+			file = "???"
+			line = 1
+		} else {
+			slash := strings.LastIndex(file, "/")
+			if slash >= 0 {
+				file = file[slash+1:]
+			}
+		}
+		if line < 0 {
+			line = 0 // not a real line number
+		}
+		c.w.WriteString(fmt.Sprintf(" [%s:%d]", file, line))
+	}
+	c.w.WriteString(fmt.Sprint(" ", l.Char(), " | "))
+	writeEntries(c.w, pkg, l, depth, entries...)
+	c.Flush()
+}
+
+func (c *PrettyFormatter) Flush() {
+	c.w.Flush()
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go b/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go
new file mode 100644
index 00000000..426603ef
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/glog_formatter.go
@@ -0,0 +1,96 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package capnslog
+
+import (
+	"bufio"
+	"bytes"
+	"io"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var pid = os.Getpid()
+
+type GlogFormatter struct {
+	StringFormatter
+}
+
+func NewGlogFormatter(w io.Writer) *GlogFormatter {
+	g := &GlogFormatter{}
+	g.w = bufio.NewWriter(w)
+	return g
+}
+
+func (g GlogFormatter) Format(pkg string, level LogLevel, depth int, entries ...interface{}) {
+	g.w.Write(GlogHeader(level, depth+1))
+	g.StringFormatter.Format(pkg, level, depth+1, entries...)
+}
+
+func GlogHeader(level LogLevel, depth int) []byte {
+	// Lmmdd hh:mm:ss.uuuuuu threadid file:line]
+	now := time.Now().UTC()
+	_, file, line, ok := runtime.Caller(depth) // It's always the same number of frames to the user's call.
+	if !ok {
+		file = "???"
+		line = 1
+	} else {
+		slash := strings.LastIndex(file, "/")
+		if slash >= 0 {
+			file = file[slash+1:]
+		}
+	}
+	if line < 0 {
+		line = 0 // not a real line number
+	}
+	buf := &bytes.Buffer{}
+	buf.Grow(30)
+	_, month, day := now.Date()
+	hour, minute, second := now.Clock()
+	buf.WriteString(level.Char())
+	twoDigits(buf, int(month))
+	twoDigits(buf, day)
+	buf.WriteByte(' ')
+	twoDigits(buf, hour)
+	buf.WriteByte(':')
+	twoDigits(buf, minute)
+	buf.WriteByte(':')
+	twoDigits(buf, second)
+	buf.WriteByte('.')
+	buf.WriteString(strconv.Itoa(now.Nanosecond() / 1000))
+	buf.WriteByte('Z')
+	buf.WriteByte(' ')
+	buf.WriteString(strconv.Itoa(pid))
+	buf.WriteByte(' ')
+	buf.WriteString(file)
+	buf.WriteByte(':')
+	buf.WriteString(strconv.Itoa(line))
+	buf.WriteByte(']')
+	buf.WriteByte(' ')
+	return buf.Bytes()
+}
+
+const digits = "0123456789"
+
+func twoDigits(b *bytes.Buffer, d int) {
+	c2 := digits[d%10]
+	d /= 10
+	c1 := digits[d%10]
+	b.WriteByte(c1)
+	b.WriteByte(c2)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/init.go b/vendor/github.com/coreos/pkg/capnslog/init.go
new file mode 100644
index 00000000..44b8cd36
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/init.go
@@ -0,0 +1,49 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// +build !windows
+
+package capnslog
+
+import (
+	"io"
+	"os"
+	"syscall"
+)
+
+// Here's where the opinionation comes in. We need some sensible defaults,
+// especially after taking over the log package. Your project (whatever it may
+// be) may see things differently. That's okay; there should be no defaults in
+// the main package that cannot be controlled or overridden programatically,
+// otherwise it's a bug. Doing so is creating your own init_log.go file much
+// like this one.
+
+func init() {
+	initHijack()
+
+	// Go `log` pacakge uses os.Stderr.
+	SetFormatter(NewDefaultFormatter(os.Stderr))
+	SetGlobalLogLevel(INFO)
+}
+
+func NewDefaultFormatter(out io.Writer) Formatter {
+	if syscall.Getppid() == 1 {
+		// We're running under init, which may be systemd.
+		f, err := NewJournaldFormatter()
+		if err == nil {
+			return f
+		}
+	}
+	return NewPrettyFormatter(out, false)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/init_windows.go b/vendor/github.com/coreos/pkg/capnslog/init_windows.go
new file mode 100644
index 00000000..a98bd667
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/init_windows.go
@@ -0,0 +1,25 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package capnslog
+
+import "os"
+
+func init() {
+	initHijack()
+
+	// Go `log` pacakge uses os.Stderr.
+	SetFormatter(NewPrettyFormatter(os.Stderr, false))
+	SetGlobalLogLevel(INFO)
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go b/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go
new file mode 100644
index 00000000..f4636bb6
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/journald_formatter.go
@@ -0,0 +1,66 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// +build !windows
+
+package capnslog
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/coreos/go-systemd/journal"
+)
+
+func NewJournaldFormatter() (Formatter, error) {
+	if !journal.Enabled() {
+		return nil, errors.New("No systemd detected")
+	}
+	return &journaldFormatter{}, nil
+}
+
+type journaldFormatter struct{}
+
+func (j *journaldFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) {
+	var pri journal.Priority
+	switch l {
+	case CRITICAL:
+		pri = journal.PriCrit
+	case ERROR:
+		pri = journal.PriErr
+	case WARNING:
+		pri = journal.PriWarning
+	case NOTICE:
+		pri = journal.PriNotice
+	case INFO:
+		pri = journal.PriInfo
+	case DEBUG:
+		pri = journal.PriDebug
+	case TRACE:
+		pri = journal.PriDebug
+	default:
+		panic("Unhandled loglevel")
+	}
+	msg := fmt.Sprint(entries...)
+	tags := map[string]string{
+		"PACKAGE": pkg,
+	}
+	err := journal.Send(msg, pri, tags)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+	}
+}
+
+func (j *journaldFormatter) Flush() {}
diff --git a/vendor/github.com/coreos/pkg/capnslog/log_hijack.go b/vendor/github.com/coreos/pkg/capnslog/log_hijack.go
new file mode 100644
index 00000000..970086b9
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/log_hijack.go
@@ -0,0 +1,39 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package capnslog
+
+import (
+	"log"
+)
+
+func initHijack() {
+	pkg := NewPackageLogger("log", "")
+	w := packageWriter{pkg}
+	log.SetFlags(0)
+	log.SetPrefix("")
+	log.SetOutput(w)
+}
+
+type packageWriter struct {
+	pl *PackageLogger
+}
+
+func (p packageWriter) Write(b []byte) (int, error) {
+	if p.pl.level < INFO {
+		return 0, nil
+	}
+	p.pl.internalLog(calldepth+2, INFO, string(b))
+	return len(b), nil
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/logmap.go b/vendor/github.com/coreos/pkg/capnslog/logmap.go
new file mode 100644
index 00000000..84954488
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/logmap.go
@@ -0,0 +1,240 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package capnslog
+
+import (
+	"errors"
+	"strings"
+	"sync"
+)
+
+// LogLevel is the set of all log levels.
+type LogLevel int8
+
+const (
+	// CRITICAL is the lowest log level; only errors which will end the program will be propagated.
+	CRITICAL LogLevel = iota - 1
+	// ERROR is for errors that are not fatal but lead to troubling behavior.
+	ERROR
+	// WARNING is for errors which are not fatal and not errors, but are unusual. Often sourced from misconfigurations.
+	WARNING
+	// NOTICE is for normal but significant conditions.
+	NOTICE
+	// INFO is a log level for common, everyday log updates.
+	INFO
+	// DEBUG is the default hidden level for more verbose updates about internal processes.
+	DEBUG
+	// TRACE is for (potentially) call by call tracing of programs.
+	TRACE
+)
+
+// Char returns a single-character representation of the log level.
+func (l LogLevel) Char() string {
+	switch l {
+	case CRITICAL:
+		return "C"
+	case ERROR:
+		return "E"
+	case WARNING:
+		return "W"
+	case NOTICE:
+		return "N"
+	case INFO:
+		return "I"
+	case DEBUG:
+		return "D"
+	case TRACE:
+		return "T"
+	default:
+		panic("Unhandled loglevel")
+	}
+}
+
+// String returns a multi-character representation of the log level.
+func (l LogLevel) String() string {
+	switch l {
+	case CRITICAL:
+		return "CRITICAL"
+	case ERROR:
+		return "ERROR"
+	case WARNING:
+		return "WARNING"
+	case NOTICE:
+		return "NOTICE"
+	case INFO:
+		return "INFO"
+	case DEBUG:
+		return "DEBUG"
+	case TRACE:
+		return "TRACE"
+	default:
+		panic("Unhandled loglevel")
+	}
+}
+
+// Update using the given string value. Fulfills the flag.Value interface.
+func (l *LogLevel) Set(s string) error {
+	value, err := ParseLevel(s)
+	if err != nil {
+		return err
+	}
+
+	*l = value
+	return nil
+}
+
+// ParseLevel translates some potential loglevel strings into their corresponding levels.
+func ParseLevel(s string) (LogLevel, error) {
+	switch s {
+	case "CRITICAL", "C":
+		return CRITICAL, nil
+	case "ERROR", "0", "E":
+		return ERROR, nil
+	case "WARNING", "1", "W":
+		return WARNING, nil
+	case "NOTICE", "2", "N":
+		return NOTICE, nil
+	case "INFO", "3", "I":
+		return INFO, nil
+	case "DEBUG", "4", "D":
+		return DEBUG, nil
+	case "TRACE", "5", "T":
+		return TRACE, nil
+	}
+	return CRITICAL, errors.New("couldn't parse log level " + s)
+}
+
+type RepoLogger map[string]*PackageLogger
+
+type loggerStruct struct {
+	sync.Mutex
+	repoMap   map[string]RepoLogger
+	formatter Formatter
+}
+
+// logger is the global logger
+var logger = new(loggerStruct)
+
+// SetGlobalLogLevel sets the log level for all packages in all repositories
+// registered with capnslog.
+func SetGlobalLogLevel(l LogLevel) {
+	logger.Lock()
+	defer logger.Unlock()
+	for _, r := range logger.repoMap {
+		r.setRepoLogLevelInternal(l)
+	}
+}
+
+// GetRepoLogger may return the handle to the repository's set of packages' loggers.
+func GetRepoLogger(repo string) (RepoLogger, error) {
+	logger.Lock()
+	defer logger.Unlock()
+	r, ok := logger.repoMap[repo]
+	if !ok {
+		return nil, errors.New("no packages registered for repo " + repo)
+	}
+	return r, nil
+}
+
+// MustRepoLogger returns the handle to the repository's packages' loggers.
+func MustRepoLogger(repo string) RepoLogger {
+	r, err := GetRepoLogger(repo)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+// SetRepoLogLevel sets the log level for all packages in the repository.
+func (r RepoLogger) SetRepoLogLevel(l LogLevel) {
+	logger.Lock()
+	defer logger.Unlock()
+	r.setRepoLogLevelInternal(l)
+}
+
+func (r RepoLogger) setRepoLogLevelInternal(l LogLevel) {
+	for _, v := range r {
+		v.level = l
+	}
+}
+
+// ParseLogLevelConfig parses a comma-separated string of "package=loglevel", in
+// order, and returns a map of the results, for use in SetLogLevel.
+func (r RepoLogger) ParseLogLevelConfig(conf string) (map[string]LogLevel, error) {
+	setlist := strings.Split(conf, ",")
+	out := make(map[string]LogLevel)
+	for _, setstring := range setlist {
+		setting := strings.Split(setstring, "=")
+		if len(setting) != 2 {
+			return nil, errors.New("oddly structured `pkg=level` option: " + setstring)
+		}
+		l, err := ParseLevel(setting[1])
+		if err != nil {
+			return nil, err
+		}
+		out[setting[0]] = l
+	}
+	return out, nil
+}
+
+// SetLogLevel takes a map of package names within a repository to their desired
+// loglevel, and sets the levels appropriately. Unknown packages are ignored.
+// "*" is a special package name that corresponds to all packages, and will be
+// processed first.
+func (r RepoLogger) SetLogLevel(m map[string]LogLevel) {
+	logger.Lock()
+	defer logger.Unlock()
+	if l, ok := m["*"]; ok {
+		r.setRepoLogLevelInternal(l)
+	}
+	for k, v := range m {
+		l, ok := r[k]
+		if !ok {
+			continue
+		}
+		l.level = v
+	}
+}
+
+// SetFormatter sets the formatting function for all logs.
+func SetFormatter(f Formatter) {
+	logger.Lock()
+	defer logger.Unlock()
+	logger.formatter = f
+}
+
+// NewPackageLogger creates a package logger object.
+// This should be defined as a global var in your package, referencing your repo.
+func NewPackageLogger(repo string, pkg string) (p *PackageLogger) {
+	logger.Lock()
+	defer logger.Unlock()
+	if logger.repoMap == nil {
+		logger.repoMap = make(map[string]RepoLogger)
+	}
+	r, rok := logger.repoMap[repo]
+	if !rok {
+		logger.repoMap[repo] = make(RepoLogger)
+		r = logger.repoMap[repo]
+	}
+	p, pok := r[pkg]
+	if !pok {
+		r[pkg] = &PackageLogger{
+			pkg:   pkg,
+			level: INFO,
+		}
+		p = r[pkg]
+	}
+	return
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go b/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go
new file mode 100644
index 00000000..32d2f16a
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/pkg_logger.go
@@ -0,0 +1,158 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package capnslog
+
+import (
+	"fmt"
+	"os"
+)
+
+type PackageLogger struct {
+	pkg   string
+	level LogLevel
+}
+
+const calldepth = 2
+
+func (p *PackageLogger) internalLog(depth int, inLevel LogLevel, entries ...interface{}) {
+	if inLevel != CRITICAL && p.level < inLevel {
+		return
+	}
+	logger.Lock()
+	defer logger.Unlock()
+	if logger.formatter != nil {
+		logger.formatter.Format(p.pkg, inLevel, depth+1, entries...)
+	}
+}
+
+func (p *PackageLogger) LevelAt(l LogLevel) bool {
+	return p.level >= l
+}
+
+// Log a formatted string at any level between ERROR and TRACE
+func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) {
+	p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
+}
+
+// Log a message at any level between ERROR and TRACE
+func (p *PackageLogger) Log(l LogLevel, args ...interface{}) {
+	p.internalLog(calldepth, l, fmt.Sprint(args...))
+}
+
+// log stdlib compatibility
+
+func (p *PackageLogger) Println(args ...interface{}) {
+	p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
+}
+
+func (p *PackageLogger) Printf(format string, args ...interface{}) {
+	p.internalLog(calldepth, INFO, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Print(args ...interface{}) {
+	p.internalLog(calldepth, INFO, fmt.Sprint(args...))
+}
+
+// Panic and fatal
+
+func (p *PackageLogger) Panicf(format string, args ...interface{}) {
+	s := fmt.Sprintf(format, args...)
+	p.internalLog(calldepth, CRITICAL, s)
+	panic(s)
+}
+
+func (p *PackageLogger) Panic(args ...interface{}) {
+	s := fmt.Sprint(args...)
+	p.internalLog(calldepth, CRITICAL, s)
+	panic(s)
+}
+
+func (p *PackageLogger) Fatalf(format string, args ...interface{}) {
+	s := fmt.Sprintf(format, args...)
+	p.internalLog(calldepth, CRITICAL, s)
+	os.Exit(1)
+}
+
+func (p *PackageLogger) Fatal(args ...interface{}) {
+	s := fmt.Sprint(args...)
+	p.internalLog(calldepth, CRITICAL, s)
+	os.Exit(1)
+}
+
+// Error Functions
+
+func (p *PackageLogger) Errorf(format string, args ...interface{}) {
+	p.internalLog(calldepth, ERROR, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Error(entries ...interface{}) {
+	p.internalLog(calldepth, ERROR, entries...)
+}
+
+// Warning Functions
+
+func (p *PackageLogger) Warningf(format string, args ...interface{}) {
+	p.internalLog(calldepth, WARNING, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Warning(entries ...interface{}) {
+	p.internalLog(calldepth, WARNING, entries...)
+}
+
+// Notice Functions
+
+func (p *PackageLogger) Noticef(format string, args ...interface{}) {
+	p.internalLog(calldepth, NOTICE, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Notice(entries ...interface{}) {
+	p.internalLog(calldepth, NOTICE, entries...)
+}
+
+// Info Functions
+
+func (p *PackageLogger) Infof(format string, args ...interface{}) {
+	p.internalLog(calldepth, INFO, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Info(entries ...interface{}) {
+	p.internalLog(calldepth, INFO, entries...)
+}
+
+// Debug Functions
+
+func (p *PackageLogger) Debugf(format string, args ...interface{}) {
+	p.internalLog(calldepth, DEBUG, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Debug(entries ...interface{}) {
+	p.internalLog(calldepth, DEBUG, entries...)
+}
+
+// Trace Functions
+
+func (p *PackageLogger) Tracef(format string, args ...interface{}) {
+	p.internalLog(calldepth, TRACE, fmt.Sprintf(format, args...))
+}
+
+func (p *PackageLogger) Trace(entries ...interface{}) {
+	p.internalLog(calldepth, TRACE, entries...)
+}
+
+func (p *PackageLogger) Flush() {
+	logger.Lock()
+	defer logger.Unlock()
+	logger.formatter.Flush()
+}
diff --git a/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go b/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go
new file mode 100644
index 00000000..4be5a1f2
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/capnslog/syslog_formatter.go
@@ -0,0 +1,65 @@
+// Copyright 2015 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// +build !windows
+
+package capnslog
+
+import (
+	"fmt"
+	"log/syslog"
+)
+
+func NewSyslogFormatter(w *syslog.Writer) Formatter {
+	return &syslogFormatter{w}
+}
+
+func NewDefaultSyslogFormatter(tag string) (Formatter, error) {
+	w, err := syslog.New(syslog.LOG_DEBUG, tag)
+	if err != nil {
+		return nil, err
+	}
+	return NewSyslogFormatter(w), nil
+}
+
+type syslogFormatter struct {
+	w *syslog.Writer
+}
+
+func (s *syslogFormatter) Format(pkg string, l LogLevel, _ int, entries ...interface{}) {
+	for _, entry := range entries {
+		str := fmt.Sprint(entry)
+		switch l {
+		case CRITICAL:
+			s.w.Crit(str)
+		case ERROR:
+			s.w.Err(str)
+		case WARNING:
+			s.w.Warning(str)
+		case NOTICE:
+			s.w.Notice(str)
+		case INFO:
+			s.w.Info(str)
+		case DEBUG:
+			s.w.Debug(str)
+		case TRACE:
+			s.w.Debug(str)
+		default:
+			panic("Unhandled loglevel")
+		}
+	}
+}
+
+func (s *syslogFormatter) Flush() {
+}
diff --git a/vendor/github.com/coreos/pkg/timeutil/backoff.go b/vendor/github.com/coreos/pkg/timeutil/backoff.go
new file mode 100644
index 00000000..b34fb496
--- /dev/null
+++ b/vendor/github.com/coreos/pkg/timeutil/backoff.go
@@ -0,0 +1,15 @@
+package timeutil
+
+import (
+	"time"
+)
+
+func ExpBackoff(prev, max time.Duration) time.Duration {
+	if prev == 0 {
+		return time.Second
+	}
+	if prev > max/2 {
+		return max
+	}
+	return 2 * prev
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/Makefile b/vendor/github.com/gogo/protobuf/proto/Makefile
new file mode 100644
index 00000000..ba28d87a
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/Makefile
@@ -0,0 +1,43 @@
+# Go support for Protocol Buffers - Google's data interchange format
+#
+# Copyright 2010 The Go Authors.  All rights reserved.
+# https://github.com/golang/protobuf
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+install:
+	go install
+
+test: install generate-test-pbs
+	go test
+
+
+generate-test-pbs:
+	make install
+	make -C testdata
+	protoc-min-version --version="3.0.0" --proto_path=.:../../../../ proto3_proto/proto3.proto
+	make
diff --git a/vendor/github.com/gogo/protobuf/proto/clone.go b/vendor/github.com/gogo/protobuf/proto/clone.go
new file mode 100644
index 00000000..ba3e94bb
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/clone.go
@@ -0,0 +1,202 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer deep copy and merge.
+// TODO: MessageSet and RawMessage.
+
+package proto
+
+import (
+	"log"
+	"reflect"
+	"strings"
+)
+
+// Clone returns a deep copy of a protocol buffer.
+func Clone(pb Message) Message {
+	in := reflect.ValueOf(pb)
+	if in.IsNil() {
+		return pb
+	}
+
+	out := reflect.New(in.Type().Elem())
+	// out is empty so a merge is a deep copy.
+	mergeStruct(out.Elem(), in.Elem())
+	return out.Interface().(Message)
+}
+
+// Merge merges src into dst.
+// Required and optional fields that are set in src will be set to that value in dst.
+// Elements of repeated fields will be appended.
+// Merge panics if src and dst are not the same type, or if dst is nil.
+func Merge(dst, src Message) {
+	in := reflect.ValueOf(src)
+	out := reflect.ValueOf(dst)
+	if out.IsNil() {
+		panic("proto: nil destination")
+	}
+	if in.Type() != out.Type() {
+		// Explicit test prior to mergeStruct so that mistyped nils will fail
+		panic("proto: type mismatch")
+	}
+	if in.IsNil() {
+		// Merging nil into non-nil is a quiet no-op
+		return
+	}
+	mergeStruct(out.Elem(), in.Elem())
+}
+
+func mergeStruct(out, in reflect.Value) {
+	for i := 0; i < in.NumField(); i++ {
+		f := in.Type().Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		mergeAny(out.Field(i), in.Field(i))
+	}
+
+	if emIn, ok := in.Addr().Interface().(extensionsMap); ok {
+		emOut := out.Addr().Interface().(extensionsMap)
+		mergeExtension(emOut.ExtensionMap(), emIn.ExtensionMap())
+	} else if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {
+		emOut := out.Addr().Interface().(extensionsBytes)
+		bIn := emIn.GetExtensions()
+		bOut := emOut.GetExtensions()
+		*bOut = append(*bOut, *bIn...)
+	}
+
+	uf := in.FieldByName("XXX_unrecognized")
+	if !uf.IsValid() {
+		return
+	}
+	uin := uf.Bytes()
+	if len(uin) > 0 {
+		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
+	}
+}
+
+func mergeAny(out, in reflect.Value) {
+	if in.Type() == protoMessageType {
+		if !in.IsNil() {
+			if out.IsNil() {
+				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
+			} else {
+				Merge(out.Interface().(Message), in.Interface().(Message))
+			}
+		}
+		return
+	}
+	switch in.Kind() {
+	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+		reflect.String, reflect.Uint32, reflect.Uint64:
+		out.Set(in)
+	case reflect.Map:
+		if in.Len() == 0 {
+			return
+		}
+		if out.IsNil() {
+			out.Set(reflect.MakeMap(in.Type()))
+		}
+		// For maps with value types of *T or []byte we need to deep copy each value.
+		elemKind := in.Type().Elem().Kind()
+		for _, key := range in.MapKeys() {
+			var val reflect.Value
+			switch elemKind {
+			case reflect.Ptr:
+				val = reflect.New(in.Type().Elem().Elem())
+				mergeAny(val, in.MapIndex(key))
+			case reflect.Slice:
+				val = in.MapIndex(key)
+				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+			default:
+				val = in.MapIndex(key)
+			}
+			out.SetMapIndex(key, val)
+		}
+	case reflect.Ptr:
+		if in.IsNil() {
+			return
+		}
+		if out.IsNil() {
+			out.Set(reflect.New(in.Elem().Type()))
+		}
+		mergeAny(out.Elem(), in.Elem())
+	case reflect.Slice:
+		if in.IsNil() {
+			return
+		}
+		if in.Type().Elem().Kind() == reflect.Uint8 {
+			// []byte is a scalar bytes field, not a repeated field.
+			// Make a deep copy.
+			// Append to []byte{} instead of []byte(nil) so that we never end up
+			// with a nil result.
+			out.SetBytes(append([]byte{}, in.Bytes()...))
+			return
+		}
+		n := in.Len()
+		if out.IsNil() {
+			out.Set(reflect.MakeSlice(in.Type(), 0, n))
+		}
+		switch in.Type().Elem().Kind() {
+		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+			reflect.String, reflect.Uint32, reflect.Uint64:
+			out.Set(reflect.AppendSlice(out, in))
+		default:
+			for i := 0; i < n; i++ {
+				x := reflect.Indirect(reflect.New(in.Type().Elem()))
+				mergeAny(x, in.Index(i))
+				out.Set(reflect.Append(out, x))
+			}
+		}
+	case reflect.Struct:
+		mergeStruct(out, in)
+	default:
+		// unknown type, so not a protocol buffer
+		log.Printf("proto: don't know how to copy %v", in)
+	}
+}
+
+func mergeExtension(out, in map[int32]Extension) {
+	for extNum, eIn := range in {
+		eOut := Extension{desc: eIn.desc}
+		if eIn.value != nil {
+			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
+			mergeAny(v, reflect.ValueOf(eIn.value))
+			eOut.value = v.Interface()
+		}
+		if eIn.enc != nil {
+			eOut.enc = make([]byte, len(eIn.enc))
+			copy(eOut.enc, eIn.enc)
+		}
+
+		out[extNum] = eOut
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/decode.go b/vendor/github.com/gogo/protobuf/proto/decode.go
new file mode 100644
index 00000000..8bba5941
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode.go
@@ -0,0 +1,826 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for decoding protocol buffer data to construct in-memory representations.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+)
+
+// errOverflow is returned when an integer is too large to be represented.
+var errOverflow = errors.New("proto: integer overflow")
+
+// The fundamental decoders that interpret bytes on the wire.
+// Those that take integer types all return uint64 and are
+// therefore of type valueDecoder.
+
+// DecodeVarint reads a varint-encoded integer from the slice.
+// It returns the integer and the number of bytes consumed, or
+// zero if there is not enough.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func DecodeVarint(buf []byte) (x uint64, n int) {
+	// x, n already 0
+	for shift := uint(0); shift < 64; shift += 7 {
+		if n >= len(buf) {
+			return 0, 0
+		}
+		b := uint64(buf[n])
+		n++
+		x |= (b & 0x7F) << shift
+		if (b & 0x80) == 0 {
+			return x, n
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	return 0, 0
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) DecodeVarint() (x uint64, err error) {
+	// x, err already 0
+
+	i := p.index
+	l := len(p.buf)
+
+	for shift := uint(0); shift < 64; shift += 7 {
+		if i >= l {
+			err = io.ErrUnexpectedEOF
+			return
+		}
+		b := p.buf[i]
+		i++
+		x |= (uint64(b) & 0x7F) << shift
+		if b < 0x80 {
+			p.index = i
+			return
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	err = errOverflow
+	return
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) DecodeFixed64() (x uint64, err error) {
+	// x, err already 0
+	i := p.index + 8
+	if i < 0 || i > len(p.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	p.index = i
+
+	x = uint64(p.buf[i-8])
+	x |= uint64(p.buf[i-7]) << 8
+	x |= uint64(p.buf[i-6]) << 16
+	x |= uint64(p.buf[i-5]) << 24
+	x |= uint64(p.buf[i-4]) << 32
+	x |= uint64(p.buf[i-3]) << 40
+	x |= uint64(p.buf[i-2]) << 48
+	x |= uint64(p.buf[i-1]) << 56
+	return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) DecodeFixed32() (x uint64, err error) {
+	// x, err already 0
+	i := p.index + 4
+	if i < 0 || i > len(p.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	p.index = i
+
+	x = uint64(p.buf[i-4])
+	x |= uint64(p.buf[i-3]) << 8
+	x |= uint64(p.buf[i-2]) << 16
+	x |= uint64(p.buf[i-1]) << 24
+	return
+}
+
+// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
+// from the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
+	x, err = p.DecodeVarint()
+	if err != nil {
+		return
+	}
+	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
+	return
+}
+
+// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
+// from  the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
+	x, err = p.DecodeVarint()
+	if err != nil {
+		return
+	}
+	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
+	return
+}
+
+// These are not ValueDecoders: they produce an array of bytes or a string.
+// bytes, embedded messages
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+	n, err := p.DecodeVarint()
+	if err != nil {
+		return nil, err
+	}
+
+	nb := int(n)
+	if nb < 0 {
+		return nil, fmt.Errorf("proto: bad byte length %d", nb)
+	}
+	end := p.index + nb
+	if end < p.index || end > len(p.buf) {
+		return nil, io.ErrUnexpectedEOF
+	}
+
+	if !alloc {
+		// todo: check if can get more uses of alloc=false
+		buf = p.buf[p.index:end]
+		p.index += nb
+		return
+	}
+
+	buf = make([]byte, nb)
+	copy(buf, p.buf[p.index:])
+	p.index += nb
+	return
+}
+
+// DecodeStringBytes reads an encoded string from the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) DecodeStringBytes() (s string, err error) {
+	buf, err := p.DecodeRawBytes(false)
+	if err != nil {
+		return
+	}
+	return string(buf), nil
+}
+
+// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
+// If the protocol buffer has extensions, and the field matches, add it as an extension.
+// Otherwise, if the XXX_unrecognized field exists, append the skipped data there.
+func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error {
+	oi := o.index
+
+	err := o.skip(t, tag, wire)
+	if err != nil {
+		return err
+	}
+
+	if !unrecField.IsValid() {
+		return nil
+	}
+
+	ptr := structPointer_Bytes(base, unrecField)
+
+	// Add the skipped field to struct field
+	obuf := o.buf
+
+	o.buf = *ptr
+	o.EncodeVarint(uint64(tag<<3 | wire))
+	*ptr = append(o.buf, obuf[oi:o.index]...)
+
+	o.buf = obuf
+
+	return nil
+}
+
+// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
+func (o *Buffer) skip(t reflect.Type, tag, wire int) error {
+
+	var u uint64
+	var err error
+
+	switch wire {
+	case WireVarint:
+		_, err = o.DecodeVarint()
+	case WireFixed64:
+		_, err = o.DecodeFixed64()
+	case WireBytes:
+		_, err = o.DecodeRawBytes(false)
+	case WireFixed32:
+		_, err = o.DecodeFixed32()
+	case WireStartGroup:
+		for {
+			u, err = o.DecodeVarint()
+			if err != nil {
+				break
+			}
+			fwire := int(u & 0x7)
+			if fwire == WireEndGroup {
+				break
+			}
+			ftag := int(u >> 3)
+			err = o.skip(t, ftag, fwire)
+			if err != nil {
+				break
+			}
+		}
+	default:
+		err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t)
+	}
+	return err
+}
+
+// Unmarshaler is the interface representing objects that can
+// unmarshal themselves.  The method should reset the receiver before
+// decoding starts.  The argument points to data that may be
+// overwritten, so implementations should not keep references to the
+// buffer.
+type Unmarshaler interface {
+	Unmarshal([]byte) error
+}
+
+// Unmarshal parses the protocol buffer representation in buf and places the
+// decoded result in pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// Unmarshal resets pb before starting to unmarshal, so any
+// existing data in pb is always removed. Use UnmarshalMerge
+// to preserve and append to existing data.
+func Unmarshal(buf []byte, pb Message) error {
+	pb.Reset()
+	return UnmarshalMerge(buf, pb)
+}
+
+// UnmarshalMerge parses the protocol buffer representation in buf and
+// writes the decoded result to pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// UnmarshalMerge merges into existing data in pb.
+// Most code should use Unmarshal instead.
+func UnmarshalMerge(buf []byte, pb Message) error {
+	// If the object can unmarshal itself, let it.
+	if u, ok := pb.(Unmarshaler); ok {
+		return u.Unmarshal(buf)
+	}
+	return NewBuffer(buf).Unmarshal(pb)
+}
+
+// Unmarshal parses the protocol buffer representation in the
+// Buffer and places the decoded result in pb.  If the struct
+// underlying pb does not match the data in the buffer, the results can be
+// unpredictable.
+func (p *Buffer) Unmarshal(pb Message) error {
+	// If the object can unmarshal itself, let it.
+	if u, ok := pb.(Unmarshaler); ok {
+		err := u.Unmarshal(p.buf[p.index:])
+		p.index = len(p.buf)
+		return err
+	}
+
+	typ, base, err := getbase(pb)
+	if err != nil {
+		return err
+	}
+
+	err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base)
+
+	if collectStats {
+		stats.Decode++
+	}
+
+	return err
+}
+
+// unmarshalType does the work of unmarshaling a structure.
+func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error {
+	var state errorState
+	required, reqFields := prop.reqCount, uint64(0)
+
+	var err error
+	for err == nil && o.index < len(o.buf) {
+		oi := o.index
+		var u uint64
+		u, err = o.DecodeVarint()
+		if err != nil {
+			break
+		}
+		wire := int(u & 0x7)
+		if wire == WireEndGroup {
+			if is_group {
+				return nil // input is satisfied
+			}
+			return fmt.Errorf("proto: %s: wiretype end group for non-group", st)
+		}
+		tag := int(u >> 3)
+		if tag <= 0 {
+			return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire)
+		}
+		fieldnum, ok := prop.decoderTags.get(tag)
+		if !ok {
+			// Maybe it's an extension?
+			if prop.extendable {
+				if e := structPointer_Interface(base, st).(extendableProto); isExtensionField(e, int32(tag)) {
+					if err = o.skip(st, tag, wire); err == nil {
+						if ee, ok := e.(extensionsMap); ok {
+							ext := ee.ExtensionMap()[int32(tag)] // may be missing
+							ext.enc = append(ext.enc, o.buf[oi:o.index]...)
+							ee.ExtensionMap()[int32(tag)] = ext
+						} else if ee, ok := e.(extensionsBytes); ok {
+							ext := ee.GetExtensions()
+							*ext = append(*ext, o.buf[oi:o.index]...)
+						}
+					}
+					continue
+				}
+			}
+			err = o.skipAndSave(st, tag, wire, base, prop.unrecField)
+			continue
+		}
+		p := prop.Prop[fieldnum]
+
+		if p.dec == nil {
+			fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name)
+			continue
+		}
+		dec := p.dec
+		if wire != WireStartGroup && wire != p.WireType {
+			if wire == WireBytes && p.packedDec != nil {
+				// a packable field
+				dec = p.packedDec
+			} else {
+				err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType)
+				continue
+			}
+		}
+		decErr := dec(o, p, base)
+		if decErr != nil && !state.shouldContinue(decErr, p) {
+			err = decErr
+		}
+		if err == nil && p.Required {
+			// Successfully decoded a required field.
+			if tag <= 64 {
+				// use bitmap for fields 1-64 to catch field reuse.
+				var mask uint64 = 1 << uint64(tag-1)
+				if reqFields&mask == 0 {
+					// new required field
+					reqFields |= mask
+					required--
+				}
+			} else {
+				// This is imprecise. It can be fooled by a required field
+				// with a tag > 64 that is encoded twice; that's very rare.
+				// A fully correct implementation would require allocating
+				// a data structure, which we would like to avoid.
+				required--
+			}
+		}
+	}
+	if err == nil {
+		if is_group {
+			return io.ErrUnexpectedEOF
+		}
+		if state.err != nil {
+			return state.err
+		}
+		if required > 0 {
+			// Not enough information to determine the exact field. If we use extra
+			// CPU, we could determine the field only if the missing required field
+			// has a tag <= 64 and we check reqFields.
+			return &RequiredNotSetError{"{Unknown}"}
+		}
+	}
+	return err
+}
+
+// Individual type decoders
+// For each,
+//	u is the decoded value,
+//	v is a pointer to the field (pointer) in the struct
+
+// Sizes of the pools to allocate inside the Buffer.
+// The goal is modest amortization and allocation
+// on at least 16-byte boundaries.
+const (
+	boolPoolSize   = 16
+	uint32PoolSize = 8
+	uint64PoolSize = 4
+)
+
+// Decode a bool.
+func (o *Buffer) dec_bool(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	if len(o.bools) == 0 {
+		o.bools = make([]bool, boolPoolSize)
+	}
+	o.bools[0] = u != 0
+	*structPointer_Bool(base, p.field) = &o.bools[0]
+	o.bools = o.bools[1:]
+	return nil
+}
+
+func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	*structPointer_BoolVal(base, p.field) = u != 0
+	return nil
+}
+
+// Decode an int32.
+func (o *Buffer) dec_int32(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word32_Set(structPointer_Word32(base, p.field), o, uint32(u))
+	return nil
+}
+
+func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u))
+	return nil
+}
+
+// Decode an int64.
+func (o *Buffer) dec_int64(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word64_Set(structPointer_Word64(base, p.field), o, u)
+	return nil
+}
+
+func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word64Val_Set(structPointer_Word64Val(base, p.field), o, u)
+	return nil
+}
+
+// Decode a string.
+func (o *Buffer) dec_string(p *Properties, base structPointer) error {
+	s, err := o.DecodeStringBytes()
+	if err != nil {
+		return err
+	}
+	*structPointer_String(base, p.field) = &s
+	return nil
+}
+
+func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error {
+	s, err := o.DecodeStringBytes()
+	if err != nil {
+		return err
+	}
+	*structPointer_StringVal(base, p.field) = s
+	return nil
+}
+
+// Decode a slice of bytes ([]byte).
+func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	*structPointer_Bytes(base, p.field) = b
+	return nil
+}
+
+// Decode a slice of bools ([]bool).
+func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	v := structPointer_BoolSlice(base, p.field)
+	*v = append(*v, u != 0)
+	return nil
+}
+
+// Decode a slice of bools ([]bool) in packed format.
+func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error {
+	v := structPointer_BoolSlice(base, p.field)
+
+	nn, err := o.DecodeVarint()
+	if err != nil {
+		return err
+	}
+	nb := int(nn) // number of bytes of encoded bools
+
+	y := *v
+	for i := 0; i < nb; i++ {
+		u, err := p.valDec(o)
+		if err != nil {
+			return err
+		}
+		y = append(y, u != 0)
+	}
+
+	*v = y
+	return nil
+}
+
+// Decode a slice of int32s ([]int32).
+func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	structPointer_Word32Slice(base, p.field).Append(uint32(u))
+	return nil
+}
+
+// Decode a slice of int32s ([]int32) in packed format.
+func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Slice(base, p.field)
+
+	nn, err := o.DecodeVarint()
+	if err != nil {
+		return err
+	}
+	nb := int(nn) // number of bytes of encoded int32s
+
+	fin := o.index + nb
+	if fin < o.index {
+		return errOverflow
+	}
+	for o.index < fin {
+		u, err := p.valDec(o)
+		if err != nil {
+			return err
+		}
+		v.Append(uint32(u))
+	}
+	return nil
+}
+
+// Decode a slice of int64s ([]int64).
+func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+
+	structPointer_Word64Slice(base, p.field).Append(u)
+	return nil
+}
+
+// Decode a slice of int64s ([]int64) in packed format.
+func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64Slice(base, p.field)
+
+	nn, err := o.DecodeVarint()
+	if err != nil {
+		return err
+	}
+	nb := int(nn) // number of bytes of encoded int64s
+
+	fin := o.index + nb
+	if fin < o.index {
+		return errOverflow
+	}
+	for o.index < fin {
+		u, err := p.valDec(o)
+		if err != nil {
+			return err
+		}
+		v.Append(u)
+	}
+	return nil
+}
+
+// Decode a slice of strings ([]string).
+func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error {
+	s, err := o.DecodeStringBytes()
+	if err != nil {
+		return err
+	}
+	v := structPointer_StringSlice(base, p.field)
+	*v = append(*v, s)
+	return nil
+}
+
+// Decode a slice of slice of bytes ([][]byte).
+func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	v := structPointer_BytesSlice(base, p.field)
+	*v = append(*v, b)
+	return nil
+}
+
+// Decode a map field.
+func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {
+	raw, err := o.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+	oi := o.index       // index at the end of this map entry
+	o.index -= len(raw) // move buffer back to start of map entry
+
+	mptr := structPointer_Map(base, p.field, p.mtype) // *map[K]V
+	if mptr.Elem().IsNil() {
+		mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem()))
+	}
+	v := mptr.Elem() // map[K]V
+
+	// Prepare addressable doubly-indirect placeholders for the key and value types.
+	// See enc_new_map for why.
+	keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K
+	keybase := toStructPointer(keyptr.Addr())                  // **K
+
+	var valbase structPointer
+	var valptr reflect.Value
+	switch p.mtype.Elem().Kind() {
+	case reflect.Slice:
+		// []byte
+		var dummy []byte
+		valptr = reflect.ValueOf(&dummy)  // *[]byte
+		valbase = toStructPointer(valptr) // *[]byte
+	case reflect.Ptr:
+		// message; valptr is **Msg; need to allocate the intermediate pointer
+		valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
+		valptr.Set(reflect.New(valptr.Type().Elem()))
+		valbase = toStructPointer(valptr)
+	default:
+		// everything else
+		valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
+		valbase = toStructPointer(valptr.Addr())                   // **V
+	}
+
+	// Decode.
+	// This parses a restricted wire format, namely the encoding of a message
+	// with two fields. See enc_new_map for the format.
+	for o.index < oi {
+		// tagcode for key and value properties are always a single byte
+		// because they have tags 1 and 2.
+		tagcode := o.buf[o.index]
+		o.index++
+		switch tagcode {
+		case p.mkeyprop.tagcode[0]:
+			if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil {
+				return err
+			}
+		case p.mvalprop.tagcode[0]:
+			if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil {
+				return err
+			}
+		default:
+			// TODO: Should we silently skip this instead?
+			return fmt.Errorf("proto: bad map data tag %d", raw[0])
+		}
+	}
+
+	v.SetMapIndex(keyptr.Elem(), valptr.Elem())
+	return nil
+}
+
+// Decode a group.
+func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error {
+	bas := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(bas) {
+		// allocate new nested message
+		bas = toStructPointer(reflect.New(p.stype))
+		structPointer_SetStructPointer(base, p.field, bas)
+	}
+	return o.unmarshalType(p.stype, p.sprop, true, bas)
+}
+
+// Decode an embedded message.
+func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) {
+	raw, e := o.DecodeRawBytes(false)
+	if e != nil {
+		return e
+	}
+
+	bas := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(bas) {
+		// allocate new nested message
+		bas = toStructPointer(reflect.New(p.stype))
+		structPointer_SetStructPointer(base, p.field, bas)
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		iv := structPointer_Interface(bas, p.stype)
+		return iv.(Unmarshaler).Unmarshal(raw)
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	err = o.unmarshalType(p.stype, p.sprop, false, bas)
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
+
+// Decode a slice of embedded messages.
+func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error {
+	return o.dec_slice_struct(p, false, base)
+}
+
+// Decode a slice of embedded groups.
+func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error {
+	return o.dec_slice_struct(p, true, base)
+}
+
+// Decode a slice of structs ([]*struct).
+func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error {
+	v := reflect.New(p.stype)
+	bas := toStructPointer(v)
+	structPointer_StructPointerSlice(base, p.field).Append(bas)
+
+	if is_group {
+		err := o.unmarshalType(p.stype, p.sprop, is_group, bas)
+		return err
+	}
+
+	raw, err := o.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		iv := v.Interface()
+		return iv.(Unmarshaler).Unmarshal(raw)
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	err = o.unmarshalType(p.stype, p.sprop, is_group, bas)
+
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/decode_gogo.go b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go
new file mode 100644
index 00000000..6a77aad7
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go
@@ -0,0 +1,175 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"reflect"
+)
+
+// Decode a reference to a struct pointer.
+func (o *Buffer) dec_ref_struct_message(p *Properties, base structPointer) (err error) {
+	raw, e := o.DecodeRawBytes(false)
+	if e != nil {
+		return e
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		panic("not supported, since this is a pointer receiver")
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	bas := structPointer_FieldPointer(base, p.field)
+
+	err = o.unmarshalType(p.stype, p.sprop, false, bas)
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
+
+// Decode a slice of references to struct pointers ([]struct).
+func (o *Buffer) dec_slice_ref_struct(p *Properties, is_group bool, base structPointer) error {
+	newBas := appendStructPointer(base, p.field, p.sstype)
+
+	if is_group {
+		panic("not supported, maybe in future, if requested.")
+	}
+
+	raw, err := o.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		panic("not supported, since this is not a pointer receiver.")
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	err = o.unmarshalType(p.stype, p.sprop, is_group, newBas)
+
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
+
+// Decode a slice of references to struct pointers.
+func (o *Buffer) dec_slice_ref_struct_message(p *Properties, base structPointer) error {
+	return o.dec_slice_ref_struct(p, false, base)
+}
+
+func setPtrCustomType(base structPointer, f field, v interface{}) {
+	if v == nil {
+		return
+	}
+	structPointer_SetStructPointer(base, f, structPointer(reflect.ValueOf(v).Pointer()))
+}
+
+func setCustomType(base structPointer, f field, value interface{}) {
+	if value == nil {
+		return
+	}
+	v := reflect.ValueOf(value).Elem()
+	t := reflect.TypeOf(value).Elem()
+	kind := t.Kind()
+	switch kind {
+	case reflect.Slice:
+		slice := reflect.MakeSlice(t, v.Len(), v.Cap())
+		reflect.Copy(slice, v)
+		oldHeader := structPointer_GetSliceHeader(base, f)
+		oldHeader.Data = slice.Pointer()
+		oldHeader.Len = v.Len()
+		oldHeader.Cap = v.Cap()
+	default:
+		l := 1
+		size := reflect.TypeOf(value).Elem().Size()
+		if kind == reflect.Array {
+			l = reflect.TypeOf(value).Elem().Len()
+			size = reflect.TypeOf(value).Size()
+		}
+		total := int(size) * l
+		structPointer_Copy(toStructPointer(reflect.ValueOf(value)), structPointer_Add(base, f), total)
+	}
+}
+
+func (o *Buffer) dec_custom_bytes(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	i := reflect.New(p.ctype.Elem()).Interface()
+	custom := (i).(Unmarshaler)
+	if err := custom.Unmarshal(b); err != nil {
+		return err
+	}
+	setPtrCustomType(base, p.field, custom)
+	return nil
+}
+
+func (o *Buffer) dec_custom_ref_bytes(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	i := reflect.New(p.ctype).Interface()
+	custom := (i).(Unmarshaler)
+	if err := custom.Unmarshal(b); err != nil {
+		return err
+	}
+	if custom != nil {
+		setCustomType(base, p.field, custom)
+	}
+	return nil
+}
+
+// Decode a slice of bytes ([]byte) into a slice of custom types.
+func (o *Buffer) dec_custom_slice_bytes(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	i := reflect.New(p.ctype.Elem()).Interface()
+	custom := (i).(Unmarshaler)
+	if err := custom.Unmarshal(b); err != nil {
+		return err
+	}
+	newBas := appendStructPointer(base, p.field, p.ctype)
+
+	setCustomType(newBas, 0, custom)
+
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/encode.go b/vendor/github.com/gogo/protobuf/proto/encode.go
new file mode 100644
index 00000000..d1abc332
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode.go
@@ -0,0 +1,1288 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+// RequiredNotSetError is the error returned if Marshal is called with
+// a protocol buffer struct whose required fields have not
+// all been initialized. It is also the error returned if Unmarshal is
+// called with an encoded protocol buffer that does not include all the
+// required fields.
+//
+// When printed, RequiredNotSetError reports the first unset required field in a
+// message. If the field cannot be precisely determined, it is reported as
+// "{Unknown}".
+type RequiredNotSetError struct {
+	field string
+}
+
+func (e *RequiredNotSetError) Error() string {
+	return fmt.Sprintf("proto: required field %q not set", e.field)
+}
+
+var (
+	// errRepeatedHasNil is the error returned if Marshal is called with
+	// a struct with a repeated field containing a nil element.
+	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+
+	// ErrNil is the error returned if Marshal is called with nil.
+	ErrNil = errors.New("proto: Marshal called with nil")
+)
+
+// The fundamental encoders that put bytes on the wire.
+// Those that take integer types all accept uint64 and are
+// therefore of type valueEncoder.
+
+const maxVarintBytes = 10 // maximum length of a varint
+
+// EncodeVarint returns the varint encoding of x.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+// Not used by the package itself, but helpful to clients
+// wishing to use the same encoding.
+func EncodeVarint(x uint64) []byte {
+	var buf [maxVarintBytes]byte
+	var n int
+	for n = 0; x > 127; n++ {
+		buf[n] = 0x80 | uint8(x&0x7F)
+		x >>= 7
+	}
+	buf[n] = uint8(x)
+	n++
+	return buf[0:n]
+}
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) EncodeVarint(x uint64) error {
+	for x >= 1<<7 {
+		p.buf = append(p.buf, uint8(x&0x7f|0x80))
+		x >>= 7
+	}
+	p.buf = append(p.buf, uint8(x))
+	return nil
+}
+
+func sizeVarint(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) EncodeFixed64(x uint64) error {
+	p.buf = append(p.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24),
+		uint8(x>>32),
+		uint8(x>>40),
+		uint8(x>>48),
+		uint8(x>>56))
+	return nil
+}
+
+func sizeFixed64(x uint64) int {
+	return 8
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) EncodeFixed32(x uint64) error {
+	p.buf = append(p.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24))
+	return nil
+}
+
+func sizeFixed32(x uint64) int {
+	return 4
+}
+
+// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
+// to the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) EncodeZigzag64(x uint64) error {
+	// use signed number to get arithmetic right shift.
+	return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+func sizeZigzag64(x uint64) int {
+	return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
+// to the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) EncodeZigzag32(x uint64) error {
+	// use signed number to get arithmetic right shift.
+	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+func sizeZigzag32(x uint64) int {
+	return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) EncodeRawBytes(b []byte) error {
+	p.EncodeVarint(uint64(len(b)))
+	p.buf = append(p.buf, b...)
+	return nil
+}
+
+func sizeRawBytes(b []byte) int {
+	return sizeVarint(uint64(len(b))) +
+		len(b)
+}
+
+// EncodeStringBytes writes an encoded string to the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) EncodeStringBytes(s string) error {
+	p.EncodeVarint(uint64(len(s)))
+	p.buf = append(p.buf, s...)
+	return nil
+}
+
+func sizeStringBytes(s string) int {
+	return sizeVarint(uint64(len(s))) +
+		len(s)
+}
+
+// Marshaler is the interface representing objects that can marshal themselves.
+type Marshaler interface {
+	Marshal() ([]byte, error)
+}
+
+// Marshal takes the protocol buffer
+// and encodes it into the wire format, returning the data.
+func Marshal(pb Message) ([]byte, error) {
+	// Can the object marshal itself?
+	if m, ok := pb.(Marshaler); ok {
+		return m.Marshal()
+	}
+	p := NewBuffer(nil)
+	err := p.Marshal(pb)
+	var state errorState
+	if err != nil && !state.shouldContinue(err, nil) {
+		return nil, err
+	}
+	if p.buf == nil && err == nil {
+		// Return a non-nil slice on success.
+		return []byte{}, nil
+	}
+	return p.buf, err
+}
+
+// Marshal takes the protocol buffer
+// and encodes it into the wire format, writing the result to the
+// Buffer.
+func (p *Buffer) Marshal(pb Message) error {
+	// Can the object marshal itself?
+	if m, ok := pb.(Marshaler); ok {
+		data, err := m.Marshal()
+		if err != nil {
+			return err
+		}
+		p.buf = append(p.buf, data...)
+		return nil
+	}
+
+	t, base, err := getbase(pb)
+	if structPointer_IsNil(base) {
+		return ErrNil
+	}
+	if err == nil {
+		err = p.enc_struct(GetProperties(t.Elem()), base)
+	}
+
+	if collectStats {
+		stats.Encode++
+	}
+
+	return err
+}
+
+// Size returns the encoded size of a protocol buffer.
+func Size(pb Message) (n int) {
+	// Can the object marshal itself?  If so, Size is slow.
+	// TODO: add Size to Marshaler, or add a Sizer interface.
+	if m, ok := pb.(Marshaler); ok {
+		b, _ := m.Marshal()
+		return len(b)
+	}
+
+	t, base, err := getbase(pb)
+	if structPointer_IsNil(base) {
+		return 0
+	}
+	if err == nil {
+		n = size_struct(GetProperties(t.Elem()), base)
+	}
+
+	if collectStats {
+		stats.Size++
+	}
+
+	return
+}
+
+// Individual type encoders.
+
+// Encode a bool.
+func (o *Buffer) enc_bool(p *Properties, base structPointer) error {
+	v := *structPointer_Bool(base, p.field)
+	if v == nil {
+		return ErrNil
+	}
+	x := 0
+	if *v {
+		x = 1
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error {
+	v := *structPointer_BoolVal(base, p.field)
+	if !v {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, 1)
+	return nil
+}
+
+func size_bool(p *Properties, base structPointer) int {
+	v := *structPointer_Bool(base, p.field)
+	if v == nil {
+		return 0
+	}
+	return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+func size_proto3_bool(p *Properties, base structPointer) int {
+	v := *structPointer_BoolVal(base, p.field)
+	if !v {
+		return 0
+	}
+	return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+// Encode an int32.
+func (o *Buffer) enc_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return ErrNil
+	}
+	x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
+	if x == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_int32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return 0
+	}
+	x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+func size_proto3_int32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
+	if x == 0 {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+// Encode a uint32.
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_uint32(p *Properties, base structPointer) error {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return ErrNil
+	}
+	x := word32_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	if x == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_uint32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return 0
+	}
+	x := word32_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+func size_proto3_uint32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	if x == 0 {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+// Encode an int64.
+func (o *Buffer) enc_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64(base, p.field)
+	if word64_IsNil(v) {
+		return ErrNil
+	}
+	x := word64_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, x)
+	return nil
+}
+
+func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	if x == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, x)
+	return nil
+}
+
+func size_int64(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word64(base, p.field)
+	if word64_IsNil(v) {
+		return 0
+	}
+	x := word64_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(x)
+	return
+}
+
+func size_proto3_int64(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	if x == 0 {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += p.valSize(x)
+	return
+}
+
+// Encode a string.
+func (o *Buffer) enc_string(p *Properties, base structPointer) error {
+	v := *structPointer_String(base, p.field)
+	if v == nil {
+		return ErrNil
+	}
+	x := *v
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeStringBytes(x)
+	return nil
+}
+
+func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error {
+	v := *structPointer_StringVal(base, p.field)
+	if v == "" {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeStringBytes(v)
+	return nil
+}
+
+func size_string(p *Properties, base structPointer) (n int) {
+	v := *structPointer_String(base, p.field)
+	if v == nil {
+		return 0
+	}
+	x := *v
+	n += len(p.tagcode)
+	n += sizeStringBytes(x)
+	return
+}
+
+func size_proto3_string(p *Properties, base structPointer) (n int) {
+	v := *structPointer_StringVal(base, p.field)
+	if v == "" {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeStringBytes(v)
+	return
+}
+
+// All protocol buffer fields are nillable, but be careful.
+func isNil(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return v.IsNil()
+	}
+	return false
+}
+
+// Encode a message struct.
+func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return ErrNil
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, err := m.Marshal()
+		if err != nil && !state.shouldContinue(err, nil) {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+		return nil
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	return o.enc_len_struct(p.sprop, structp, &state)
+}
+
+func size_struct_message(p *Properties, base structPointer) int {
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return 0
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, _ := m.Marshal()
+		n0 := len(p.tagcode)
+		n1 := sizeRawBytes(data)
+		return n0 + n1
+	}
+
+	n0 := len(p.tagcode)
+	n1 := size_struct(p.sprop, structp)
+	n2 := sizeVarint(uint64(n1)) // size of encoded length
+	return n0 + n1 + n2
+}
+
+// Encode a group struct.
+func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error {
+	var state errorState
+	b := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(b) {
+		return ErrNil
+	}
+
+	o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
+	err := o.enc_struct(p.sprop, b)
+	if err != nil && !state.shouldContinue(err, nil) {
+		return err
+	}
+	o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
+	return state.err
+}
+
+func size_struct_group(p *Properties, base structPointer) (n int) {
+	b := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(b) {
+		return 0
+	}
+
+	n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup))
+	n += size_struct(p.sprop, b)
+	n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup))
+	return
+}
+
+// Encode a slice of bools ([]bool).
+func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return ErrNil
+	}
+	for _, x := range s {
+		o.buf = append(o.buf, p.tagcode...)
+		v := uint64(0)
+		if x {
+			v = 1
+		}
+		p.valEnc(o, v)
+	}
+	return nil
+}
+
+func size_slice_bool(p *Properties, base structPointer) int {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return 0
+	}
+	return l * (len(p.tagcode) + 1) // each bool takes exactly one byte
+}
+
+// Encode a slice of bools ([]bool) in packed format.
+func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(l)) // each bool takes exactly one byte
+	for _, x := range s {
+		v := uint64(0)
+		if x {
+			v = 1
+		}
+		p.valEnc(o, v)
+	}
+	return nil
+}
+
+func size_slice_packed_bool(p *Properties, base structPointer) (n int) {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(l))
+	n += l // each bool takes exactly one byte
+	return
+}
+
+// Encode a slice of bytes ([]byte).
+func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(s)
+	return nil
+}
+
+func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error {
+	s := *structPointer_Bytes(base, p.field)
+	if len(s) == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(s)
+	return nil
+}
+
+func size_slice_byte(p *Properties, base structPointer) (n int) {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeRawBytes(s)
+	return
+}
+
+func size_proto3_slice_byte(p *Properties, base structPointer) (n int) {
+	s := *structPointer_Bytes(base, p.field)
+	if len(s) == 0 {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeRawBytes(s)
+	return
+}
+
+// Encode a slice of int32s ([]int32).
+func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		p.valEnc(o, uint64(x))
+	}
+	return nil
+}
+
+func size_slice_int32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		n += len(p.tagcode)
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		n += p.valSize(uint64(x))
+	}
+	return
+}
+
+// Encode a slice of int32s ([]int32) in packed format.
+func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	// TODO: Reuse a Buffer.
+	buf := NewBuffer(nil)
+	for i := 0; i < l; i++ {
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		p.valEnc(buf, uint64(x))
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(len(buf.buf)))
+	o.buf = append(o.buf, buf.buf...)
+	return nil
+}
+
+func size_slice_packed_int32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	var bufSize int
+	for i := 0; i < l; i++ {
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		bufSize += p.valSize(uint64(x))
+	}
+
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(bufSize))
+	n += bufSize
+	return
+}
+
+// Encode a slice of uint32s ([]uint32).
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		x := s.Index(i)
+		p.valEnc(o, uint64(x))
+	}
+	return nil
+}
+
+func size_slice_uint32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		n += len(p.tagcode)
+		x := s.Index(i)
+		n += p.valSize(uint64(x))
+	}
+	return
+}
+
+// Encode a slice of uint32s ([]uint32) in packed format.
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	// TODO: Reuse a Buffer.
+	buf := NewBuffer(nil)
+	for i := 0; i < l; i++ {
+		p.valEnc(buf, uint64(s.Index(i)))
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(len(buf.buf)))
+	o.buf = append(o.buf, buf.buf...)
+	return nil
+}
+
+func size_slice_packed_uint32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	var bufSize int
+	for i := 0; i < l; i++ {
+		bufSize += p.valSize(uint64(s.Index(i)))
+	}
+
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(bufSize))
+	n += bufSize
+	return
+}
+
+// Encode a slice of int64s ([]int64).
+func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		p.valEnc(o, s.Index(i))
+	}
+	return nil
+}
+
+func size_slice_int64(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		n += len(p.tagcode)
+		n += p.valSize(s.Index(i))
+	}
+	return
+}
+
+// Encode a slice of int64s ([]int64) in packed format.
+func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	// TODO: Reuse a Buffer.
+	buf := NewBuffer(nil)
+	for i := 0; i < l; i++ {
+		p.valEnc(buf, s.Index(i))
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(len(buf.buf)))
+	o.buf = append(o.buf, buf.buf...)
+	return nil
+}
+
+func size_slice_packed_int64(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	var bufSize int
+	for i := 0; i < l; i++ {
+		bufSize += p.valSize(s.Index(i))
+	}
+
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(bufSize))
+	n += bufSize
+	return
+}
+
+// Encode a slice of slice of bytes ([][]byte).
+func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error {
+	ss := *structPointer_BytesSlice(base, p.field)
+	l := len(ss)
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(ss[i])
+	}
+	return nil
+}
+
+func size_slice_slice_byte(p *Properties, base structPointer) (n int) {
+	ss := *structPointer_BytesSlice(base, p.field)
+	l := len(ss)
+	if l == 0 {
+		return 0
+	}
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		n += sizeRawBytes(ss[i])
+	}
+	return
+}
+
+// Encode a slice of strings ([]string).
+func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error {
+	ss := *structPointer_StringSlice(base, p.field)
+	l := len(ss)
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeStringBytes(ss[i])
+	}
+	return nil
+}
+
+func size_slice_string(p *Properties, base structPointer) (n int) {
+	ss := *structPointer_StringSlice(base, p.field)
+	l := len(ss)
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		n += sizeStringBytes(ss[i])
+	}
+	return
+}
+
+// Encode a slice of message structs ([]*struct).
+func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+
+	for i := 0; i < l; i++ {
+		structp := s.Index(i)
+		if structPointer_IsNil(structp) {
+			return errRepeatedHasNil
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, err := m.Marshal()
+			if err != nil && !state.shouldContinue(err, nil) {
+				return err
+			}
+			o.buf = append(o.buf, p.tagcode...)
+			o.EncodeRawBytes(data)
+			continue
+		}
+
+		o.buf = append(o.buf, p.tagcode...)
+		err := o.enc_len_struct(p.sprop, structp, &state)
+		if err != nil && !state.shouldContinue(err, nil) {
+			if err == ErrNil {
+				return errRepeatedHasNil
+			}
+			return err
+		}
+	}
+	return state.err
+}
+
+func size_slice_struct_message(p *Properties, base structPointer) (n int) {
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		structp := s.Index(i)
+		if structPointer_IsNil(structp) {
+			return // return the size up to this point
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, _ := m.Marshal()
+			n += len(p.tagcode)
+			n += sizeRawBytes(data)
+			continue
+		}
+
+		n0 := size_struct(p.sprop, structp)
+		n1 := sizeVarint(uint64(n0)) // size of encoded length
+		n += n0 + n1
+	}
+	return
+}
+
+// Encode a slice of group structs ([]*struct).
+func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error {
+	var state errorState
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+
+	for i := 0; i < l; i++ {
+		b := s.Index(i)
+		if structPointer_IsNil(b) {
+			return errRepeatedHasNil
+		}
+
+		o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
+
+		err := o.enc_struct(p.sprop, b)
+
+		if err != nil && !state.shouldContinue(err, nil) {
+			if err == ErrNil {
+				return errRepeatedHasNil
+			}
+			return err
+		}
+
+		o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
+	}
+	return state.err
+}
+
+func size_slice_struct_group(p *Properties, base structPointer) (n int) {
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+
+	n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup))
+	n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup))
+	for i := 0; i < l; i++ {
+		b := s.Index(i)
+		if structPointer_IsNil(b) {
+			return // return size up to this point
+		}
+
+		n += size_struct(p.sprop, b)
+	}
+	return
+}
+
+// Encode an extension map.
+func (o *Buffer) enc_map(p *Properties, base structPointer) error {
+	v := *structPointer_ExtMap(base, p.field)
+	if err := encodeExtensionMap(v); err != nil {
+		return err
+	}
+	// Fast-path for common cases: zero or one extensions.
+	if len(v) <= 1 {
+		for _, e := range v {
+			o.buf = append(o.buf, e.enc...)
+		}
+		return nil
+	}
+
+	// Sort keys to provide a deterministic encoding.
+	keys := make([]int, 0, len(v))
+	for k := range v {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+
+	for _, k := range keys {
+		o.buf = append(o.buf, v[int32(k)].enc...)
+	}
+	return nil
+}
+
+func size_map(p *Properties, base structPointer) int {
+	v := *structPointer_ExtMap(base, p.field)
+	return sizeExtensionMap(v)
+}
+
+// Encode a map field.
+func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
+	var state errorState // XXX: or do we need to plumb this through?
+
+	/*
+		A map defined as
+			map<key_type, value_type> map_field = N;
+		is encoded in the same way as
+			message MapFieldEntry {
+				key_type key = 1;
+				value_type value = 2;
+			}
+			repeated MapFieldEntry map_field = N;
+	*/
+
+	v := structPointer_Map(base, p.field, p.mtype).Elem() // map[K]V
+	if v.Len() == 0 {
+		return nil
+	}
+
+	keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
+
+	enc := func() error {
+		if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {
+			return err
+		}
+		if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	keys := v.MapKeys()
+	sort.Sort(mapKeys(keys))
+	for _, key := range keys {
+		val := v.MapIndex(key)
+
+		keycopy.Set(key)
+		valcopy.Set(val)
+
+		o.buf = append(o.buf, p.tagcode...)
+		if err := o.enc_len_thing(enc, &state); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func size_new_map(p *Properties, base structPointer) int {
+	v := structPointer_Map(base, p.field, p.mtype).Elem() // map[K]V
+
+	keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
+
+	n := 0
+	for _, key := range v.MapKeys() {
+		val := v.MapIndex(key)
+		keycopy.Set(key)
+		valcopy.Set(val)
+
+		// Tag codes for key and val are the responsibility of the sub-sizer.
+		keysize := p.mkeyprop.size(p.mkeyprop, keybase)
+		valsize := p.mvalprop.size(p.mvalprop, valbase)
+		entry := keysize + valsize
+		// Add on tag code and length of map entry itself.
+		n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry
+	}
+	return n
+}
+
+// mapEncodeScratch returns a new reflect.Value matching the map's value type,
+// and a structPointer suitable for passing to an encoder or sizer.
+func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {
+	// Prepare addressable doubly-indirect placeholders for the key and value types.
+	// This is needed because the element-type encoders expect **T, but the map iteration produces T.
+
+	keycopy = reflect.New(mapType.Key()).Elem()                 // addressable K
+	keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K
+	keyptr.Set(keycopy.Addr())                                  //
+	keybase = toStructPointer(keyptr.Addr())                    // **K
+
+	// Value types are more varied and require special handling.
+	switch mapType.Elem().Kind() {
+	case reflect.Slice:
+		// []byte
+		var dummy []byte
+		valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte
+		valbase = toStructPointer(valcopy.Addr())
+	case reflect.Ptr:
+		// message; the generated field type is map[K]*Msg (so V is *Msg),
+		// so we only need one level of indirection.
+		valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
+		valbase = toStructPointer(valcopy.Addr())
+	default:
+		// everything else
+		valcopy = reflect.New(mapType.Elem()).Elem()                // addressable V
+		valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V
+		valptr.Set(valcopy.Addr())                                  //
+		valbase = toStructPointer(valptr.Addr())                    // **V
+	}
+	return
+}
+
+// Encode a struct.
+func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
+	var state errorState
+	// Encode fields in tag order so that decoders may use optimizations
+	// that depend on the ordering.
+	// https://developers.google.com/protocol-buffers/docs/encoding#order
+	for _, i := range prop.order {
+		p := prop.Prop[i]
+		if p.enc != nil {
+			err := p.enc(o, p, base)
+			if err != nil {
+				if err == ErrNil {
+					if p.Required && state.err == nil {
+						state.err = &RequiredNotSetError{p.Name}
+					}
+				} else if err == errRepeatedHasNil {
+					// Give more context to nil values in repeated fields.
+					return errors.New("repeated field " + p.OrigName + " has nil element")
+				} else if !state.shouldContinue(err, p) {
+					return err
+				}
+			}
+		}
+	}
+
+	// Add unrecognized fields at the end.
+	if prop.unrecField.IsValid() {
+		v := *structPointer_Bytes(base, prop.unrecField)
+		if len(v) > 0 {
+			o.buf = append(o.buf, v...)
+		}
+	}
+
+	return state.err
+}
+
+func size_struct(prop *StructProperties, base structPointer) (n int) {
+	for _, i := range prop.order {
+		p := prop.Prop[i]
+		if p.size != nil {
+			n += p.size(p, base)
+		}
+	}
+
+	// Add unrecognized fields at the end.
+	if prop.unrecField.IsValid() {
+		v := *structPointer_Bytes(base, prop.unrecField)
+		n += len(v)
+	}
+
+	return
+}
+
+var zeroes [20]byte // longer than any conceivable sizeVarint
+
+// Encode a struct, preceded by its encoded length (as a varint).
+func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error {
+	return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state)
+}
+
+// Encode something, preceded by its encoded length (as a varint).
+func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error {
+	iLen := len(o.buf)
+	o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length
+	iMsg := len(o.buf)
+	err := enc()
+	if err != nil && !state.shouldContinue(err, nil) {
+		return err
+	}
+	lMsg := len(o.buf) - iMsg
+	lLen := sizeVarint(uint64(lMsg))
+	switch x := lLen - (iMsg - iLen); {
+	case x > 0: // actual length is x bytes larger than the space we reserved
+		// Move msg x bytes right.
+		o.buf = append(o.buf, zeroes[:x]...)
+		copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
+	case x < 0: // actual length is x bytes smaller than the space we reserved
+		// Move msg x bytes left.
+		copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
+		o.buf = o.buf[:len(o.buf)+x] // x is negative
+	}
+	// Encode the length in the reserved space.
+	o.buf = o.buf[:iLen]
+	o.EncodeVarint(uint64(lMsg))
+	o.buf = o.buf[:len(o.buf)+lMsg]
+	return state.err
+}
+
+// errorState maintains the first error that occurs and updates that error
+// with additional context.
+type errorState struct {
+	err error
+}
+
+// shouldContinue reports whether encoding should continue upon encountering the
+// given error. If the error is RequiredNotSetError, shouldContinue returns true
+// and, if this is the first appearance of that error, remembers it for future
+// reporting.
+//
+// If prop is not nil, it may update any error with additional context about the
+// field with the error.
+func (s *errorState) shouldContinue(err error, prop *Properties) bool {
+	// Ignore unset required fields.
+	reqNotSet, ok := err.(*RequiredNotSetError)
+	if !ok {
+		return false
+	}
+	if s.err == nil {
+		if prop != nil {
+			err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field}
+		}
+		s.err = err
+	}
+	return true
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/encode_gogo.go b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
new file mode 100644
index 00000000..f77cfb1e
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
@@ -0,0 +1,354 @@
+// Extensions for Protocol Buffers to create more go like structures.
+//
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// http://github.com/golang/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"reflect"
+)
+
+func NewRequiredNotSetError(field string) *RequiredNotSetError {
+	return &RequiredNotSetError{field}
+}
+
+type Sizer interface {
+	Size() int
+}
+
+func (o *Buffer) enc_ext_slice_byte(p *Properties, base structPointer) error {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, s...)
+	return nil
+}
+
+func size_ext_slice_byte(p *Properties, base structPointer) (n int) {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return 0
+	}
+	n += len(s)
+	return
+}
+
+// Encode a reference to bool pointer.
+func (o *Buffer) enc_ref_bool(p *Properties, base structPointer) error {
+	v := *structPointer_BoolVal(base, p.field)
+	x := 0
+	if v {
+		x = 1
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_ref_bool(p *Properties, base structPointer) int {
+	return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+// Encode a reference to int32 pointer.
+func (o *Buffer) enc_ref_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v))
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_ref_int32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v))
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+func (o *Buffer) enc_ref_uint32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_ref_uint32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+// Encode a reference to an int64 pointer.
+func (o *Buffer) enc_ref_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, x)
+	return nil
+}
+
+func size_ref_int64(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(x)
+	return
+}
+
+// Encode a reference to a string pointer.
+func (o *Buffer) enc_ref_string(p *Properties, base structPointer) error {
+	v := *structPointer_StringVal(base, p.field)
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeStringBytes(v)
+	return nil
+}
+
+func size_ref_string(p *Properties, base structPointer) (n int) {
+	v := *structPointer_StringVal(base, p.field)
+	n += len(p.tagcode)
+	n += sizeStringBytes(v)
+	return
+}
+
+// Encode a reference to a message struct.
+func (o *Buffer) enc_ref_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	structp := structPointer_GetRefStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return ErrNil
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, err := m.Marshal()
+		if err != nil && !state.shouldContinue(err, nil) {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+		return nil
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	return o.enc_len_struct(p.sprop, structp, &state)
+}
+
+//TODO this is only copied, please fix this
+func size_ref_struct_message(p *Properties, base structPointer) int {
+	structp := structPointer_GetRefStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return 0
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, _ := m.Marshal()
+		n0 := len(p.tagcode)
+		n1 := sizeRawBytes(data)
+		return n0 + n1
+	}
+
+	n0 := len(p.tagcode)
+	n1 := size_struct(p.sprop, structp)
+	n2 := sizeVarint(uint64(n1)) // size of encoded length
+	return n0 + n1 + n2
+}
+
+// Encode a slice of references to message struct pointers ([]struct).
+func (o *Buffer) enc_slice_ref_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	ss := structPointer_GetStructPointer(base, p.field)
+	ss1 := structPointer_GetRefStructPointer(ss, field(0))
+	size := p.stype.Size()
+	l := structPointer_Len(base, p.field)
+	for i := 0; i < l; i++ {
+		structp := structPointer_Add(ss1, field(uintptr(i)*size))
+		if structPointer_IsNil(structp) {
+			return errRepeatedHasNil
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, err := m.Marshal()
+			if err != nil && !state.shouldContinue(err, nil) {
+				return err
+			}
+			o.buf = append(o.buf, p.tagcode...)
+			o.EncodeRawBytes(data)
+			continue
+		}
+
+		o.buf = append(o.buf, p.tagcode...)
+		err := o.enc_len_struct(p.sprop, structp, &state)
+		if err != nil && !state.shouldContinue(err, nil) {
+			if err == ErrNil {
+				return errRepeatedHasNil
+			}
+			return err
+		}
+
+	}
+	return state.err
+}
+
+//TODO this is only copied, please fix this
+func size_slice_ref_struct_message(p *Properties, base structPointer) (n int) {
+	ss := structPointer_GetStructPointer(base, p.field)
+	ss1 := structPointer_GetRefStructPointer(ss, field(0))
+	size := p.stype.Size()
+	l := structPointer_Len(base, p.field)
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		structp := structPointer_Add(ss1, field(uintptr(i)*size))
+		if structPointer_IsNil(structp) {
+			return // return the size up to this point
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, _ := m.Marshal()
+			n += len(p.tagcode)
+			n += sizeRawBytes(data)
+			continue
+		}
+
+		n0 := size_struct(p.sprop, structp)
+		n1 := sizeVarint(uint64(n0)) // size of encoded length
+		n += n0 + n1
+	}
+	return
+}
+
+func (o *Buffer) enc_custom_bytes(p *Properties, base structPointer) error {
+	i := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if i == nil {
+		return ErrNil
+	}
+	custom := i.(Marshaler)
+	data, err := custom.Marshal()
+	if err != nil {
+		return err
+	}
+	if data == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_custom_bytes(p *Properties, base structPointer) (n int) {
+	n += len(p.tagcode)
+	i := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if i == nil {
+		return 0
+	}
+	custom := i.(Marshaler)
+	data, _ := custom.Marshal()
+	n += sizeRawBytes(data)
+	return
+}
+
+func (o *Buffer) enc_custom_ref_bytes(p *Properties, base structPointer) error {
+	custom := structPointer_InterfaceAt(base, p.field, p.ctype).(Marshaler)
+	data, err := custom.Marshal()
+	if err != nil {
+		return err
+	}
+	if data == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_custom_ref_bytes(p *Properties, base structPointer) (n int) {
+	n += len(p.tagcode)
+	i := structPointer_InterfaceAt(base, p.field, p.ctype)
+	if i == nil {
+		return 0
+	}
+	custom := i.(Marshaler)
+	data, _ := custom.Marshal()
+	n += sizeRawBytes(data)
+	return
+}
+
+func (o *Buffer) enc_custom_slice_bytes(p *Properties, base structPointer) error {
+	inter := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if inter == nil {
+		return ErrNil
+	}
+	slice := reflect.ValueOf(inter)
+	l := slice.Len()
+	for i := 0; i < l; i++ {
+		v := slice.Index(i)
+		custom := v.Interface().(Marshaler)
+		data, err := custom.Marshal()
+		if err != nil {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+	}
+	return nil
+}
+
+func size_custom_slice_bytes(p *Properties, base structPointer) (n int) {
+	inter := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if inter == nil {
+		return 0
+	}
+	slice := reflect.ValueOf(inter)
+	l := slice.Len()
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		v := slice.Index(i)
+		custom := v.Interface().(Marshaler)
+		data, _ := custom.Marshal()
+		n += sizeRawBytes(data)
+	}
+	return
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/equal.go b/vendor/github.com/gogo/protobuf/proto/equal.go
new file mode 100644
index 00000000..d8673a3e
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/equal.go
@@ -0,0 +1,256 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer comparison.
+// TODO: MessageSet.
+
+package proto
+
+import (
+	"bytes"
+	"log"
+	"reflect"
+	"strings"
+)
+
+/*
+Equal returns true iff protocol buffers a and b are equal.
+The arguments must both be pointers to protocol buffer structs.
+
+Equality is defined in this way:
+  - Two messages are equal iff they are the same type,
+    corresponding fields are equal, unknown field sets
+    are equal, and extensions sets are equal.
+  - Two set scalar fields are equal iff their values are equal.
+    If the fields are of a floating-point type, remember that
+    NaN != x for all x, including NaN.
+  - Two repeated fields are equal iff their lengths are the same,
+    and their corresponding elements are equal (a "bytes" field,
+    although represented by []byte, is not a repeated field)
+  - Two unset fields are equal.
+  - Two unknown field sets are equal if their current
+    encoded state is equal.
+  - Two extension sets are equal iff they have corresponding
+    elements that are pairwise equal.
+  - Every other combination of things are not equal.
+
+The return value is undefined if a and b are not protocol buffers.
+*/
+func Equal(a, b Message) bool {
+	if a == nil || b == nil {
+		return a == b
+	}
+	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
+	if v1.Type() != v2.Type() {
+		return false
+	}
+	if v1.Kind() == reflect.Ptr {
+		if v1.IsNil() {
+			return v2.IsNil()
+		}
+		if v2.IsNil() {
+			return false
+		}
+		v1, v2 = v1.Elem(), v2.Elem()
+	}
+	if v1.Kind() != reflect.Struct {
+		return false
+	}
+	return equalStruct(v1, v2)
+}
+
+// v1 and v2 are known to have the same type.
+func equalStruct(v1, v2 reflect.Value) bool {
+	for i := 0; i < v1.NumField(); i++ {
+		f := v1.Type().Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		f1, f2 := v1.Field(i), v2.Field(i)
+		if f.Type.Kind() == reflect.Ptr {
+			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
+				// both unset
+				continue
+			} else if n1 != n2 {
+				// set/unset mismatch
+				return false
+			}
+			b1, ok := f1.Interface().(raw)
+			if ok {
+				b2 := f2.Interface().(raw)
+				// RawMessage
+				if !bytes.Equal(b1.Bytes(), b2.Bytes()) {
+					return false
+				}
+				continue
+			}
+			f1, f2 = f1.Elem(), f2.Elem()
+		}
+		if !equalAny(f1, f2) {
+			return false
+		}
+	}
+
+	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
+		em2 := v2.FieldByName("XXX_extensions")
+		if !equalExtensions(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+			return false
+		}
+	}
+
+	uf := v1.FieldByName("XXX_unrecognized")
+	if !uf.IsValid() {
+		return true
+	}
+
+	u1 := uf.Bytes()
+	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
+	if !bytes.Equal(u1, u2) {
+		return false
+	}
+
+	return true
+}
+
+// v1 and v2 are known to have the same type.
+func equalAny(v1, v2 reflect.Value) bool {
+	if v1.Type() == protoMessageType {
+		m1, _ := v1.Interface().(Message)
+		m2, _ := v2.Interface().(Message)
+		return Equal(m1, m2)
+	}
+	switch v1.Kind() {
+	case reflect.Bool:
+		return v1.Bool() == v2.Bool()
+	case reflect.Float32, reflect.Float64:
+		return v1.Float() == v2.Float()
+	case reflect.Int32, reflect.Int64:
+		return v1.Int() == v2.Int()
+	case reflect.Map:
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		for _, key := range v1.MapKeys() {
+			val2 := v2.MapIndex(key)
+			if !val2.IsValid() {
+				// This key was not found in the second map.
+				return false
+			}
+			if !equalAny(v1.MapIndex(key), val2) {
+				return false
+			}
+		}
+		return true
+	case reflect.Ptr:
+		return equalAny(v1.Elem(), v2.Elem())
+	case reflect.Slice:
+		if v1.Type().Elem().Kind() == reflect.Uint8 {
+			// short circuit: []byte
+			if v1.IsNil() != v2.IsNil() {
+				return false
+			}
+			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
+		}
+
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		for i := 0; i < v1.Len(); i++ {
+			if !equalAny(v1.Index(i), v2.Index(i)) {
+				return false
+			}
+		}
+		return true
+	case reflect.String:
+		return v1.Interface().(string) == v2.Interface().(string)
+	case reflect.Struct:
+		return equalStruct(v1, v2)
+	case reflect.Uint32, reflect.Uint64:
+		return v1.Uint() == v2.Uint()
+	}
+
+	// unknown type, so not a protocol buffer
+	log.Printf("proto: don't know how to compare %v", v1)
+	return false
+}
+
+// base is the struct type that the extensions are based on.
+// em1 and em2 are extension maps.
+func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool {
+	if len(em1) != len(em2) {
+		return false
+	}
+
+	for extNum, e1 := range em1 {
+		e2, ok := em2[extNum]
+		if !ok {
+			return false
+		}
+
+		m1, m2 := e1.value, e2.value
+
+		if m1 != nil && m2 != nil {
+			// Both are unencoded.
+			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) {
+				return false
+			}
+			continue
+		}
+
+		// At least one is encoded. To do a semantically correct comparison
+		// we need to unmarshal them first.
+		var desc *ExtensionDesc
+		if m := extensionMaps[base]; m != nil {
+			desc = m[extNum]
+		}
+		if desc == nil {
+			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
+			continue
+		}
+		var err error
+		if m1 == nil {
+			m1, err = decodeExtension(e1.enc, desc)
+		}
+		if m2 == nil && err == nil {
+			m2, err = decodeExtension(e2.enc, desc)
+		}
+		if err != nil {
+			// The encoded form is invalid.
+			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
+			return false
+		}
+		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/extensions.go b/vendor/github.com/gogo/protobuf/proto/extensions.go
new file mode 100644
index 00000000..50e04e59
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions.go
@@ -0,0 +1,481 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Types and routines for supporting protocol buffer extensions.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"sync"
+)
+
+// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
+var ErrMissingExtension = errors.New("proto: missing extension")
+
+// ExtensionRange represents a range of message extensions for a protocol buffer.
+// Used in code generated by the protocol compiler.
+type ExtensionRange struct {
+	Start, End int32 // both inclusive
+}
+
+// extendableProto is an interface implemented by any protocol buffer that may be extended.
+type extendableProto interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+}
+
+type extensionsMap interface {
+	extendableProto
+	ExtensionMap() map[int32]Extension
+}
+
+type extensionsBytes interface {
+	extendableProto
+	GetExtensions() *[]byte
+}
+
+var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
+
+// ExtensionDesc represents an extension specification.
+// Used in generated code from the protocol compiler.
+type ExtensionDesc struct {
+	ExtendedType  Message     // nil pointer to the type that is being extended
+	ExtensionType interface{} // nil pointer to the extension type
+	Field         int32       // field number
+	Name          string      // fully-qualified name of extension, for text formatting
+	Tag           string      // protobuf tag style
+}
+
+func (ed *ExtensionDesc) repeated() bool {
+	t := reflect.TypeOf(ed.ExtensionType)
+	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+}
+
+// Extension represents an extension in a message.
+type Extension struct {
+	// When an extension is stored in a message using SetExtension
+	// only desc and value are set. When the message is marshaled
+	// enc will be set to the encoded form of the message.
+	//
+	// When a message is unmarshaled and contains extensions, each
+	// extension will have only enc set. When such an extension is
+	// accessed using GetExtension (or GetExtensions) desc and value
+	// will be set.
+	desc  *ExtensionDesc
+	value interface{}
+	enc   []byte
+}
+
+// SetRawExtension is for testing only.
+func SetRawExtension(base extendableProto, id int32, b []byte) {
+	if ebase, ok := base.(extensionsMap); ok {
+		ebase.ExtensionMap()[id] = Extension{enc: b}
+	} else if ebase, ok := base.(extensionsBytes); ok {
+		clearExtension(base, id)
+		ext := ebase.GetExtensions()
+		*ext = append(*ext, b...)
+	} else {
+		panic("unreachable")
+	}
+}
+
+// isExtensionField returns true iff the given field number is in an extension range.
+func isExtensionField(pb extendableProto, field int32) bool {
+	for _, er := range pb.ExtensionRangeArray() {
+		if er.Start <= field && field <= er.End {
+			return true
+		}
+	}
+	return false
+}
+
+// checkExtensionTypes checks that the given extension is valid for pb.
+func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+	// Check the extended type.
+	if a, b := reflect.TypeOf(pb), reflect.TypeOf(extension.ExtendedType); a != b {
+		return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
+	}
+	// Check the range.
+	if !isExtensionField(pb, extension.Field) {
+		return errors.New("proto: bad extension number; not in declared ranges")
+	}
+	return nil
+}
+
+// extPropKey is sufficient to uniquely identify an extension.
+type extPropKey struct {
+	base  reflect.Type
+	field int32
+}
+
+var extProp = struct {
+	sync.RWMutex
+	m map[extPropKey]*Properties
+}{
+	m: make(map[extPropKey]*Properties),
+}
+
+func extensionProperties(ed *ExtensionDesc) *Properties {
+	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
+
+	extProp.RLock()
+	if prop, ok := extProp.m[key]; ok {
+		extProp.RUnlock()
+		return prop
+	}
+	extProp.RUnlock()
+
+	extProp.Lock()
+	defer extProp.Unlock()
+	// Check again.
+	if prop, ok := extProp.m[key]; ok {
+		return prop
+	}
+
+	prop := new(Properties)
+	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
+	extProp.m[key] = prop
+	return prop
+}
+
+// encodeExtensionMap encodes any unmarshaled (unencoded) extensions in m.
+func encodeExtensionMap(m map[int32]Extension) error {
+	for k, e := range m {
+		err := encodeExtension(&e)
+		if err != nil {
+			return err
+		}
+		m[k] = e
+	}
+	return nil
+}
+
+func encodeExtension(e *Extension) error {
+	if e.value == nil || e.desc == nil {
+		// Extension is only in its encoded form.
+		return nil
+	}
+	// We don't skip extensions that have an encoded form set,
+	// because the extension value may have been mutated after
+	// the last time this function was called.
+
+	et := reflect.TypeOf(e.desc.ExtensionType)
+	props := extensionProperties(e.desc)
+
+	p := NewBuffer(nil)
+	// If e.value has type T, the encoder expects a *struct{ X T }.
+	// Pass a *T with a zero field and hope it all works out.
+	x := reflect.New(et)
+	x.Elem().Set(reflect.ValueOf(e.value))
+	if err := props.enc(p, props, toStructPointer(x)); err != nil {
+		return err
+	}
+	e.enc = p.buf
+	return nil
+}
+
+func sizeExtensionMap(m map[int32]Extension) (n int) {
+	for _, e := range m {
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			n += len(e.enc)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		et := reflect.TypeOf(e.desc.ExtensionType)
+		props := extensionProperties(e.desc)
+
+		// If e.value has type T, the encoder expects a *struct{ X T }.
+		// Pass a *T with a zero field and hope it all works out.
+		x := reflect.New(et)
+		x.Elem().Set(reflect.ValueOf(e.value))
+		n += props.size(props, toStructPointer(x))
+	}
+	return
+}
+
+// HasExtension returns whether the given extension is present in pb.
+func HasExtension(pb extendableProto, extension *ExtensionDesc) bool {
+	// TODO: Check types, field numbers, etc.?
+	if epb, doki := pb.(extensionsMap); doki {
+		_, ok := epb.ExtensionMap()[extension.Field]
+		return ok
+	} else if epb, doki := pb.(extensionsBytes); doki {
+		ext := epb.GetExtensions()
+		buf := *ext
+		o := 0
+		for o < len(buf) {
+			tag, n := DecodeVarint(buf[o:])
+			fieldNum := int32(tag >> 3)
+			if int32(fieldNum) == extension.Field {
+				return true
+			}
+			wireType := int(tag & 0x7)
+			o += n
+			l, err := size(buf[o:], wireType)
+			if err != nil {
+				return false
+			}
+			o += l
+		}
+		return false
+	}
+	panic("unreachable")
+}
+
+func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
+	ext := pb.GetExtensions()
+	for offset < len(*ext) {
+		tag, n1 := DecodeVarint((*ext)[offset:])
+		fieldNum := int32(tag >> 3)
+		wireType := int(tag & 0x7)
+		n2, err := size((*ext)[offset+n1:], wireType)
+		if err != nil {
+			panic(err)
+		}
+		newOffset := offset + n1 + n2
+		if fieldNum == theFieldNum {
+			*ext = append((*ext)[:offset], (*ext)[newOffset:]...)
+			return offset
+		}
+		offset = newOffset
+	}
+	return -1
+}
+
+func clearExtension(pb extendableProto, fieldNum int32) {
+	if epb, doki := pb.(extensionsMap); doki {
+		delete(epb.ExtensionMap(), fieldNum)
+	} else if epb, doki := pb.(extensionsBytes); doki {
+		offset := 0
+		for offset != -1 {
+			offset = deleteExtension(epb, fieldNum, offset)
+		}
+	} else {
+		panic("unreachable")
+	}
+}
+
+// ClearExtension removes the given extension from pb.
+func ClearExtension(pb extendableProto, extension *ExtensionDesc) {
+	// TODO: Check types, field numbers, etc.?
+	clearExtension(pb, extension.Field)
+}
+
+// GetExtension parses and returns the given extension of pb.
+// If the extension is not present it returns ErrMissingExtension.
+func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, error) {
+	if err := checkExtensionTypes(pb, extension); err != nil {
+		return nil, err
+	}
+
+	if epb, doki := pb.(extensionsMap); doki {
+		emap := epb.ExtensionMap()
+		e, ok := emap[extension.Field]
+		if !ok {
+			return nil, ErrMissingExtension
+		}
+		if e.value != nil {
+			// Already decoded. Check the descriptor, though.
+			if e.desc != extension {
+				// This shouldn't happen. If it does, it means that
+				// GetExtension was called twice with two different
+				// descriptors with the same field number.
+				return nil, errors.New("proto: descriptor conflict")
+			}
+			return e.value, nil
+		}
+
+		v, err := decodeExtension(e.enc, extension)
+		if err != nil {
+			return nil, err
+		}
+
+		// Remember the decoded version and drop the encoded version.
+		// That way it is safe to mutate what we return.
+		e.value = v
+		e.desc = extension
+		e.enc = nil
+		emap[extension.Field] = e
+		return e.value, nil
+	} else if epb, doki := pb.(extensionsBytes); doki {
+		ext := epb.GetExtensions()
+		o := 0
+		for o < len(*ext) {
+			tag, n := DecodeVarint((*ext)[o:])
+			fieldNum := int32(tag >> 3)
+			wireType := int(tag & 0x7)
+			l, err := size((*ext)[o+n:], wireType)
+			if err != nil {
+				return nil, err
+			}
+			if int32(fieldNum) == extension.Field {
+				v, err := decodeExtension((*ext)[o:o+n+l], extension)
+				if err != nil {
+					return nil, err
+				}
+				return v, nil
+			}
+			o += n + l
+		}
+	}
+	panic("unreachable")
+}
+
+// decodeExtension decodes an extension encoded in b.
+func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
+	o := NewBuffer(b)
+
+	t := reflect.TypeOf(extension.ExtensionType)
+	rep := extension.repeated()
+
+	props := extensionProperties(extension)
+
+	// t is a pointer to a struct, pointer to basic type or a slice.
+	// Allocate a "field" to store the pointer/slice itself; the
+	// pointer/slice will be stored here. We pass
+	// the address of this field to props.dec.
+	// This passes a zero field and a *t and lets props.dec
+	// interpret it as a *struct{ x t }.
+	value := reflect.New(t).Elem()
+
+	for {
+		// Discard wire type and field number varint. It isn't needed.
+		if _, err := o.DecodeVarint(); err != nil {
+			return nil, err
+		}
+
+		if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil {
+			return nil, err
+		}
+
+		if !rep || o.index >= len(o.buf) {
+			break
+		}
+	}
+	return value.Interface(), nil
+}
+
+// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
+// The returned slice has the same length as es; missing extensions will appear as nil elements.
+func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
+	epb, ok := pb.(extendableProto)
+	if !ok {
+		err = errors.New("proto: not an extendable proto")
+		return
+	}
+	extensions = make([]interface{}, len(es))
+	for i, e := range es {
+		extensions[i], err = GetExtension(epb, e)
+		if err == ErrMissingExtension {
+			err = nil
+		}
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+// SetExtension sets the specified extension of pb to the specified value.
+func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error {
+	if err := checkExtensionTypes(pb, extension); err != nil {
+		return err
+	}
+	typ := reflect.TypeOf(extension.ExtensionType)
+	if typ != reflect.TypeOf(value) {
+		return errors.New("proto: bad extension value type")
+	}
+	// nil extension values need to be caught early, because the
+	// encoder can't distinguish an ErrNil due to a nil extension
+	// from an ErrNil due to a missing field. Extensions are
+	// always optional, so the encoder would just swallow the error
+	// and drop all the extensions from the encoded message.
+	if reflect.ValueOf(value).IsNil() {
+		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+	}
+	return setExtension(pb, extension, value)
+}
+
+func setExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error {
+	if epb, doki := pb.(extensionsMap); doki {
+		epb.ExtensionMap()[extension.Field] = Extension{desc: extension, value: value}
+	} else if epb, doki := pb.(extensionsBytes); doki {
+		ClearExtension(pb, extension)
+		ext := epb.GetExtensions()
+		et := reflect.TypeOf(extension.ExtensionType)
+		props := extensionProperties(extension)
+		p := NewBuffer(nil)
+		x := reflect.New(et)
+		x.Elem().Set(reflect.ValueOf(value))
+		if err := props.enc(p, props, toStructPointer(x)); err != nil {
+			return err
+		}
+		*ext = append(*ext, p.buf...)
+	}
+	return nil
+}
+
+// A global registry of extensions.
+// The generated code will register the generated descriptors by calling RegisterExtension.
+
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
+// RegisterExtension is called from the generated code.
+func RegisterExtension(desc *ExtensionDesc) {
+	st := reflect.TypeOf(desc.ExtendedType).Elem()
+	m := extensionMaps[st]
+	if m == nil {
+		m = make(map[int32]*ExtensionDesc)
+		extensionMaps[st] = m
+	}
+	if _, ok := m[desc.Field]; ok {
+		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+	}
+	m[desc.Field] = desc
+}
+
+// RegisteredExtensions returns a map of the registered extensions of a
+// protocol buffer struct, indexed by the extension number.
+// The argument pb should be a nil pointer to the struct type.
+func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
+	return extensionMaps[reflect.TypeOf(pb).Elem()]
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
new file mode 100644
index 00000000..bd55fb68
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
@@ -0,0 +1,221 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+func GetBoolExtension(pb extendableProto, extension *ExtensionDesc, ifnotset bool) bool {
+	if reflect.ValueOf(pb).IsNil() {
+		return ifnotset
+	}
+	value, err := GetExtension(pb, extension)
+	if err != nil {
+		return ifnotset
+	}
+	if value == nil {
+		return ifnotset
+	}
+	if value.(*bool) == nil {
+		return ifnotset
+	}
+	return *(value.(*bool))
+}
+
+func (this *Extension) Equal(that *Extension) bool {
+	return bytes.Equal(this.enc, that.enc)
+}
+
+func SizeOfExtensionMap(m map[int32]Extension) (n int) {
+	return sizeExtensionMap(m)
+}
+
+type sortableMapElem struct {
+	field int32
+	ext   Extension
+}
+
+func newSortableExtensionsFromMap(m map[int32]Extension) sortableExtensions {
+	s := make(sortableExtensions, 0, len(m))
+	for k, v := range m {
+		s = append(s, &sortableMapElem{field: k, ext: v})
+	}
+	return s
+}
+
+type sortableExtensions []*sortableMapElem
+
+func (this sortableExtensions) Len() int { return len(this) }
+
+func (this sortableExtensions) Swap(i, j int) { this[i], this[j] = this[j], this[i] }
+
+func (this sortableExtensions) Less(i, j int) bool { return this[i].field < this[j].field }
+
+func (this sortableExtensions) String() string {
+	sort.Sort(this)
+	ss := make([]string, len(this))
+	for i := range this {
+		ss[i] = fmt.Sprintf("%d: %v", this[i].field, this[i].ext)
+	}
+	return "map[" + strings.Join(ss, ",") + "]"
+}
+
+func StringFromExtensionsMap(m map[int32]Extension) string {
+	return newSortableExtensionsFromMap(m).String()
+}
+
+func StringFromExtensionsBytes(ext []byte) string {
+	m, err := BytesToExtensionsMap(ext)
+	if err != nil {
+		panic(err)
+	}
+	return StringFromExtensionsMap(m)
+}
+
+func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error) {
+	if err := encodeExtensionMap(m); err != nil {
+		return 0, err
+	}
+	keys := make([]int, 0, len(m))
+	for k := range m {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+	for _, k := range keys {
+		n += copy(data[n:], m[int32(k)].enc)
+	}
+	return n, nil
+}
+
+func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error) {
+	if m[id].value == nil || m[id].desc == nil {
+		return m[id].enc, nil
+	}
+	if err := encodeExtensionMap(m); err != nil {
+		return nil, err
+	}
+	return m[id].enc, nil
+}
+
+func size(buf []byte, wire int) (int, error) {
+	switch wire {
+	case WireVarint:
+		_, n := DecodeVarint(buf)
+		return n, nil
+	case WireFixed64:
+		return 8, nil
+	case WireBytes:
+		v, n := DecodeVarint(buf)
+		return int(v) + n, nil
+	case WireFixed32:
+		return 4, nil
+	case WireStartGroup:
+		offset := 0
+		for {
+			u, n := DecodeVarint(buf[offset:])
+			fwire := int(u & 0x7)
+			offset += n
+			if fwire == WireEndGroup {
+				return offset, nil
+			}
+			s, err := size(buf[offset:], wire)
+			if err != nil {
+				return 0, err
+			}
+			offset += s
+		}
+	}
+	return 0, fmt.Errorf("proto: can't get size for unknown wire type %d", wire)
+}
+
+func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error) {
+	m := make(map[int32]Extension)
+	i := 0
+	for i < len(buf) {
+		tag, n := DecodeVarint(buf[i:])
+		if n <= 0 {
+			return nil, fmt.Errorf("unable to decode varint")
+		}
+		fieldNum := int32(tag >> 3)
+		wireType := int(tag & 0x7)
+		l, err := size(buf[i+n:], wireType)
+		if err != nil {
+			return nil, err
+		}
+		end := i + int(l) + n
+		m[int32(fieldNum)] = Extension{enc: buf[i:end]}
+		i = end
+	}
+	return m, nil
+}
+
+func NewExtension(e []byte) Extension {
+	ee := Extension{enc: make([]byte, len(e))}
+	copy(ee.enc, e)
+	return ee
+}
+
+func (this Extension) GoString() string {
+	if this.enc == nil {
+		if err := encodeExtension(&this); err != nil {
+			panic(err)
+		}
+	}
+	return fmt.Sprintf("proto.NewExtension(%#v)", this.enc)
+}
+
+func SetUnsafeExtension(pb extendableProto, fieldNum int32, value interface{}) error {
+	typ := reflect.TypeOf(pb).Elem()
+	ext, ok := extensionMaps[typ]
+	if !ok {
+		return fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+	}
+	desc, ok := ext[fieldNum]
+	if !ok {
+		return errors.New("proto: bad extension number; not in declared ranges")
+	}
+	return setExtension(pb, desc, value)
+}
+
+func GetUnsafeExtension(pb extendableProto, fieldNum int32) (interface{}, error) {
+	typ := reflect.TypeOf(pb).Elem()
+	ext, ok := extensionMaps[typ]
+	if !ok {
+		return nil, fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+	}
+	desc, ok := ext[fieldNum]
+	if !ok {
+		return nil, fmt.Errorf("unregistered field number %d", fieldNum)
+	}
+	return GetExtension(pb, desc)
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/lib.go b/vendor/github.com/gogo/protobuf/proto/lib.go
new file mode 100644
index 00000000..9e254e5a
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib.go
@@ -0,0 +1,790 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+	Package proto converts data structures to and from the wire format of
+	protocol buffers.  It works in concert with the Go source code generated
+	for .proto files by the protocol compiler.
+
+	A summary of the properties of the protocol buffer interface
+	for a protocol buffer variable v:
+
+	  - Names are turned from camel_case to CamelCase for export.
+	  - There are no methods on v to set fields; just treat
+		them as structure fields.
+	  - There are getters that return a field's value if set,
+		and return the field's default value if unset.
+		The getters work even if the receiver is a nil message.
+	  - The zero value for a struct is its correct initialization state.
+		All desired fields must be set before marshaling.
+	  - A Reset() method will restore a protobuf struct to its zero state.
+	  - Non-repeated fields are pointers to the values; nil means unset.
+		That is, optional or required field int32 f becomes F *int32.
+	  - Repeated fields are slices.
+	  - Helper functions are available to aid the setting of fields.
+		msg.Foo = proto.String("hello") // set field
+	  - Constants are defined to hold the default values of all fields that
+		have them.  They have the form Default_StructName_FieldName.
+		Because the getter methods handle defaulted values,
+		direct use of these constants should be rare.
+	  - Enums are given type names and maps from names to values.
+		Enum values are prefixed by the enclosing message's name, or by the
+		enum's type name if it is a top-level enum. Enum types have a String
+		method, and a Enum method to assist in message construction.
+	  - Nested messages, groups and enums have type names prefixed with the name of
+	  	the surrounding message type.
+	  - Extensions are given descriptor names that start with E_,
+		followed by an underscore-delimited list of the nested messages
+		that contain it (if any) followed by the CamelCased name of the
+		extension field itself.  HasExtension, ClearExtension, GetExtension
+		and SetExtension are functions for manipulating extensions.
+	  - Marshal and Unmarshal are functions to encode and decode the wire format.
+
+	The simplest way to describe this is to see an example.
+	Given file test.proto, containing
+
+		package example;
+
+		enum FOO { X = 17; }
+
+		message Test {
+		  required string label = 1;
+		  optional int32 type = 2 [default=77];
+		  repeated int64 reps = 3;
+		  optional group OptionalGroup = 4 {
+		    required string RequiredField = 5;
+		  }
+		}
+
+	The resulting file, test.pb.go, is:
+
+		package example
+
+		import proto "github.com/gogo/protobuf/proto"
+		import math "math"
+
+		type FOO int32
+		const (
+			FOO_X FOO = 17
+		)
+		var FOO_name = map[int32]string{
+			17: "X",
+		}
+		var FOO_value = map[string]int32{
+			"X": 17,
+		}
+
+		func (x FOO) Enum() *FOO {
+			p := new(FOO)
+			*p = x
+			return p
+		}
+		func (x FOO) String() string {
+			return proto.EnumName(FOO_name, int32(x))
+		}
+		func (x *FOO) UnmarshalJSON(data []byte) error {
+			value, err := proto.UnmarshalJSONEnum(FOO_value, data)
+			if err != nil {
+				return err
+			}
+			*x = FOO(value)
+			return nil
+		}
+
+		type Test struct {
+			Label            *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+			Type             *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
+			Reps             []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
+			Optionalgroup    *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
+			XXX_unrecognized []byte              `json:"-"`
+		}
+		func (m *Test) Reset()         { *m = Test{} }
+		func (m *Test) String() string { return proto.CompactTextString(m) }
+		func (*Test) ProtoMessage()    {}
+		const Default_Test_Type int32 = 77
+
+		func (m *Test) GetLabel() string {
+			if m != nil && m.Label != nil {
+				return *m.Label
+			}
+			return ""
+		}
+
+		func (m *Test) GetType() int32 {
+			if m != nil && m.Type != nil {
+				return *m.Type
+			}
+			return Default_Test_Type
+		}
+
+		func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
+			if m != nil {
+				return m.Optionalgroup
+			}
+			return nil
+		}
+
+		type Test_OptionalGroup struct {
+			RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
+		}
+		func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
+		func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
+
+		func (m *Test_OptionalGroup) GetRequiredField() string {
+			if m != nil && m.RequiredField != nil {
+				return *m.RequiredField
+			}
+			return ""
+		}
+
+		func init() {
+			proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+		}
+
+	To create and play with a Test object:
+
+		package main
+
+		import (
+			"log"
+
+			"github.com/gogo/protobuf/proto"
+			pb "./example.pb"
+		)
+
+		func main() {
+			test := &pb.Test{
+				Label: proto.String("hello"),
+				Type:  proto.Int32(17),
+				Optionalgroup: &pb.Test_OptionalGroup{
+					RequiredField: proto.String("good bye"),
+				},
+			}
+			data, err := proto.Marshal(test)
+			if err != nil {
+				log.Fatal("marshaling error: ", err)
+			}
+			newTest := &pb.Test{}
+			err = proto.Unmarshal(data, newTest)
+			if err != nil {
+				log.Fatal("unmarshaling error: ", err)
+			}
+			// Now test and newTest contain the same data.
+			if test.GetLabel() != newTest.GetLabel() {
+				log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
+			}
+			// etc.
+		}
+*/
+package proto
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"reflect"
+	"strconv"
+	"sync"
+)
+
+// Message is implemented by generated protocol buffer messages.
+type Message interface {
+	Reset()
+	String() string
+	ProtoMessage()
+}
+
+// Stats records allocation details about the protocol buffer encoders
+// and decoders.  Useful for tuning the library itself.
+type Stats struct {
+	Emalloc uint64 // mallocs in encode
+	Dmalloc uint64 // mallocs in decode
+	Encode  uint64 // number of encodes
+	Decode  uint64 // number of decodes
+	Chit    uint64 // number of cache hits
+	Cmiss   uint64 // number of cache misses
+	Size    uint64 // number of sizes
+}
+
+// Set to true to enable stats collection.
+const collectStats = false
+
+var stats Stats
+
+// GetStats returns a copy of the global Stats structure.
+func GetStats() Stats { return stats }
+
+// A Buffer is a buffer manager for marshaling and unmarshaling
+// protocol buffers.  It may be reused between invocations to
+// reduce memory usage.  It is not necessary to use a Buffer;
+// the global functions Marshal and Unmarshal create a
+// temporary Buffer and are fine for most applications.
+type Buffer struct {
+	buf   []byte // encode/decode byte stream
+	index int    // write point
+
+	// pools of basic types to amortize allocation.
+	bools   []bool
+	uint32s []uint32
+	uint64s []uint64
+
+	// extra pools, only used with pointer_reflect.go
+	int32s   []int32
+	int64s   []int64
+	float32s []float32
+	float64s []float64
+}
+
+// NewBuffer allocates a new Buffer and initializes its internal data to
+// the contents of the argument slice.
+func NewBuffer(e []byte) *Buffer {
+	return &Buffer{buf: e}
+}
+
+// Reset resets the Buffer, ready for marshaling a new protocol buffer.
+func (p *Buffer) Reset() {
+	p.buf = p.buf[0:0] // for reading/writing
+	p.index = 0        // for reading
+}
+
+// SetBuf replaces the internal buffer with the slice,
+// ready for unmarshaling the contents of the slice.
+func (p *Buffer) SetBuf(s []byte) {
+	p.buf = s
+	p.index = 0
+}
+
+// Bytes returns the contents of the Buffer.
+func (p *Buffer) Bytes() []byte { return p.buf }
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool {
+	return &v
+}
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 {
+	return &v
+}
+
+// Int is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it, but unlike Int32
+// its argument value is an int.
+func Int(v int) *int32 {
+	p := new(int32)
+	*p = int32(v)
+	return p
+}
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 {
+	return &v
+}
+
+// Float32 is a helper routine that allocates a new float32 value
+// to store v and returns a pointer to it.
+func Float32(v float32) *float32 {
+	return &v
+}
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 {
+	return &v
+}
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 {
+	return &v
+}
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 {
+	return &v
+}
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string {
+	return &v
+}
+
+// EnumName is a helper function to simplify printing protocol buffer enums
+// by name.  Given an enum map and a value, it returns a useful string.
+func EnumName(m map[int32]string, v int32) string {
+	s, ok := m[v]
+	if ok {
+		return s
+	}
+	return strconv.Itoa(int(v))
+}
+
+// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
+// from their JSON-encoded representation. Given a map from the enum's symbolic
+// names to its int values, and a byte buffer containing the JSON-encoded
+// value, it returns an int32 that can be cast to the enum type by the caller.
+//
+// The function can deal with both JSON representations, numeric and symbolic.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+	if data[0] == '"' {
+		// New style: enums are strings.
+		var repr string
+		if err := json.Unmarshal(data, &repr); err != nil {
+			return -1, err
+		}
+		val, ok := m[repr]
+		if !ok {
+			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+		}
+		return val, nil
+	}
+	// Old style: enums are ints.
+	var val int32
+	if err := json.Unmarshal(data, &val); err != nil {
+		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+	}
+	return val, nil
+}
+
+// DebugPrint dumps the encoded data in b in a debugging format with a header
+// including the string s. Used in testing but made available for general debugging.
+func (o *Buffer) DebugPrint(s string, b []byte) {
+	var u uint64
+
+	obuf := o.buf
+	index := o.index
+	o.buf = b
+	o.index = 0
+	depth := 0
+
+	fmt.Printf("\n--- %s ---\n", s)
+
+out:
+	for {
+		for i := 0; i < depth; i++ {
+			fmt.Print("  ")
+		}
+
+		index := o.index
+		if index == len(o.buf) {
+			break
+		}
+
+		op, err := o.DecodeVarint()
+		if err != nil {
+			fmt.Printf("%3d: fetching op err %v\n", index, err)
+			break out
+		}
+		tag := op >> 3
+		wire := op & 7
+
+		switch wire {
+		default:
+			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
+				index, tag, wire)
+			break out
+
+		case WireBytes:
+			var r []byte
+
+			r, err = o.DecodeRawBytes(false)
+			if err != nil {
+				break out
+			}
+			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
+			if len(r) <= 6 {
+				for i := 0; i < len(r); i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+			} else {
+				for i := 0; i < 3; i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+				fmt.Printf(" ..")
+				for i := len(r) - 3; i < len(r); i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+			}
+			fmt.Printf("\n")
+
+		case WireFixed32:
+			u, err = o.DecodeFixed32()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
+
+		case WireFixed64:
+			u, err = o.DecodeFixed64()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
+			break
+
+		case WireVarint:
+			u, err = o.DecodeVarint()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
+
+		case WireStartGroup:
+			if err != nil {
+				fmt.Printf("%3d: t=%3d start err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d start\n", index, tag)
+			depth++
+
+		case WireEndGroup:
+			depth--
+			if err != nil {
+				fmt.Printf("%3d: t=%3d end err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d end\n", index, tag)
+		}
+	}
+
+	if depth != 0 {
+		fmt.Printf("%3d: start-end not balanced %d\n", o.index, depth)
+	}
+	fmt.Printf("\n")
+
+	o.buf = obuf
+	o.index = index
+}
+
+// SetDefaults sets unset protocol buffer fields to their default values.
+// It only modifies fields that are both unset and have defined defaults.
+// It recursively sets default values in any non-nil sub-messages.
+func SetDefaults(pb Message) {
+	setDefaults(reflect.ValueOf(pb), true, false)
+}
+
+// v is a pointer to a struct.
+func setDefaults(v reflect.Value, recur, zeros bool) {
+	v = v.Elem()
+
+	defaultMu.RLock()
+	dm, ok := defaults[v.Type()]
+	defaultMu.RUnlock()
+	if !ok {
+		dm = buildDefaultMessage(v.Type())
+		defaultMu.Lock()
+		defaults[v.Type()] = dm
+		defaultMu.Unlock()
+	}
+
+	for _, sf := range dm.scalars {
+		f := v.Field(sf.index)
+		if !f.IsNil() {
+			// field already set
+			continue
+		}
+		dv := sf.value
+		if dv == nil && !zeros {
+			// no explicit default, and don't want to set zeros
+			continue
+		}
+		fptr := f.Addr().Interface() // **T
+		// TODO: Consider batching the allocations we do here.
+		switch sf.kind {
+		case reflect.Bool:
+			b := new(bool)
+			if dv != nil {
+				*b = dv.(bool)
+			}
+			*(fptr.(**bool)) = b
+		case reflect.Float32:
+			f := new(float32)
+			if dv != nil {
+				*f = dv.(float32)
+			}
+			*(fptr.(**float32)) = f
+		case reflect.Float64:
+			f := new(float64)
+			if dv != nil {
+				*f = dv.(float64)
+			}
+			*(fptr.(**float64)) = f
+		case reflect.Int32:
+			// might be an enum
+			if ft := f.Type(); ft != int32PtrType {
+				// enum
+				f.Set(reflect.New(ft.Elem()))
+				if dv != nil {
+					f.Elem().SetInt(int64(dv.(int32)))
+				}
+			} else {
+				// int32 field
+				i := new(int32)
+				if dv != nil {
+					*i = dv.(int32)
+				}
+				*(fptr.(**int32)) = i
+			}
+		case reflect.Int64:
+			i := new(int64)
+			if dv != nil {
+				*i = dv.(int64)
+			}
+			*(fptr.(**int64)) = i
+		case reflect.String:
+			s := new(string)
+			if dv != nil {
+				*s = dv.(string)
+			}
+			*(fptr.(**string)) = s
+		case reflect.Uint8:
+			// exceptional case: []byte
+			var b []byte
+			if dv != nil {
+				db := dv.([]byte)
+				b = make([]byte, len(db))
+				copy(b, db)
+			} else {
+				b = []byte{}
+			}
+			*(fptr.(*[]byte)) = b
+		case reflect.Uint32:
+			u := new(uint32)
+			if dv != nil {
+				*u = dv.(uint32)
+			}
+			*(fptr.(**uint32)) = u
+		case reflect.Uint64:
+			u := new(uint64)
+			if dv != nil {
+				*u = dv.(uint64)
+			}
+			*(fptr.(**uint64)) = u
+		default:
+			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
+		}
+	}
+
+	for _, ni := range dm.nested {
+		f := v.Field(ni)
+		// f is *T or []*T or map[T]*T
+		switch f.Kind() {
+		case reflect.Ptr:
+			if f.IsNil() {
+				continue
+			}
+			setDefaults(f, recur, zeros)
+
+		case reflect.Slice:
+			for i := 0; i < f.Len(); i++ {
+				e := f.Index(i)
+				if e.IsNil() {
+					continue
+				}
+				setDefaults(e, recur, zeros)
+			}
+
+		case reflect.Map:
+			for _, k := range f.MapKeys() {
+				e := f.MapIndex(k)
+				if e.IsNil() {
+					continue
+				}
+				setDefaults(e, recur, zeros)
+			}
+		}
+	}
+}
+
+var (
+	// defaults maps a protocol buffer struct type to a slice of the fields,
+	// with its scalar fields set to their proto-declared non-zero default values.
+	defaultMu sync.RWMutex
+	defaults  = make(map[reflect.Type]defaultMessage)
+
+	int32PtrType = reflect.TypeOf((*int32)(nil))
+)
+
+// defaultMessage represents information about the default values of a message.
+type defaultMessage struct {
+	scalars []scalarField
+	nested  []int // struct field index of nested messages
+}
+
+type scalarField struct {
+	index int          // struct field index
+	kind  reflect.Kind // element type (the T in *T or []T)
+	value interface{}  // the proto-declared default value, or nil
+}
+
+// t is a struct type.
+func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
+	sprop := GetProperties(t)
+	for _, prop := range sprop.Prop {
+		fi, ok := sprop.decoderTags.get(prop.Tag)
+		if !ok {
+			// XXX_unrecognized
+			continue
+		}
+		ft := t.Field(fi).Type
+
+		var canHaveDefault, nestedMessage bool
+		switch ft.Kind() {
+		case reflect.Ptr:
+			if ft.Elem().Kind() == reflect.Struct {
+				nestedMessage = true
+			} else {
+				canHaveDefault = true // proto2 scalar field
+			}
+
+		case reflect.Slice:
+			switch ft.Elem().Kind() {
+			case reflect.Ptr:
+				nestedMessage = true // repeated message
+			case reflect.Uint8:
+				canHaveDefault = true // bytes field
+			}
+
+		case reflect.Map:
+			if ft.Elem().Kind() == reflect.Ptr {
+				nestedMessage = true // map with message values
+			}
+		}
+
+		if !canHaveDefault {
+			if nestedMessage {
+				dm.nested = append(dm.nested, fi)
+			}
+			continue
+		}
+
+		sf := scalarField{
+			index: fi,
+			kind:  ft.Elem().Kind(),
+		}
+
+		// scalar fields without defaults
+		if !prop.HasDefault {
+			dm.scalars = append(dm.scalars, sf)
+			continue
+		}
+
+		// a scalar field: either *T or []byte
+		switch ft.Elem().Kind() {
+		case reflect.Bool:
+			x, err := strconv.ParseBool(prop.Default)
+			if err != nil {
+				log.Printf("proto: bad default bool %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = x
+		case reflect.Float32:
+			x, err := strconv.ParseFloat(prop.Default, 32)
+			if err != nil {
+				log.Printf("proto: bad default float32 %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = float32(x)
+		case reflect.Float64:
+			x, err := strconv.ParseFloat(prop.Default, 64)
+			if err != nil {
+				log.Printf("proto: bad default float64 %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = x
+		case reflect.Int32:
+			x, err := strconv.ParseInt(prop.Default, 10, 32)
+			if err != nil {
+				log.Printf("proto: bad default int32 %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = int32(x)
+		case reflect.Int64:
+			x, err := strconv.ParseInt(prop.Default, 10, 64)
+			if err != nil {
+				log.Printf("proto: bad default int64 %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = x
+		case reflect.String:
+			sf.value = prop.Default
+		case reflect.Uint8:
+			// []byte (not *uint8)
+			sf.value = []byte(prop.Default)
+		case reflect.Uint32:
+			x, err := strconv.ParseUint(prop.Default, 10, 32)
+			if err != nil {
+				log.Printf("proto: bad default uint32 %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = uint32(x)
+		case reflect.Uint64:
+			x, err := strconv.ParseUint(prop.Default, 10, 64)
+			if err != nil {
+				log.Printf("proto: bad default uint64 %q: %v", prop.Default, err)
+				continue
+			}
+			sf.value = x
+		default:
+			log.Printf("proto: unhandled def kind %v", ft.Elem().Kind())
+			continue
+		}
+
+		dm.scalars = append(dm.scalars, sf)
+	}
+
+	return dm
+}
+
+// Map fields may have key types of non-float scalars, strings and enums.
+// The easiest way to sort them in some deterministic order is to use fmt.
+// If this turns out to be inefficient we can always consider other options,
+// such as doing a Schwartzian transform.
+
+type mapKeys []reflect.Value
+
+func (s mapKeys) Len() int      { return len(s) }
+func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s mapKeys) Less(i, j int) bool {
+	return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface())
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/lib_gogo.go b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
new file mode 100644
index 00000000..a6c2c06b
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
@@ -0,0 +1,40 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"encoding/json"
+	"strconv"
+)
+
+func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error) {
+	s, ok := m[value]
+	if !ok {
+		s = strconv.Itoa(int(value))
+	}
+	return json.Marshal(s)
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/message_set.go b/vendor/github.com/gogo/protobuf/proto/message_set.go
new file mode 100644
index 00000000..9d912bce
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/message_set.go
@@ -0,0 +1,287 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Support for message sets.
+ */
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+// ErrNoMessageTypeId occurs when a protocol buffer does not have a message type ID.
+// A message type ID is required for storing a protocol buffer in a message set.
+var ErrNoMessageTypeId = errors.New("proto does not have a message type ID")
+
+// The first two types (_MessageSet_Item and MessageSet)
+// model what the protocol compiler produces for the following protocol message:
+//   message MessageSet {
+//     repeated group Item = 1 {
+//       required int32 type_id = 2;
+//       required string message = 3;
+//     };
+//   }
+// That is the MessageSet wire format. We can't use a proto to generate these
+// because that would introduce a circular dependency between it and this package.
+//
+// When a proto1 proto has a field that looks like:
+//   optional message<MessageSet> info = 3;
+// the protocol compiler produces a field in the generated struct that looks like:
+//   Info *_proto_.MessageSet  `protobuf:"bytes,3,opt,name=info"`
+// The package is automatically inserted so there is no need for that proto file to
+// import this package.
+
+type _MessageSet_Item struct {
+	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
+	Message []byte `protobuf:"bytes,3,req,name=message"`
+}
+
+type MessageSet struct {
+	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
+	XXX_unrecognized []byte
+	// TODO: caching?
+}
+
+// Make sure MessageSet is a Message.
+var _ Message = (*MessageSet)(nil)
+
+// messageTypeIder is an interface satisfied by a protocol buffer type
+// that may be stored in a MessageSet.
+type messageTypeIder interface {
+	MessageTypeId() int32
+}
+
+func (ms *MessageSet) find(pb Message) *_MessageSet_Item {
+	mti, ok := pb.(messageTypeIder)
+	if !ok {
+		return nil
+	}
+	id := mti.MessageTypeId()
+	for _, item := range ms.Item {
+		if *item.TypeId == id {
+			return item
+		}
+	}
+	return nil
+}
+
+func (ms *MessageSet) Has(pb Message) bool {
+	if ms.find(pb) != nil {
+		return true
+	}
+	return false
+}
+
+func (ms *MessageSet) Unmarshal(pb Message) error {
+	if item := ms.find(pb); item != nil {
+		return Unmarshal(item.Message, pb)
+	}
+	if _, ok := pb.(messageTypeIder); !ok {
+		return ErrNoMessageTypeId
+	}
+	return nil // TODO: return error instead?
+}
+
+func (ms *MessageSet) Marshal(pb Message) error {
+	msg, err := Marshal(pb)
+	if err != nil {
+		return err
+	}
+	if item := ms.find(pb); item != nil {
+		// reuse existing item
+		item.Message = msg
+		return nil
+	}
+
+	mti, ok := pb.(messageTypeIder)
+	if !ok {
+		return ErrNoMessageTypeId
+	}
+
+	mtid := mti.MessageTypeId()
+	ms.Item = append(ms.Item, &_MessageSet_Item{
+		TypeId:  &mtid,
+		Message: msg,
+	})
+	return nil
+}
+
+func (ms *MessageSet) Reset()         { *ms = MessageSet{} }
+func (ms *MessageSet) String() string { return CompactTextString(ms) }
+func (*MessageSet) ProtoMessage()     {}
+
+// Support for the message_set_wire_format message option.
+
+func skipVarint(buf []byte) []byte {
+	i := 0
+	for ; buf[i]&0x80 != 0; i++ {
+	}
+	return buf[i+1:]
+}
+
+// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
+// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
+func MarshalMessageSet(m map[int32]Extension) ([]byte, error) {
+	if err := encodeExtensionMap(m); err != nil {
+		return nil, err
+	}
+
+	// Sort extension IDs to provide a deterministic encoding.
+	// See also enc_map in encode.go.
+	ids := make([]int, 0, len(m))
+	for id := range m {
+		ids = append(ids, int(id))
+	}
+	sort.Ints(ids)
+
+	ms := &MessageSet{Item: make([]*_MessageSet_Item, 0, len(m))}
+	for _, id := range ids {
+		e := m[int32(id)]
+		// Remove the wire type and field number varint, as well as the length varint.
+		msg := skipVarint(skipVarint(e.enc))
+
+		ms.Item = append(ms.Item, &_MessageSet_Item{
+			TypeId:  Int32(int32(id)),
+			Message: msg,
+		})
+	}
+	return Marshal(ms)
+}
+
+// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
+func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error {
+	ms := new(MessageSet)
+	if err := Unmarshal(buf, ms); err != nil {
+		return err
+	}
+	for _, item := range ms.Item {
+		id := *item.TypeId
+		msg := item.Message
+
+		// Restore wire type and field number varint, plus length varint.
+		// Be careful to preserve duplicate items.
+		b := EncodeVarint(uint64(id)<<3 | WireBytes)
+		if ext, ok := m[id]; ok {
+			// Existing data; rip off the tag and length varint
+			// so we join the new data correctly.
+			// We can assume that ext.enc is set because we are unmarshaling.
+			o := ext.enc[len(b):]   // skip wire type and field number
+			_, n := DecodeVarint(o) // calculate length of length varint
+			o = o[n:]               // skip length varint
+			msg = append(o, msg...) // join old data and new data
+		}
+		b = append(b, EncodeVarint(uint64(len(msg)))...)
+		b = append(b, msg...)
+
+		m[id] = Extension{enc: b}
+	}
+	return nil
+}
+
+// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
+// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
+func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) {
+	var b bytes.Buffer
+	b.WriteByte('{')
+
+	// Process the map in key order for deterministic output.
+	ids := make([]int32, 0, len(m))
+	for id := range m {
+		ids = append(ids, id)
+	}
+	sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
+
+	for i, id := range ids {
+		ext := m[id]
+		if i > 0 {
+			b.WriteByte(',')
+		}
+
+		msd, ok := messageSetMap[id]
+		if !ok {
+			// Unknown type; we can't render it, so skip it.
+			continue
+		}
+		fmt.Fprintf(&b, `"[%s]":`, msd.name)
+
+		x := ext.value
+		if x == nil {
+			x = reflect.New(msd.t.Elem()).Interface()
+			if err := Unmarshal(ext.enc, x.(Message)); err != nil {
+				return nil, err
+			}
+		}
+		d, err := json.Marshal(x)
+		if err != nil {
+			return nil, err
+		}
+		b.Write(d)
+	}
+	b.WriteByte('}')
+	return b.Bytes(), nil
+}
+
+// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
+// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
+func UnmarshalMessageSetJSON(buf []byte, m map[int32]Extension) error {
+	// Common-case fast path.
+	if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
+		return nil
+	}
+
+	// This is fairly tricky, and it's not clear that it is needed.
+	return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
+}
+
+// A global registry of types that can be used in a MessageSet.
+
+var messageSetMap = make(map[int32]messageSetDesc)
+
+type messageSetDesc struct {
+	t    reflect.Type // pointer to struct
+	name string
+}
+
+// RegisterMessageSetType is called from the generated code.
+func RegisterMessageSetType(m Message, fieldNum int32, name string) {
+	messageSetMap[fieldNum] = messageSetDesc{
+		t:    reflect.TypeOf(m),
+		name: name,
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
new file mode 100644
index 00000000..c68b1252
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,479 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build appengine
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+	"math"
+	"reflect"
+)
+
+// A structPointer is a pointer to a struct.
+type structPointer struct {
+	v reflect.Value
+}
+
+// toStructPointer returns a structPointer equivalent to the given reflect value.
+// The reflect value must itself be a pointer to a struct.
+func toStructPointer(v reflect.Value) structPointer {
+	return structPointer{v}
+}
+
+// IsNil reports whether p is nil.
+func structPointer_IsNil(p structPointer) bool {
+	return p.v.IsNil()
+}
+
+// Interface returns the struct pointer as an interface value.
+func structPointer_Interface(p structPointer, _ reflect.Type) interface{} {
+	return p.v.Interface()
+}
+
+// A field identifies a field in a struct, accessible from a structPointer.
+// In this implementation, a field is identified by the sequence of field indices
+// passed to reflect's FieldByIndex.
+type field []int
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+	return f.Index
+}
+
+// invalidField is an invalid field identifier.
+var invalidField = field(nil)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool { return f != nil }
+
+// field returns the given field in the struct as a reflect value.
+func structPointer_field(p structPointer, f field) reflect.Value {
+	// Special case: an extension map entry with a value of type T
+	// passes a *T to the struct-handling code with a zero field,
+	// expecting that it will be treated as equivalent to *struct{ X T },
+	// which has the same memory layout. We have to handle that case
+	// specially, because reflect will panic if we call FieldByIndex on a
+	// non-struct.
+	if f == nil {
+		return p.v.Elem()
+	}
+
+	return p.v.Elem().FieldByIndex(f)
+}
+
+// ifield returns the given field in the struct as an interface value.
+func structPointer_ifield(p structPointer, f field) interface{} {
+	return structPointer_field(p, f).Addr().Interface()
+}
+
+// Bytes returns the address of a []byte field in the struct.
+func structPointer_Bytes(p structPointer, f field) *[]byte {
+	return structPointer_ifield(p, f).(*[]byte)
+}
+
+// BytesSlice returns the address of a [][]byte field in the struct.
+func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
+	return structPointer_ifield(p, f).(*[][]byte)
+}
+
+// Bool returns the address of a *bool field in the struct.
+func structPointer_Bool(p structPointer, f field) **bool {
+	return structPointer_ifield(p, f).(**bool)
+}
+
+// BoolVal returns the address of a bool field in the struct.
+func structPointer_BoolVal(p structPointer, f field) *bool {
+	return structPointer_ifield(p, f).(*bool)
+}
+
+// BoolSlice returns the address of a []bool field in the struct.
+func structPointer_BoolSlice(p structPointer, f field) *[]bool {
+	return structPointer_ifield(p, f).(*[]bool)
+}
+
+// String returns the address of a *string field in the struct.
+func structPointer_String(p structPointer, f field) **string {
+	return structPointer_ifield(p, f).(**string)
+}
+
+// StringVal returns the address of a string field in the struct.
+func structPointer_StringVal(p structPointer, f field) *string {
+	return structPointer_ifield(p, f).(*string)
+}
+
+// StringSlice returns the address of a []string field in the struct.
+func structPointer_StringSlice(p structPointer, f field) *[]string {
+	return structPointer_ifield(p, f).(*[]string)
+}
+
+// ExtMap returns the address of an extension map field in the struct.
+func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
+	return structPointer_ifield(p, f).(*map[int32]Extension)
+}
+
+// Map returns the reflect.Value for the address of a map field in the struct.
+func structPointer_Map(p structPointer, f field, typ reflect.Type) reflect.Value {
+	return structPointer_field(p, f).Addr()
+}
+
+// SetStructPointer writes a *struct field in the struct.
+func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
+	structPointer_field(p, f).Set(q.v)
+}
+
+// GetStructPointer reads a *struct field in the struct.
+func structPointer_GetStructPointer(p structPointer, f field) structPointer {
+	return structPointer{structPointer_field(p, f)}
+}
+
+// StructPointerSlice the address of a []*struct field in the struct.
+func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice {
+	return structPointerSlice{structPointer_field(p, f)}
+}
+
+// A structPointerSlice represents the address of a slice of pointers to structs
+// (themselves messages or groups). That is, v.Type() is *[]*struct{...}.
+type structPointerSlice struct {
+	v reflect.Value
+}
+
+func (p structPointerSlice) Len() int                  { return p.v.Len() }
+func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} }
+func (p structPointerSlice) Append(q structPointer) {
+	p.v.Set(reflect.Append(p.v, q.v))
+}
+
+var (
+	int32Type   = reflect.TypeOf(int32(0))
+	uint32Type  = reflect.TypeOf(uint32(0))
+	float32Type = reflect.TypeOf(float32(0))
+	int64Type   = reflect.TypeOf(int64(0))
+	uint64Type  = reflect.TypeOf(uint64(0))
+	float64Type = reflect.TypeOf(float64(0))
+)
+
+// A word32 represents a field of type *int32, *uint32, *float32, or *enum.
+// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable.
+type word32 struct {
+	v reflect.Value
+}
+
+// IsNil reports whether p is nil.
+func word32_IsNil(p word32) bool {
+	return p.v.IsNil()
+}
+
+// Set sets p to point at a newly allocated word with bits set to x.
+func word32_Set(p word32, o *Buffer, x uint32) {
+	t := p.v.Type().Elem()
+	switch t {
+	case int32Type:
+		if len(o.int32s) == 0 {
+			o.int32s = make([]int32, uint32PoolSize)
+		}
+		o.int32s[0] = int32(x)
+		p.v.Set(reflect.ValueOf(&o.int32s[0]))
+		o.int32s = o.int32s[1:]
+		return
+	case uint32Type:
+		if len(o.uint32s) == 0 {
+			o.uint32s = make([]uint32, uint32PoolSize)
+		}
+		o.uint32s[0] = x
+		p.v.Set(reflect.ValueOf(&o.uint32s[0]))
+		o.uint32s = o.uint32s[1:]
+		return
+	case float32Type:
+		if len(o.float32s) == 0 {
+			o.float32s = make([]float32, uint32PoolSize)
+		}
+		o.float32s[0] = math.Float32frombits(x)
+		p.v.Set(reflect.ValueOf(&o.float32s[0]))
+		o.float32s = o.float32s[1:]
+		return
+	}
+
+	// must be enum
+	p.v.Set(reflect.New(t))
+	p.v.Elem().SetInt(int64(int32(x)))
+}
+
+// Get gets the bits pointed at by p, as a uint32.
+func word32_Get(p word32) uint32 {
+	elem := p.v.Elem()
+	switch elem.Kind() {
+	case reflect.Int32:
+		return uint32(elem.Int())
+	case reflect.Uint32:
+		return uint32(elem.Uint())
+	case reflect.Float32:
+		return math.Float32bits(float32(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32(p structPointer, f field) word32 {
+	return word32{structPointer_field(p, f)}
+}
+
+// A word32Val represents a field of type int32, uint32, float32, or enum.
+// That is, v.Type() is int32, uint32, float32, or enum and v is assignable.
+type word32Val struct {
+	v reflect.Value
+}
+
+// Set sets *p to x.
+func word32Val_Set(p word32Val, x uint32) {
+	switch p.v.Type() {
+	case int32Type:
+		p.v.SetInt(int64(x))
+		return
+	case uint32Type:
+		p.v.SetUint(uint64(x))
+		return
+	case float32Type:
+		p.v.SetFloat(float64(math.Float32frombits(x)))
+		return
+	}
+
+	// must be enum
+	p.v.SetInt(int64(int32(x)))
+}
+
+// Get gets the bits pointed at by p, as a uint32.
+func word32Val_Get(p word32Val) uint32 {
+	elem := p.v
+	switch elem.Kind() {
+	case reflect.Int32:
+		return uint32(elem.Int())
+	case reflect.Uint32:
+		return uint32(elem.Uint())
+	case reflect.Float32:
+		return math.Float32bits(float32(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct.
+func structPointer_Word32Val(p structPointer, f field) word32Val {
+	return word32Val{structPointer_field(p, f)}
+}
+
+// A word32Slice is a slice of 32-bit values.
+// That is, v.Type() is []int32, []uint32, []float32, or []enum.
+type word32Slice struct {
+	v reflect.Value
+}
+
+func (p word32Slice) Append(x uint32) {
+	n, m := p.v.Len(), p.v.Cap()
+	if n < m {
+		p.v.SetLen(n + 1)
+	} else {
+		t := p.v.Type().Elem()
+		p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
+	}
+	elem := p.v.Index(n)
+	switch elem.Kind() {
+	case reflect.Int32:
+		elem.SetInt(int64(int32(x)))
+	case reflect.Uint32:
+		elem.SetUint(uint64(x))
+	case reflect.Float32:
+		elem.SetFloat(float64(math.Float32frombits(x)))
+	}
+}
+
+func (p word32Slice) Len() int {
+	return p.v.Len()
+}
+
+func (p word32Slice) Index(i int) uint32 {
+	elem := p.v.Index(i)
+	switch elem.Kind() {
+	case reflect.Int32:
+		return uint32(elem.Int())
+	case reflect.Uint32:
+		return uint32(elem.Uint())
+	case reflect.Float32:
+		return math.Float32bits(float32(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct.
+func structPointer_Word32Slice(p structPointer, f field) word32Slice {
+	return word32Slice{structPointer_field(p, f)}
+}
+
+// word64 is like word32 but for 64-bit values.
+type word64 struct {
+	v reflect.Value
+}
+
+func word64_Set(p word64, o *Buffer, x uint64) {
+	t := p.v.Type().Elem()
+	switch t {
+	case int64Type:
+		if len(o.int64s) == 0 {
+			o.int64s = make([]int64, uint64PoolSize)
+		}
+		o.int64s[0] = int64(x)
+		p.v.Set(reflect.ValueOf(&o.int64s[0]))
+		o.int64s = o.int64s[1:]
+		return
+	case uint64Type:
+		if len(o.uint64s) == 0 {
+			o.uint64s = make([]uint64, uint64PoolSize)
+		}
+		o.uint64s[0] = x
+		p.v.Set(reflect.ValueOf(&o.uint64s[0]))
+		o.uint64s = o.uint64s[1:]
+		return
+	case float64Type:
+		if len(o.float64s) == 0 {
+			o.float64s = make([]float64, uint64PoolSize)
+		}
+		o.float64s[0] = math.Float64frombits(x)
+		p.v.Set(reflect.ValueOf(&o.float64s[0]))
+		o.float64s = o.float64s[1:]
+		return
+	}
+	panic("unreachable")
+}
+
+func word64_IsNil(p word64) bool {
+	return p.v.IsNil()
+}
+
+func word64_Get(p word64) uint64 {
+	elem := p.v.Elem()
+	switch elem.Kind() {
+	case reflect.Int64:
+		return uint64(elem.Int())
+	case reflect.Uint64:
+		return elem.Uint()
+	case reflect.Float64:
+		return math.Float64bits(elem.Float())
+	}
+	panic("unreachable")
+}
+
+func structPointer_Word64(p structPointer, f field) word64 {
+	return word64{structPointer_field(p, f)}
+}
+
+// word64Val is like word32Val but for 64-bit values.
+type word64Val struct {
+	v reflect.Value
+}
+
+func word64Val_Set(p word64Val, o *Buffer, x uint64) {
+	switch p.v.Type() {
+	case int64Type:
+		p.v.SetInt(int64(x))
+		return
+	case uint64Type:
+		p.v.SetUint(x)
+		return
+	case float64Type:
+		p.v.SetFloat(math.Float64frombits(x))
+		return
+	}
+	panic("unreachable")
+}
+
+func word64Val_Get(p word64Val) uint64 {
+	elem := p.v
+	switch elem.Kind() {
+	case reflect.Int64:
+		return uint64(elem.Int())
+	case reflect.Uint64:
+		return elem.Uint()
+	case reflect.Float64:
+		return math.Float64bits(elem.Float())
+	}
+	panic("unreachable")
+}
+
+func structPointer_Word64Val(p structPointer, f field) word64Val {
+	return word64Val{structPointer_field(p, f)}
+}
+
+type word64Slice struct {
+	v reflect.Value
+}
+
+func (p word64Slice) Append(x uint64) {
+	n, m := p.v.Len(), p.v.Cap()
+	if n < m {
+		p.v.SetLen(n + 1)
+	} else {
+		t := p.v.Type().Elem()
+		p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
+	}
+	elem := p.v.Index(n)
+	switch elem.Kind() {
+	case reflect.Int64:
+		elem.SetInt(int64(int64(x)))
+	case reflect.Uint64:
+		elem.SetUint(uint64(x))
+	case reflect.Float64:
+		elem.SetFloat(float64(math.Float64frombits(x)))
+	}
+}
+
+func (p word64Slice) Len() int {
+	return p.v.Len()
+}
+
+func (p word64Slice) Index(i int) uint64 {
+	elem := p.v.Index(i)
+	switch elem.Kind() {
+	case reflect.Int64:
+		return uint64(elem.Int())
+	case reflect.Uint64:
+		return uint64(elem.Uint())
+	case reflect.Float64:
+		return math.Float64bits(float64(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+func structPointer_Word64Slice(p structPointer, f field) word64Slice {
+	return word64Slice{structPointer_field(p, f)}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
new file mode 100644
index 00000000..48bc0fa4
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,266 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !appengine
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// NOTE: These type_Foo functions would more idiomatically be methods,
+// but Go does not allow methods on pointer types, and we must preserve
+// some pointer type for the garbage collector. We use these
+// funcs with clunky names as our poor approximation to methods.
+//
+// An alternative would be
+//	type structPointer struct { p unsafe.Pointer }
+// but that does not registerize as well.
+
+// A structPointer is a pointer to a struct.
+type structPointer unsafe.Pointer
+
+// toStructPointer returns a structPointer equivalent to the given reflect value.
+func toStructPointer(v reflect.Value) structPointer {
+	return structPointer(unsafe.Pointer(v.Pointer()))
+}
+
+// IsNil reports whether p is nil.
+func structPointer_IsNil(p structPointer) bool {
+	return p == nil
+}
+
+// Interface returns the struct pointer, assumed to have element type t,
+// as an interface value.
+func structPointer_Interface(p structPointer, t reflect.Type) interface{} {
+	return reflect.NewAt(t, unsafe.Pointer(p)).Interface()
+}
+
+// A field identifies a field in a struct, accessible from a structPointer.
+// In this implementation, a field is identified by its byte offset from the start of the struct.
+type field uintptr
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+	return field(f.Offset)
+}
+
+// invalidField is an invalid field identifier.
+const invalidField = ^field(0)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool {
+	return f != ^field(0)
+}
+
+// Bytes returns the address of a []byte field in the struct.
+func structPointer_Bytes(p structPointer, f field) *[]byte {
+	return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BytesSlice returns the address of a [][]byte field in the struct.
+func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
+	return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// Bool returns the address of a *bool field in the struct.
+func structPointer_Bool(p structPointer, f field) **bool {
+	return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BoolVal returns the address of a bool field in the struct.
+func structPointer_BoolVal(p structPointer, f field) *bool {
+	return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BoolSlice returns the address of a []bool field in the struct.
+func structPointer_BoolSlice(p structPointer, f field) *[]bool {
+	return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// String returns the address of a *string field in the struct.
+func structPointer_String(p structPointer, f field) **string {
+	return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StringVal returns the address of a string field in the struct.
+func structPointer_StringVal(p structPointer, f field) *string {
+	return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StringSlice returns the address of a []string field in the struct.
+func structPointer_StringSlice(p structPointer, f field) *[]string {
+	return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// ExtMap returns the address of an extension map field in the struct.
+func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
+	return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// Map returns the reflect.Value for the address of a map field in the struct.
+func structPointer_Map(p structPointer, f field, typ reflect.Type) reflect.Value {
+	return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f)))
+}
+
+// SetStructPointer writes a *struct field in the struct.
+func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
+	*(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q
+}
+
+// GetStructPointer reads a *struct field in the struct.
+func structPointer_GetStructPointer(p structPointer, f field) structPointer {
+	return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StructPointerSlice the address of a []*struct field in the struct.
+func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice {
+	return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups).
+type structPointerSlice []structPointer
+
+func (v *structPointerSlice) Len() int                  { return len(*v) }
+func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] }
+func (v *structPointerSlice) Append(p structPointer)    { *v = append(*v, p) }
+
+// A word32 is the address of a "pointer to 32-bit value" field.
+type word32 **uint32
+
+// IsNil reports whether *v is nil.
+func word32_IsNil(p word32) bool {
+	return *p == nil
+}
+
+// Set sets *v to point at a newly allocated word set to x.
+func word32_Set(p word32, o *Buffer, x uint32) {
+	if len(o.uint32s) == 0 {
+		o.uint32s = make([]uint32, uint32PoolSize)
+	}
+	o.uint32s[0] = x
+	*p = &o.uint32s[0]
+	o.uint32s = o.uint32s[1:]
+}
+
+// Get gets the value pointed at by *v.
+func word32_Get(p word32) uint32 {
+	return **p
+}
+
+// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32(p structPointer, f field) word32 {
+	return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// A word32Val is the address of a 32-bit value field.
+type word32Val *uint32
+
+// Set sets *p to x.
+func word32Val_Set(p word32Val, x uint32) {
+	*p = x
+}
+
+// Get gets the value pointed at by p.
+func word32Val_Get(p word32Val) uint32 {
+	return *p
+}
+
+// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32Val(p structPointer, f field) word32Val {
+	return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// A word32Slice is a slice of 32-bit values.
+type word32Slice []uint32
+
+func (v *word32Slice) Append(x uint32)    { *v = append(*v, x) }
+func (v *word32Slice) Len() int           { return len(*v) }
+func (v *word32Slice) Index(i int) uint32 { return (*v)[i] }
+
+// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct.
+func structPointer_Word32Slice(p structPointer, f field) *word32Slice {
+	return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// word64 is like word32 but for 64-bit values.
+type word64 **uint64
+
+func word64_Set(p word64, o *Buffer, x uint64) {
+	if len(o.uint64s) == 0 {
+		o.uint64s = make([]uint64, uint64PoolSize)
+	}
+	o.uint64s[0] = x
+	*p = &o.uint64s[0]
+	o.uint64s = o.uint64s[1:]
+}
+
+func word64_IsNil(p word64) bool {
+	return *p == nil
+}
+
+func word64_Get(p word64) uint64 {
+	return **p
+}
+
+func structPointer_Word64(p structPointer, f field) word64 {
+	return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// word64Val is like word32Val but for 64-bit values.
+type word64Val *uint64
+
+func word64Val_Set(p word64Val, o *Buffer, x uint64) {
+	*p = x
+}
+
+func word64Val_Get(p word64Val) uint64 {
+	return *p
+}
+
+func structPointer_Word64Val(p structPointer, f field) word64Val {
+	return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// word64Slice is like word32Slice but for 64-bit values.
+type word64Slice []uint64
+
+func (v *word64Slice) Append(x uint64)    { *v = append(*v, x) }
+func (v *word64Slice) Len() int           { return len(*v) }
+func (v *word64Slice) Index(i int) uint64 { return (*v)[i] }
+
+func structPointer_Word64Slice(p structPointer, f field) *word64Slice {
+	return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
new file mode 100644
index 00000000..6bc85fa9
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !appengine
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+func structPointer_InterfaceAt(p structPointer, f field, t reflect.Type) interface{} {
+	point := unsafe.Pointer(uintptr(p) + uintptr(f))
+	r := reflect.NewAt(t, point)
+	return r.Interface()
+}
+
+func structPointer_InterfaceRef(p structPointer, f field, t reflect.Type) interface{} {
+	point := unsafe.Pointer(uintptr(p) + uintptr(f))
+	r := reflect.NewAt(t, point)
+	if r.Elem().IsNil() {
+		return nil
+	}
+	return r.Elem().Interface()
+}
+
+func copyUintPtr(oldptr, newptr uintptr, size int) {
+	oldbytes := make([]byte, 0)
+	oldslice := (*reflect.SliceHeader)(unsafe.Pointer(&oldbytes))
+	oldslice.Data = oldptr
+	oldslice.Len = size
+	oldslice.Cap = size
+	newbytes := make([]byte, 0)
+	newslice := (*reflect.SliceHeader)(unsafe.Pointer(&newbytes))
+	newslice.Data = newptr
+	newslice.Len = size
+	newslice.Cap = size
+	copy(newbytes, oldbytes)
+}
+
+func structPointer_Copy(oldptr structPointer, newptr structPointer, size int) {
+	copyUintPtr(uintptr(oldptr), uintptr(newptr), size)
+}
+
+func appendStructPointer(base structPointer, f field, typ reflect.Type) structPointer {
+	size := typ.Elem().Size()
+	oldHeader := structPointer_GetSliceHeader(base, f)
+	newLen := oldHeader.Len + 1
+	slice := reflect.MakeSlice(typ, newLen, newLen)
+	bas := toStructPointer(slice)
+	for i := 0; i < oldHeader.Len; i++ {
+		newElemptr := uintptr(bas) + uintptr(i)*size
+		oldElemptr := oldHeader.Data + uintptr(i)*size
+		copyUintPtr(oldElemptr, newElemptr, int(size))
+	}
+
+	oldHeader.Data = uintptr(bas)
+	oldHeader.Len = newLen
+	oldHeader.Cap = newLen
+
+	return structPointer(unsafe.Pointer(uintptr(unsafe.Pointer(bas)) + uintptr(uintptr(newLen-1)*size)))
+}
+
+func structPointer_FieldPointer(p structPointer, f field) structPointer {
+	return structPointer(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_GetRefStructPointer(p structPointer, f field) structPointer {
+	return structPointer((*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+func structPointer_GetSliceHeader(p structPointer, f field) *reflect.SliceHeader {
+	return (*reflect.SliceHeader)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_Add(p structPointer, size field) structPointer {
+	return structPointer(unsafe.Pointer(uintptr(p) + uintptr(size)))
+}
+
+func structPointer_Len(p structPointer, f field) int {
+	return len(*(*[]interface{})(unsafe.Pointer(structPointer_GetRefStructPointer(p, f))))
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/properties.go b/vendor/github.com/gogo/protobuf/proto/properties.go
new file mode 100644
index 00000000..13245c00
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties.go
@@ -0,0 +1,815 @@
+// Extensions for Protocol Buffers to create more go like structures.
+//
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+const debug bool = false
+
+// Constants that identify the encoding of a value on the wire.
+const (
+	WireVarint     = 0
+	WireFixed64    = 1
+	WireBytes      = 2
+	WireStartGroup = 3
+	WireEndGroup   = 4
+	WireFixed32    = 5
+)
+
+const startSize = 10 // initial slice/string sizes
+
+// Encoders are defined in encode.go
+// An encoder outputs the full representation of a field, including its
+// tag and encoder type.
+type encoder func(p *Buffer, prop *Properties, base structPointer) error
+
+// A valueEncoder encodes a single integer in a particular encoding.
+type valueEncoder func(o *Buffer, x uint64) error
+
+// Sizers are defined in encode.go
+// A sizer returns the encoded size of a field, including its tag and encoder
+// type.
+type sizer func(prop *Properties, base structPointer) int
+
+// A valueSizer returns the encoded size of a single integer in a particular
+// encoding.
+type valueSizer func(x uint64) int
+
+// Decoders are defined in decode.go
+// A decoder creates a value from its wire representation.
+// Unrecognized subelements are saved in unrec.
+type decoder func(p *Buffer, prop *Properties, base structPointer) error
+
+// A valueDecoder decodes a single integer in a particular encoding.
+type valueDecoder func(o *Buffer) (x uint64, err error)
+
+// tagMap is an optimization over map[int]int for typical protocol buffer
+// use-cases. Encoded protocol buffers are often in tag order with small tag
+// numbers.
+type tagMap struct {
+	fastTags []int
+	slowTags map[int]int
+}
+
+// tagMapFastLimit is the upper bound on the tag number that will be stored in
+// the tagMap slice rather than its map.
+const tagMapFastLimit = 1024
+
+func (p *tagMap) get(t int) (int, bool) {
+	if t > 0 && t < tagMapFastLimit {
+		if t >= len(p.fastTags) {
+			return 0, false
+		}
+		fi := p.fastTags[t]
+		return fi, fi >= 0
+	}
+	fi, ok := p.slowTags[t]
+	return fi, ok
+}
+
+func (p *tagMap) put(t int, fi int) {
+	if t > 0 && t < tagMapFastLimit {
+		for len(p.fastTags) < t+1 {
+			p.fastTags = append(p.fastTags, -1)
+		}
+		p.fastTags[t] = fi
+		return
+	}
+	if p.slowTags == nil {
+		p.slowTags = make(map[int]int)
+	}
+	p.slowTags[t] = fi
+}
+
+// StructProperties represents properties for all the fields of a struct.
+// decoderTags and decoderOrigNames should only be used by the decoder.
+type StructProperties struct {
+	Prop             []*Properties  // properties for each field
+	reqCount         int            // required count
+	decoderTags      tagMap         // map from proto tag to struct field number
+	decoderOrigNames map[string]int // map from original name to struct field number
+	order            []int          // list of struct field numbers in tag order
+	unrecField       field          // field id of the XXX_unrecognized []byte field
+	extendable       bool           // is this an extendable proto
+}
+
+// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
+// See encode.go, (*Buffer).enc_struct.
+
+func (sp *StructProperties) Len() int { return len(sp.order) }
+func (sp *StructProperties) Less(i, j int) bool {
+	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
+}
+func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
+
+// Properties represents the protocol-specific behavior of a single struct field.
+type Properties struct {
+	Name     string // name of the field, for error messages
+	OrigName string // original name before protocol compiler (always set)
+	Wire     string
+	WireType int
+	Tag      int
+	Required bool
+	Optional bool
+	Repeated bool
+	Packed   bool   // relevant for repeated primitives only
+	Enum     string // set for enum types only
+	proto3   bool   // whether this is known to be a proto3 field; set for []byte only
+
+	Default    string // default value
+	HasDefault bool   // whether an explicit default was provided
+	CustomType string
+	def_uint64 uint64
+
+	enc           encoder
+	valEnc        valueEncoder // set for bool and numeric types only
+	field         field
+	tagcode       []byte // encoding of EncodeVarint((Tag<<3)|WireType)
+	tagbuf        [8]byte
+	stype         reflect.Type      // set for struct types only
+	sstype        reflect.Type      // set for slices of structs types only
+	ctype         reflect.Type      // set for custom types only
+	sprop         *StructProperties // set for struct types only
+	isMarshaler   bool
+	isUnmarshaler bool
+
+	mtype    reflect.Type // set for map types only
+	mkeyprop *Properties  // set for map types only
+	mvalprop *Properties  // set for map types only
+
+	size    sizer
+	valSize valueSizer // set for bool and numeric types only
+
+	dec    decoder
+	valDec valueDecoder // set for bool and numeric types only
+
+	// If this is a packable field, this will be the decoder for the packed version of the field.
+	packedDec decoder
+}
+
+// String formats the properties in the protobuf struct field tag style.
+func (p *Properties) String() string {
+	s := p.Wire
+	s = ","
+	s += strconv.Itoa(p.Tag)
+	if p.Required {
+		s += ",req"
+	}
+	if p.Optional {
+		s += ",opt"
+	}
+	if p.Repeated {
+		s += ",rep"
+	}
+	if p.Packed {
+		s += ",packed"
+	}
+	if p.OrigName != p.Name {
+		s += ",name=" + p.OrigName
+	}
+	if p.proto3 {
+		s += ",proto3"
+	}
+	if len(p.Enum) > 0 {
+		s += ",enum=" + p.Enum
+	}
+	if p.HasDefault {
+		s += ",def=" + p.Default
+	}
+	return s
+}
+
+// Parse populates p by parsing a string in the protobuf struct field tag style.
+func (p *Properties) Parse(s string) {
+	// "bytes,49,opt,name=foo,def=hello!"
+	fields := strings.Split(s, ",") // breaks def=, but handled below.
+	if len(fields) < 2 {
+		fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
+		return
+	}
+
+	p.Wire = fields[0]
+	switch p.Wire {
+	case "varint":
+		p.WireType = WireVarint
+		p.valEnc = (*Buffer).EncodeVarint
+		p.valDec = (*Buffer).DecodeVarint
+		p.valSize = sizeVarint
+	case "fixed32":
+		p.WireType = WireFixed32
+		p.valEnc = (*Buffer).EncodeFixed32
+		p.valDec = (*Buffer).DecodeFixed32
+		p.valSize = sizeFixed32
+	case "fixed64":
+		p.WireType = WireFixed64
+		p.valEnc = (*Buffer).EncodeFixed64
+		p.valDec = (*Buffer).DecodeFixed64
+		p.valSize = sizeFixed64
+	case "zigzag32":
+		p.WireType = WireVarint
+		p.valEnc = (*Buffer).EncodeZigzag32
+		p.valDec = (*Buffer).DecodeZigzag32
+		p.valSize = sizeZigzag32
+	case "zigzag64":
+		p.WireType = WireVarint
+		p.valEnc = (*Buffer).EncodeZigzag64
+		p.valDec = (*Buffer).DecodeZigzag64
+		p.valSize = sizeZigzag64
+	case "bytes", "group":
+		p.WireType = WireBytes
+		// no numeric converter for non-numeric types
+	default:
+		fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
+		return
+	}
+
+	var err error
+	p.Tag, err = strconv.Atoi(fields[1])
+	if err != nil {
+		return
+	}
+
+	for i := 2; i < len(fields); i++ {
+		f := fields[i]
+		switch {
+		case f == "req":
+			p.Required = true
+		case f == "opt":
+			p.Optional = true
+		case f == "rep":
+			p.Repeated = true
+		case f == "packed":
+			p.Packed = true
+		case strings.HasPrefix(f, "name="):
+			p.OrigName = f[5:]
+		case strings.HasPrefix(f, "enum="):
+			p.Enum = f[5:]
+		case f == "proto3":
+			p.proto3 = true
+		case strings.HasPrefix(f, "def="):
+			p.HasDefault = true
+			p.Default = f[4:] // rest of string
+			if i+1 < len(fields) {
+				// Commas aren't escaped, and def is always last.
+				p.Default += "," + strings.Join(fields[i+1:], ",")
+				break
+			}
+		case strings.HasPrefix(f, "embedded="):
+			p.OrigName = strings.Split(f, "=")[1]
+		case strings.HasPrefix(f, "customtype="):
+			p.CustomType = strings.Split(f, "=")[1]
+		}
+	}
+}
+
+func logNoSliceEnc(t1, t2 reflect.Type) {
+	fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)
+}
+
+var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
+
+// Initialize the fields for encoding and decoding.
+func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
+	p.enc = nil
+	p.dec = nil
+	p.size = nil
+	if len(p.CustomType) > 0 {
+		p.setCustomEncAndDec(typ)
+		p.setTag(lockGetProp)
+		return
+	}
+	switch t1 := typ; t1.Kind() {
+	default:
+		fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1)
+
+	// proto3 scalar types
+
+	case reflect.Bool:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_bool
+			p.dec = (*Buffer).dec_proto3_bool
+			p.size = size_proto3_bool
+		} else {
+			p.enc = (*Buffer).enc_ref_bool
+			p.dec = (*Buffer).dec_proto3_bool
+			p.size = size_ref_bool
+		}
+	case reflect.Int32:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_int32
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_proto3_int32
+		} else {
+			p.enc = (*Buffer).enc_ref_int32
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_ref_int32
+		}
+	case reflect.Uint32:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_uint32
+			p.dec = (*Buffer).dec_proto3_int32 // can reuse
+			p.size = size_proto3_uint32
+		} else {
+			p.enc = (*Buffer).enc_ref_uint32
+			p.dec = (*Buffer).dec_proto3_int32 // can reuse
+			p.size = size_ref_uint32
+		}
+	case reflect.Int64, reflect.Uint64:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_int64
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_proto3_int64
+		} else {
+			p.enc = (*Buffer).enc_ref_int64
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_ref_int64
+		}
+	case reflect.Float32:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_proto3_uint32
+		} else {
+			p.enc = (*Buffer).enc_ref_uint32 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_ref_uint32
+		}
+	case reflect.Float64:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_proto3_int64
+		} else {
+			p.enc = (*Buffer).enc_ref_int64 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_ref_int64
+		}
+	case reflect.String:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_string
+			p.dec = (*Buffer).dec_proto3_string
+			p.size = size_proto3_string
+		} else {
+			p.enc = (*Buffer).enc_ref_string
+			p.dec = (*Buffer).dec_proto3_string
+			p.size = size_ref_string
+		}
+	case reflect.Struct:
+		p.stype = typ
+		p.isMarshaler = isMarshaler(typ)
+		p.isUnmarshaler = isUnmarshaler(typ)
+		if p.Wire == "bytes" {
+			p.enc = (*Buffer).enc_ref_struct_message
+			p.dec = (*Buffer).dec_ref_struct_message
+			p.size = size_ref_struct_message
+		} else {
+			fmt.Fprintf(os.Stderr, "proto: no coders for struct %T\n", typ)
+		}
+
+	case reflect.Ptr:
+		switch t2 := t1.Elem(); t2.Kind() {
+		default:
+			fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2)
+			break
+		case reflect.Bool:
+			p.enc = (*Buffer).enc_bool
+			p.dec = (*Buffer).dec_bool
+			p.size = size_bool
+		case reflect.Int32:
+			p.enc = (*Buffer).enc_int32
+			p.dec = (*Buffer).dec_int32
+			p.size = size_int32
+		case reflect.Uint32:
+			p.enc = (*Buffer).enc_uint32
+			p.dec = (*Buffer).dec_int32 // can reuse
+			p.size = size_uint32
+		case reflect.Int64, reflect.Uint64:
+			p.enc = (*Buffer).enc_int64
+			p.dec = (*Buffer).dec_int64
+			p.size = size_int64
+		case reflect.Float32:
+			p.enc = (*Buffer).enc_uint32 // can just treat them as bits
+			p.dec = (*Buffer).dec_int32
+			p.size = size_uint32
+		case reflect.Float64:
+			p.enc = (*Buffer).enc_int64 // can just treat them as bits
+			p.dec = (*Buffer).dec_int64
+			p.size = size_int64
+		case reflect.String:
+			p.enc = (*Buffer).enc_string
+			p.dec = (*Buffer).dec_string
+			p.size = size_string
+		case reflect.Struct:
+			p.stype = t1.Elem()
+			p.isMarshaler = isMarshaler(t1)
+			p.isUnmarshaler = isUnmarshaler(t1)
+			if p.Wire == "bytes" {
+				p.enc = (*Buffer).enc_struct_message
+				p.dec = (*Buffer).dec_struct_message
+				p.size = size_struct_message
+			} else {
+				p.enc = (*Buffer).enc_struct_group
+				p.dec = (*Buffer).dec_struct_group
+				p.size = size_struct_group
+			}
+		}
+
+	case reflect.Slice:
+		switch t2 := t1.Elem(); t2.Kind() {
+		default:
+			logNoSliceEnc(t1, t2)
+			break
+		case reflect.Bool:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_bool
+				p.size = size_slice_packed_bool
+			} else {
+				p.enc = (*Buffer).enc_slice_bool
+				p.size = size_slice_bool
+			}
+			p.dec = (*Buffer).dec_slice_bool
+			p.packedDec = (*Buffer).dec_slice_packed_bool
+		case reflect.Int32:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_int32
+				p.size = size_slice_packed_int32
+			} else {
+				p.enc = (*Buffer).enc_slice_int32
+				p.size = size_slice_int32
+			}
+			p.dec = (*Buffer).dec_slice_int32
+			p.packedDec = (*Buffer).dec_slice_packed_int32
+		case reflect.Uint32:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_uint32
+				p.size = size_slice_packed_uint32
+			} else {
+				p.enc = (*Buffer).enc_slice_uint32
+				p.size = size_slice_uint32
+			}
+			p.dec = (*Buffer).dec_slice_int32
+			p.packedDec = (*Buffer).dec_slice_packed_int32
+		case reflect.Int64, reflect.Uint64:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_int64
+				p.size = size_slice_packed_int64
+			} else {
+				p.enc = (*Buffer).enc_slice_int64
+				p.size = size_slice_int64
+			}
+			p.dec = (*Buffer).dec_slice_int64
+			p.packedDec = (*Buffer).dec_slice_packed_int64
+		case reflect.Uint8:
+			p.enc = (*Buffer).enc_slice_byte
+			p.dec = (*Buffer).dec_slice_byte
+			p.size = size_slice_byte
+			// This is a []byte, which is either a bytes field,
+			// or the value of a map field. In the latter case,
+			// we always encode an empty []byte, so we should not
+			// use the proto3 enc/size funcs.
+			// f == nil iff this is the key/value of a map field.
+			if p.proto3 && f != nil {
+				p.enc = (*Buffer).enc_proto3_slice_byte
+				p.size = size_proto3_slice_byte
+			}
+		case reflect.Float32, reflect.Float64:
+			switch t2.Bits() {
+			case 32:
+				// can just treat them as bits
+				if p.Packed {
+					p.enc = (*Buffer).enc_slice_packed_uint32
+					p.size = size_slice_packed_uint32
+				} else {
+					p.enc = (*Buffer).enc_slice_uint32
+					p.size = size_slice_uint32
+				}
+				p.dec = (*Buffer).dec_slice_int32
+				p.packedDec = (*Buffer).dec_slice_packed_int32
+			case 64:
+				// can just treat them as bits
+				if p.Packed {
+					p.enc = (*Buffer).enc_slice_packed_int64
+					p.size = size_slice_packed_int64
+				} else {
+					p.enc = (*Buffer).enc_slice_int64
+					p.size = size_slice_int64
+				}
+				p.dec = (*Buffer).dec_slice_int64
+				p.packedDec = (*Buffer).dec_slice_packed_int64
+			default:
+				logNoSliceEnc(t1, t2)
+				break
+			}
+		case reflect.String:
+			p.enc = (*Buffer).enc_slice_string
+			p.dec = (*Buffer).dec_slice_string
+			p.size = size_slice_string
+		case reflect.Ptr:
+			switch t3 := t2.Elem(); t3.Kind() {
+			default:
+				fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
+				break
+			case reflect.Struct:
+				p.stype = t2.Elem()
+				p.isMarshaler = isMarshaler(t2)
+				p.isUnmarshaler = isUnmarshaler(t2)
+				if p.Wire == "bytes" {
+					p.enc = (*Buffer).enc_slice_struct_message
+					p.dec = (*Buffer).dec_slice_struct_message
+					p.size = size_slice_struct_message
+				} else {
+					p.enc = (*Buffer).enc_slice_struct_group
+					p.dec = (*Buffer).dec_slice_struct_group
+					p.size = size_slice_struct_group
+				}
+			}
+		case reflect.Slice:
+			switch t2.Elem().Kind() {
+			default:
+				fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
+				break
+			case reflect.Uint8:
+				p.enc = (*Buffer).enc_slice_slice_byte
+				p.dec = (*Buffer).dec_slice_slice_byte
+				p.size = size_slice_slice_byte
+			}
+		case reflect.Struct:
+			p.setSliceOfNonPointerStructs(t1)
+		}
+
+	case reflect.Map:
+		p.enc = (*Buffer).enc_new_map
+		p.dec = (*Buffer).dec_new_map
+		p.size = size_new_map
+
+		p.mtype = t1
+		p.mkeyprop = &Properties{}
+		p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
+		p.mvalprop = &Properties{}
+		vtype := p.mtype.Elem()
+		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
+			// The value type is not a message (*T) or bytes ([]byte),
+			// so we need encoders for the pointer to this type.
+			vtype = reflect.PtrTo(vtype)
+		}
+		p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
+	}
+	p.setTag(lockGetProp)
+}
+
+func (p *Properties) setTag(lockGetProp bool) {
+	// precalculate tag code
+	wire := p.WireType
+	if p.Packed {
+		wire = WireBytes
+	}
+	x := uint32(p.Tag)<<3 | uint32(wire)
+	i := 0
+	for i = 0; x > 127; i++ {
+		p.tagbuf[i] = 0x80 | uint8(x&0x7F)
+		x >>= 7
+	}
+	p.tagbuf[i] = uint8(x)
+	p.tagcode = p.tagbuf[0 : i+1]
+
+	if p.stype != nil {
+		if lockGetProp {
+			p.sprop = GetProperties(p.stype)
+		} else {
+			p.sprop = getPropertiesLocked(p.stype)
+		}
+	}
+}
+
+var (
+	marshalerType   = reflect.TypeOf((*Marshaler)(nil)).Elem()
+	unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+)
+
+// isMarshaler reports whether type t implements Marshaler.
+func isMarshaler(t reflect.Type) bool {
+	return t.Implements(marshalerType)
+}
+
+// isUnmarshaler reports whether type t implements Unmarshaler.
+func isUnmarshaler(t reflect.Type) bool {
+	return t.Implements(unmarshalerType)
+}
+
+// Init populates the properties from a protocol buffer struct tag.
+func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
+	p.init(typ, name, tag, f, true)
+}
+
+func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
+	// "bytes,49,opt,def=hello!"
+	p.Name = name
+	p.OrigName = name
+	if f != nil {
+		p.field = toField(f)
+	}
+	if tag == "" {
+		return
+	}
+	p.Parse(tag)
+	p.setEncAndDec(typ, f, lockGetProp)
+}
+
+var (
+	propertiesMu  sync.RWMutex
+	propertiesMap = make(map[reflect.Type]*StructProperties)
+)
+
+// GetProperties returns the list of properties for the type represented by t.
+// t must represent a generated struct type of a protocol message.
+func GetProperties(t reflect.Type) *StructProperties {
+	if t.Kind() != reflect.Struct {
+		panic("proto: type must have kind struct")
+	}
+
+	// Most calls to GetProperties in a long-running program will be
+	// retrieving details for types we have seen before.
+	propertiesMu.RLock()
+	sprop, ok := propertiesMap[t]
+	propertiesMu.RUnlock()
+	if ok {
+		if collectStats {
+			stats.Chit++
+		}
+		return sprop
+	}
+
+	propertiesMu.Lock()
+	sprop = getPropertiesLocked(t)
+	propertiesMu.Unlock()
+	return sprop
+}
+
+// getPropertiesLocked requires that propertiesMu is held.
+func getPropertiesLocked(t reflect.Type) *StructProperties {
+	if prop, ok := propertiesMap[t]; ok {
+		if collectStats {
+			stats.Chit++
+		}
+		return prop
+	}
+	if collectStats {
+		stats.Cmiss++
+	}
+
+	prop := new(StructProperties)
+	// in case of recursive protos, fill this in now.
+	propertiesMap[t] = prop
+
+	// build properties
+	prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType)
+	prop.unrecField = invalidField
+	prop.Prop = make([]*Properties, t.NumField())
+	prop.order = make([]int, t.NumField())
+
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		p := new(Properties)
+		name := f.Name
+		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
+
+		if f.Name == "XXX_extensions" { // special case
+			if len(f.Tag.Get("protobuf")) > 0 {
+				p.enc = (*Buffer).enc_ext_slice_byte
+				p.dec = nil // not needed
+				p.size = size_ext_slice_byte
+			} else {
+				p.enc = (*Buffer).enc_map
+				p.dec = nil // not needed
+				p.size = size_map
+			}
+		}
+		if f.Name == "XXX_unrecognized" { // special case
+			prop.unrecField = toField(&f)
+		}
+		prop.Prop[i] = p
+		prop.order[i] = i
+		if debug {
+			print(i, " ", f.Name, " ", t.String(), " ")
+			if p.Tag > 0 {
+				print(p.String())
+			}
+			print("\n")
+		}
+		if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") {
+			fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")
+		}
+	}
+
+	// Re-order prop.order.
+	sort.Sort(prop)
+
+	// build required counts
+	// build tags
+	reqCount := 0
+	prop.decoderOrigNames = make(map[string]int)
+	for i, p := range prop.Prop {
+		if strings.HasPrefix(p.Name, "XXX_") {
+			// Internal fields should not appear in tags/origNames maps.
+			// They are handled specially when encoding and decoding.
+			continue
+		}
+		if p.Required {
+			reqCount++
+		}
+		prop.decoderTags.put(p.Tag, i)
+		prop.decoderOrigNames[p.OrigName] = i
+	}
+	prop.reqCount = reqCount
+
+	return prop
+}
+
+// Return the Properties object for the x[0]'th field of the structure.
+func propByIndex(t reflect.Type, x []int) *Properties {
+	if len(x) != 1 {
+		fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t)
+		return nil
+	}
+	prop := GetProperties(t)
+	return prop.Prop[x[0]]
+}
+
+// Get the address and type of a pointer to a struct from an interface.
+func getbase(pb Message) (t reflect.Type, b structPointer, err error) {
+	if pb == nil {
+		err = ErrNil
+		return
+	}
+	// get the reflect type of the pointer to the struct.
+	t = reflect.TypeOf(pb)
+	// get the address of the struct.
+	value := reflect.ValueOf(pb)
+	b = toStructPointer(value)
+	return
+}
+
+// A global registry of enum types.
+// The generated code will register the generated maps by calling RegisterEnum.
+
+var enumValueMaps = make(map[string]map[string]int32)
+var enumStringMaps = make(map[string]map[int32]string)
+
+// RegisterEnum is called from the generated code to install the enum descriptor
+// maps into the global table to aid parsing text format protocol buffers.
+func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
+	if _, ok := enumValueMaps[typeName]; ok {
+		panic("proto: duplicate enum registered: " + typeName)
+	}
+	enumValueMaps[typeName] = valueMap
+	if _, ok := enumStringMaps[typeName]; ok {
+		panic("proto: duplicate enum registered: " + typeName)
+	}
+	enumStringMaps[typeName] = unusedNameMap
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/properties_gogo.go b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
new file mode 100644
index 00000000..8daf9f77
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+)
+
+func (p *Properties) setCustomEncAndDec(typ reflect.Type) {
+	p.ctype = typ
+	if p.Repeated {
+		p.enc = (*Buffer).enc_custom_slice_bytes
+		p.dec = (*Buffer).dec_custom_slice_bytes
+		p.size = size_custom_slice_bytes
+	} else if typ.Kind() == reflect.Ptr {
+		p.enc = (*Buffer).enc_custom_bytes
+		p.dec = (*Buffer).dec_custom_bytes
+		p.size = size_custom_bytes
+	} else {
+		p.enc = (*Buffer).enc_custom_ref_bytes
+		p.dec = (*Buffer).dec_custom_ref_bytes
+		p.size = size_custom_ref_bytes
+	}
+}
+
+func (p *Properties) setSliceOfNonPointerStructs(typ reflect.Type) {
+	t2 := typ.Elem()
+	p.sstype = typ
+	p.stype = t2
+	p.isMarshaler = isMarshaler(t2)
+	p.isUnmarshaler = isUnmarshaler(t2)
+	p.enc = (*Buffer).enc_slice_ref_struct_message
+	p.dec = (*Buffer).dec_slice_ref_struct_message
+	p.size = size_slice_ref_struct_message
+	if p.Wire != "bytes" {
+		fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T \n", typ, t2)
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.pb.go b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.pb.go
new file mode 100644
index 00000000..2f2da460
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.pb.go
@@ -0,0 +1,122 @@
+// Code generated by protoc-gen-gogo.
+// source: proto3_proto/proto3.proto
+// DO NOT EDIT!
+
+/*
+Package proto3_proto is a generated protocol buffer package.
+
+It is generated from these files:
+	proto3_proto/proto3.proto
+
+It has these top-level messages:
+	Message
+	Nested
+	MessageWithMap
+*/
+package proto3_proto
+
+import proto "github.com/gogo/protobuf/proto"
+import testdata "github.com/gogo/protobuf/proto/testdata"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+
+type Message_Humour int32
+
+const (
+	Message_UNKNOWN     Message_Humour = 0
+	Message_PUNS        Message_Humour = 1
+	Message_SLAPSTICK   Message_Humour = 2
+	Message_BILL_BAILEY Message_Humour = 3
+)
+
+var Message_Humour_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "PUNS",
+	2: "SLAPSTICK",
+	3: "BILL_BAILEY",
+}
+var Message_Humour_value = map[string]int32{
+	"UNKNOWN":     0,
+	"PUNS":        1,
+	"SLAPSTICK":   2,
+	"BILL_BAILEY": 3,
+}
+
+func (x Message_Humour) String() string {
+	return proto.EnumName(Message_Humour_name, int32(x))
+}
+
+type Message struct {
+	Name         string                           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Hilarity     Message_Humour                   `protobuf:"varint,2,opt,name=hilarity,proto3,enum=proto3_proto.Message_Humour" json:"hilarity,omitempty"`
+	HeightInCm   uint32                           `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"`
+	Data         []byte                           `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+	ResultCount  int64                            `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"`
+	TrueScotsman bool                             `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"`
+	Score        float32                          `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"`
+	Key          []uint64                         `protobuf:"varint,5,rep,name=key" json:"key,omitempty"`
+	Nested       *Nested                          `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"`
+	Terrain      map[string]*Nested               `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
+	Proto2Field  *testdata.SubDefaults            `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"`
+	Proto2Value  map[string]*testdata.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+
+func (m *Message) GetNested() *Nested {
+	if m != nil {
+		return m.Nested
+	}
+	return nil
+}
+
+func (m *Message) GetTerrain() map[string]*Nested {
+	if m != nil {
+		return m.Terrain
+	}
+	return nil
+}
+
+func (m *Message) GetProto2Field() *testdata.SubDefaults {
+	if m != nil {
+		return m.Proto2Field
+	}
+	return nil
+}
+
+func (m *Message) GetProto2Value() map[string]*testdata.SubDefaults {
+	if m != nil {
+		return m.Proto2Value
+	}
+	return nil
+}
+
+type Nested struct {
+	Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
+}
+
+func (m *Nested) Reset()         { *m = Nested{} }
+func (m *Nested) String() string { return proto.CompactTextString(m) }
+func (*Nested) ProtoMessage()    {}
+
+type MessageWithMap struct {
+	ByteMapping map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (m *MessageWithMap) Reset()         { *m = MessageWithMap{} }
+func (m *MessageWithMap) String() string { return proto.CompactTextString(m) }
+func (*MessageWithMap) ProtoMessage()    {}
+
+func (m *MessageWithMap) GetByteMapping() map[bool][]byte {
+	if m != nil {
+		return m.ByteMapping
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("proto3_proto.Message_Humour", Message_Humour_name, Message_Humour_value)
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.proto b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.proto
new file mode 100644
index 00000000..ca670015
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/proto3_proto/proto3.proto
@@ -0,0 +1,68 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2014 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package proto3_proto;
+
+import "github.com/gogo/protobuf/proto/testdata/test.proto";
+
+message Message {
+  enum Humour {
+    UNKNOWN = 0;
+    PUNS = 1;
+    SLAPSTICK = 2;
+    BILL_BAILEY = 3;
+  }
+
+  string name = 1;
+  Humour hilarity = 2;
+  uint32 height_in_cm = 3;
+  bytes data = 4;
+  int64 result_count = 7;
+  bool true_scotsman = 8;
+  float score = 9;
+
+  repeated uint64 key = 5;
+  Nested nested = 6;
+
+  map<string, Nested> terrain = 10;
+  testdata.SubDefaults proto2_field = 11;
+  map<string, testdata.SubDefaults> proto2_value = 13;
+}
+
+message Nested {
+  string bunny = 1;
+}
+
+message MessageWithMap {
+  map<bool, bytes> byte_mapping = 1;
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/skip_gogo.go b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
new file mode 100644
index 00000000..d8683c8e
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
@@ -0,0 +1,117 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"io"
+)
+
+func Skip(data []byte) (n int, err error) {
+	l := len(data)
+	index := 0
+	for index < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if index >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := data[index]
+			index++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for {
+				if index >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				index++
+				if data[index-1] < 0x80 {
+					break
+				}
+			}
+			return index, nil
+		case 1:
+			index += 8
+			return index, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if index >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := data[index]
+				index++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			index += length
+			return index, nil
+		case 3:
+			for {
+				var wire uint64
+				var start int = index
+				for shift := uint(0); ; shift += 7 {
+					if index >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := data[index]
+					index++
+					wire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				wireType := int(wire & 0x7)
+				if wireType == 4 {
+					break
+				}
+				next, err := Skip(data[start:])
+				if err != nil {
+					return 0, err
+				}
+				index = start + next
+			}
+			return index, nil
+		case 4:
+			return index, nil
+		case 5:
+			index += 4
+			return index, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/text.go b/vendor/github.com/gogo/protobuf/proto/text.go
new file mode 100644
index 00000000..9f13e1d5
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text.go
@@ -0,0 +1,824 @@
+// Extensions for Protocol Buffers to create more go like structures.
+//
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for writing the text protocol buffer format.
+
+import (
+	"bufio"
+	"bytes"
+	"encoding"
+	"fmt"
+	"io"
+	"log"
+	"math"
+	"os"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+var (
+	newline         = []byte("\n")
+	spaces          = []byte("                                        ")
+	gtNewline       = []byte(">\n")
+	endBraceNewline = []byte("}\n")
+	backslashN      = []byte{'\\', 'n'}
+	backslashR      = []byte{'\\', 'r'}
+	backslashT      = []byte{'\\', 't'}
+	backslashDQ     = []byte{'\\', '"'}
+	backslashBS     = []byte{'\\', '\\'}
+	posInf          = []byte("inf")
+	negInf          = []byte("-inf")
+	nan             = []byte("nan")
+)
+
+type writer interface {
+	io.Writer
+	WriteByte(byte) error
+}
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+	ind      int
+	complete bool // if the current position is a complete line
+	compact  bool // whether to write out as a one-liner
+	w        writer
+}
+
+func (w *textWriter) WriteString(s string) (n int, err error) {
+	if !strings.Contains(s, "\n") {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		w.complete = false
+		return io.WriteString(w.w, s)
+	}
+	// WriteString is typically called without newlines, so this
+	// codepath and its copy are rare.  We copy to avoid
+	// duplicating all of Write's logic here.
+	return w.Write([]byte(s))
+}
+
+func (w *textWriter) Write(p []byte) (n int, err error) {
+	newlines := bytes.Count(p, newline)
+	if newlines == 0 {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		n, err = w.w.Write(p)
+		w.complete = false
+		return n, err
+	}
+
+	frags := bytes.SplitN(p, newline, newlines+1)
+	if w.compact {
+		for i, frag := range frags {
+			if i > 0 {
+				if err := w.w.WriteByte(' '); err != nil {
+					return n, err
+				}
+				n++
+			}
+			nn, err := w.w.Write(frag)
+			n += nn
+			if err != nil {
+				return n, err
+			}
+		}
+		return n, nil
+	}
+
+	for i, frag := range frags {
+		if w.complete {
+			w.writeIndent()
+		}
+		nn, err := w.w.Write(frag)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+		if i+1 < len(frags) {
+			if err := w.w.WriteByte('\n'); err != nil {
+				return n, err
+			}
+			n++
+		}
+	}
+	w.complete = len(frags[len(frags)-1]) == 0
+	return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+	if w.compact && c == '\n' {
+		c = ' '
+	}
+	if !w.compact && w.complete {
+		w.writeIndent()
+	}
+	err := w.w.WriteByte(c)
+	w.complete = c == '\n'
+	return err
+}
+
+func (w *textWriter) indent() { w.ind++ }
+
+func (w *textWriter) unindent() {
+	if w.ind == 0 {
+		log.Printf("proto: textWriter unindented too far")
+		return
+	}
+	w.ind--
+}
+
+func writeName(w *textWriter, props *Properties) error {
+	if _, err := w.WriteString(props.OrigName); err != nil {
+		return err
+	}
+	if props.Wire != "group" {
+		return w.WriteByte(':')
+	}
+	return nil
+}
+
+var (
+	messageSetType = reflect.TypeOf((*MessageSet)(nil)).Elem()
+)
+
+// raw is the interface satisfied by RawMessage.
+type raw interface {
+	Bytes() []byte
+}
+
+func writeStruct(w *textWriter, sv reflect.Value) error {
+	if sv.Type() == messageSetType {
+		return writeMessageSet(w, sv.Addr().Interface().(*MessageSet))
+	}
+
+	st := sv.Type()
+	sprops := GetProperties(st)
+	for i := 0; i < sv.NumField(); i++ {
+		fv := sv.Field(i)
+		props := sprops.Prop[i]
+		name := st.Field(i).Name
+
+		if strings.HasPrefix(name, "XXX_") {
+			// There are two XXX_ fields:
+			//   XXX_unrecognized []byte
+			//   XXX_extensions   map[int32]proto.Extension
+			// The first is handled here;
+			// the second is handled at the bottom of this function.
+			if name == "XXX_unrecognized" && !fv.IsNil() {
+				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if fv.Kind() == reflect.Ptr && fv.IsNil() {
+			// Field not filled in. This could be an optional field or
+			// a required field that wasn't filled in. Either way, there
+			// isn't anything we can show for it.
+			continue
+		}
+		if fv.Kind() == reflect.Slice && fv.IsNil() {
+			// Repeated field that is empty, or a bytes field that is unused.
+			continue
+		}
+
+		if props.Repeated && fv.Kind() == reflect.Slice {
+			// Repeated field.
+			for j := 0; j < fv.Len(); j++ {
+				if err := writeName(w, props); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				v := fv.Index(j)
+				if v.Kind() == reflect.Ptr && v.IsNil() {
+					// A nil message in a repeated field is not valid,
+					// but we can handle that more gracefully than panicking.
+					if _, err := w.Write([]byte("<nil>\n")); err != nil {
+						return err
+					}
+					continue
+				}
+				if len(props.Enum) > 0 {
+					if err := writeEnum(w, v, props); err != nil {
+						return err
+					}
+				} else if err := writeAny(w, v, props); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if fv.Kind() == reflect.Map {
+			// Map fields are rendered as a repeated struct with key/value fields.
+			keys := fv.MapKeys() // TODO: should we sort these for deterministic output?
+			sort.Sort(mapKeys(keys))
+			for _, key := range keys {
+				val := fv.MapIndex(key)
+				if err := writeName(w, props); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				// open struct
+				if err := w.WriteByte('<'); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte('\n'); err != nil {
+						return err
+					}
+				}
+				w.indent()
+				// key
+				if _, err := w.WriteString("key:"); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				if err := writeAny(w, key, props.mkeyprop); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+				// value
+				if _, err := w.WriteString("value:"); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				if err := writeAny(w, val, props.mvalprop); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+				// close struct
+				w.unindent()
+				if err := w.WriteByte('>'); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
+			// empty bytes field
+			continue
+		}
+		if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+			// proto3 non-repeated scalar field; skip if zero value
+			switch fv.Kind() {
+			case reflect.Bool:
+				if !fv.Bool() {
+					continue
+				}
+			case reflect.Int32, reflect.Int64:
+				if fv.Int() == 0 {
+					continue
+				}
+			case reflect.Uint32, reflect.Uint64:
+				if fv.Uint() == 0 {
+					continue
+				}
+			case reflect.Float32, reflect.Float64:
+				if fv.Float() == 0 {
+					continue
+				}
+			case reflect.String:
+				if fv.String() == "" {
+					continue
+				}
+			}
+		}
+
+		if err := writeName(w, props); err != nil {
+			return err
+		}
+		if !w.compact {
+			if err := w.WriteByte(' '); err != nil {
+				return err
+			}
+		}
+		if b, ok := fv.Interface().(raw); ok {
+			if err := writeRaw(w, b.Bytes()); err != nil {
+				return err
+			}
+			continue
+		}
+
+		if len(props.Enum) > 0 {
+			if err := writeEnum(w, fv, props); err != nil {
+				return err
+			}
+		} else if err := writeAny(w, fv, props); err != nil {
+			return err
+		}
+
+		if err := w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+
+	// Extensions (the XXX_extensions field).
+	pv := sv.Addr()
+	if pv.Type().Implements(extendableProtoType) {
+		if err := writeExtensions(w, pv); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// writeRaw writes an uninterpreted raw message.
+func writeRaw(w *textWriter, b []byte) error {
+	if err := w.WriteByte('<'); err != nil {
+		return err
+	}
+	if !w.compact {
+		if err := w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+	w.indent()
+	if err := writeUnknownStruct(w, b); err != nil {
+		return err
+	}
+	w.unindent()
+	if err := w.WriteByte('>'); err != nil {
+		return err
+	}
+	return nil
+}
+
+// writeAny writes an arbitrary field.
+func writeAny(w *textWriter, v reflect.Value, props *Properties) error {
+	v = reflect.Indirect(v)
+
+	if props != nil && len(props.CustomType) > 0 {
+		var custom Marshaler = v.Interface().(Marshaler)
+		data, err := custom.Marshal()
+		if err != nil {
+			return err
+		}
+		if err := writeString(w, string(data)); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	// Floats have special cases.
+	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+		x := v.Float()
+		var b []byte
+		switch {
+		case math.IsInf(x, 1):
+			b = posInf
+		case math.IsInf(x, -1):
+			b = negInf
+		case math.IsNaN(x):
+			b = nan
+		}
+		if b != nil {
+			_, err := w.Write(b)
+			return err
+		}
+		// Other values are handled below.
+	}
+
+	// We don't attempt to serialise every possible value type; only those
+	// that can occur in protocol buffers.
+	switch v.Kind() {
+	case reflect.Slice:
+		// Should only be a []byte; repeated fields are handled in writeStruct.
+		if err := writeString(w, string(v.Interface().([]byte))); err != nil {
+			return err
+		}
+	case reflect.String:
+		if err := writeString(w, v.String()); err != nil {
+			return err
+		}
+	case reflect.Struct:
+		// Required/optional group/message.
+		var bra, ket byte = '<', '>'
+		if props != nil && props.Wire == "group" {
+			bra, ket = '{', '}'
+		}
+		if err := w.WriteByte(bra); err != nil {
+			return err
+		}
+		if !w.compact {
+			if err := w.WriteByte('\n'); err != nil {
+				return err
+			}
+		}
+		w.indent()
+		if tm, ok := v.Interface().(encoding.TextMarshaler); ok {
+			text, err := tm.MarshalText()
+			if err != nil {
+				return err
+			}
+			if _, err = w.Write(text); err != nil {
+				return err
+			}
+		} else if err := writeStruct(w, v); err != nil {
+			return err
+		}
+		w.unindent()
+		if err := w.WriteByte(ket); err != nil {
+			return err
+		}
+	default:
+		_, err := fmt.Fprint(w, v.Interface())
+		return err
+	}
+	return nil
+}
+
+// equivalent to C's isprint.
+func isprint(c byte) bool {
+	return c >= 0x20 && c < 0x7f
+}
+
+// writeString writes a string in the protocol buffer text format.
+// It is similar to strconv.Quote except we don't use Go escape sequences,
+// we treat the string as a byte sequence, and we use octal escapes.
+// These differences are to maintain interoperability with the other
+// languages' implementations of the text format.
+func writeString(w *textWriter, s string) error {
+	// use WriteByte here to get any needed indent
+	if err := w.WriteByte('"'); err != nil {
+		return err
+	}
+	// Loop over the bytes, not the runes.
+	for i := 0; i < len(s); i++ {
+		var err error
+		// Divergence from C++: we don't escape apostrophes.
+		// There's no need to escape them, and the C++ parser
+		// copes with a naked apostrophe.
+		switch c := s[i]; c {
+		case '\n':
+			_, err = w.w.Write(backslashN)
+		case '\r':
+			_, err = w.w.Write(backslashR)
+		case '\t':
+			_, err = w.w.Write(backslashT)
+		case '"':
+			_, err = w.w.Write(backslashDQ)
+		case '\\':
+			_, err = w.w.Write(backslashBS)
+		default:
+			if isprint(c) {
+				err = w.w.WriteByte(c)
+			} else {
+				_, err = fmt.Fprintf(w.w, "\\%03o", c)
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return w.WriteByte('"')
+}
+
+func writeMessageSet(w *textWriter, ms *MessageSet) error {
+	for _, item := range ms.Item {
+		id := *item.TypeId
+		if msd, ok := messageSetMap[id]; ok {
+			// Known message set type.
+			if _, err := fmt.Fprintf(w, "[%s]: <\n", msd.name); err != nil {
+				return err
+			}
+			w.indent()
+
+			pb := reflect.New(msd.t.Elem())
+			if err := Unmarshal(item.Message, pb.Interface().(Message)); err != nil {
+				if _, err := fmt.Fprintf(w, "/* bad message: %v */\n", err); err != nil {
+					return err
+				}
+			} else {
+				if err := writeStruct(w, pb.Elem()); err != nil {
+					return err
+				}
+			}
+		} else {
+			// Unknown type.
+			if _, err := fmt.Fprintf(w, "[%d]: <\n", id); err != nil {
+				return err
+			}
+			w.indent()
+			if err := writeUnknownStruct(w, item.Message); err != nil {
+				return err
+			}
+		}
+		w.unindent()
+		if _, err := w.Write(gtNewline); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func writeUnknownStruct(w *textWriter, data []byte) (err error) {
+	if !w.compact {
+		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
+			return err
+		}
+	}
+	b := NewBuffer(data)
+	for b.index < len(b.buf) {
+		x, err := b.DecodeVarint()
+		if err != nil {
+			_, err := fmt.Fprintf(w, "/* %v */\n", err)
+			return err
+		}
+		wire, tag := x&7, x>>3
+		if wire == WireEndGroup {
+			w.unindent()
+			if _, err := w.Write(endBraceNewline); err != nil {
+				return err
+			}
+			continue
+		}
+		if _, err := fmt.Fprint(w, tag); err != nil {
+			return err
+		}
+		if wire != WireStartGroup {
+			if err := w.WriteByte(':'); err != nil {
+				return err
+			}
+		}
+		if !w.compact || wire == WireStartGroup {
+			if err := w.WriteByte(' '); err != nil {
+				return err
+			}
+		}
+		switch wire {
+		case WireBytes:
+			buf, e := b.DecodeRawBytes(false)
+			if e == nil {
+				_, err = fmt.Fprintf(w, "%q", buf)
+			} else {
+				_, err = fmt.Fprintf(w, "/* %v */", e)
+			}
+		case WireFixed32:
+			x, err = b.DecodeFixed32()
+			err = writeUnknownInt(w, x, err)
+		case WireFixed64:
+			x, err = b.DecodeFixed64()
+			err = writeUnknownInt(w, x, err)
+		case WireStartGroup:
+			err = w.WriteByte('{')
+			w.indent()
+		case WireVarint:
+			x, err = b.DecodeVarint()
+			err = writeUnknownInt(w, x, err)
+		default:
+			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
+		}
+		if err != nil {
+			return err
+		}
+		if err = w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func writeUnknownInt(w *textWriter, x uint64, err error) error {
+	if err == nil {
+		_, err = fmt.Fprint(w, x)
+	} else {
+		_, err = fmt.Fprintf(w, "/* %v */", err)
+	}
+	return err
+}
+
+type int32Slice []int32
+
+func (s int32Slice) Len() int           { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// writeExtensions writes all the extensions in pv.
+// pv is assumed to be a pointer to a protocol message struct that is extendable.
+func writeExtensions(w *textWriter, pv reflect.Value) error {
+	emap := extensionMaps[pv.Type().Elem()]
+	ep := pv.Interface().(extendableProto)
+
+	// Order the extensions by ID.
+	// This isn't strictly necessary, but it will give us
+	// canonical output, which will also make testing easier.
+	var m map[int32]Extension
+	if em, ok := ep.(extensionsMap); ok {
+		m = em.ExtensionMap()
+	} else if em, ok := ep.(extensionsBytes); ok {
+		eb := em.GetExtensions()
+		var err error
+		m, err = BytesToExtensionsMap(*eb)
+		if err != nil {
+			return err
+		}
+	}
+
+	ids := make([]int32, 0, len(m))
+	for id := range m {
+		ids = append(ids, id)
+	}
+	sort.Sort(int32Slice(ids))
+
+	for _, extNum := range ids {
+		ext := m[extNum]
+		var desc *ExtensionDesc
+		if emap != nil {
+			desc = emap[extNum]
+		}
+		if desc == nil {
+			// Unknown extension.
+			if err := writeUnknownStruct(w, ext.enc); err != nil {
+				return err
+			}
+			continue
+		}
+
+		pb, err := GetExtension(ep, desc)
+		if err != nil {
+			if _, err := fmt.Fprintln(os.Stderr, "proto: failed getting extension: ", err); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// Repeated extensions will appear as a slice.
+		if !desc.repeated() {
+			if err := writeExtension(w, desc.Name, pb); err != nil {
+				return err
+			}
+		} else {
+			v := reflect.ValueOf(pb)
+			for i := 0; i < v.Len(); i++ {
+				if err := writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func writeExtension(w *textWriter, name string, pb interface{}) error {
+	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
+		return err
+	}
+	if !w.compact {
+		if err := w.WriteByte(' '); err != nil {
+			return err
+		}
+	}
+	if err := writeAny(w, reflect.ValueOf(pb), nil); err != nil {
+		return err
+	}
+	if err := w.WriteByte('\n'); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (w *textWriter) writeIndent() {
+	if !w.complete {
+		return
+	}
+	remain := w.ind * 2
+	for remain > 0 {
+		n := remain
+		if n > len(spaces) {
+			n = len(spaces)
+		}
+		w.w.Write(spaces[:n])
+		remain -= n
+	}
+	w.complete = false
+}
+
+func marshalText(w io.Writer, pb Message, compact bool) error {
+	val := reflect.ValueOf(pb)
+	if pb == nil || val.IsNil() {
+		w.Write([]byte("<nil>"))
+		return nil
+	}
+	var bw *bufio.Writer
+	ww, ok := w.(writer)
+	if !ok {
+		bw = bufio.NewWriter(w)
+		ww = bw
+	}
+	aw := &textWriter{
+		w:        ww,
+		complete: true,
+		compact:  compact,
+	}
+
+	if tm, ok := pb.(encoding.TextMarshaler); ok {
+		text, err := tm.MarshalText()
+		if err != nil {
+			return err
+		}
+		if _, err = aw.Write(text); err != nil {
+			return err
+		}
+		if bw != nil {
+			return bw.Flush()
+		}
+		return nil
+	}
+	// Dereference the received pointer so we don't have outer < and >.
+	v := reflect.Indirect(val)
+	if err := writeStruct(aw, v); err != nil {
+		return err
+	}
+	if bw != nil {
+		return bw.Flush()
+	}
+	return nil
+}
+
+// MarshalText writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func MarshalText(w io.Writer, pb Message) error {
+	return marshalText(w, pb, false)
+}
+
+// MarshalTextString is the same as MarshalText, but returns the string directly.
+func MarshalTextString(pb Message) string {
+	var buf bytes.Buffer
+	marshalText(&buf, pb, false)
+	return buf.String()
+}
+
+// CompactText writes a given protocol buffer in compact text format (one line).
+func CompactText(w io.Writer, pb Message) error { return marshalText(w, pb, true) }
+
+// CompactTextString is the same as CompactText, but returns the string directly.
+func CompactTextString(pb Message) string {
+	var buf bytes.Buffer
+	marshalText(&buf, pb, true)
+	return buf.String()
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/text_gogo.go b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
new file mode 100644
index 00000000..cdb23373
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
@@ -0,0 +1,55 @@
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func writeEnum(w *textWriter, v reflect.Value, props *Properties) error {
+	m, ok := enumStringMaps[props.Enum]
+	if !ok {
+		if err := writeAny(w, v, props); err != nil {
+			return err
+		}
+	}
+	key := int32(0)
+	if v.Kind() == reflect.Ptr {
+		key = int32(v.Elem().Int())
+	} else {
+		key = int32(v.Int())
+	}
+	s, ok := m[key]
+	if !ok {
+		if err := writeAny(w, v, props); err != nil {
+			return err
+		}
+	}
+	_, err := fmt.Fprint(w, s)
+	return err
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/text_parser.go b/vendor/github.com/gogo/protobuf/proto/text_parser.go
new file mode 100644
index 00000000..f769937b
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_parser.go
@@ -0,0 +1,800 @@
+// Extensions for Protocol Buffers to create more go like structures.
+//
+// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.
+// http://github.com/gogo/protobuf/gogoproto
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for parsing the Text protocol buffer format.
+// TODO: message sets.
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+type ParseError struct {
+	Message string
+	Line    int // 1-based line number
+	Offset  int // 0-based byte offset from start of input
+}
+
+func (p *ParseError) Error() string {
+	if p.Line == 1 {
+		// show offset only for first line
+		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
+	}
+	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
+}
+
+type token struct {
+	value    string
+	err      *ParseError
+	line     int    // line number
+	offset   int    // byte number from start of input, not start of line
+	unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func (t *token) String() string {
+	if t.err == nil {
+		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
+	}
+	return fmt.Sprintf("parse error: %v", t.err)
+}
+
+type textParser struct {
+	s            string // remaining input
+	done         bool   // whether the parsing is finished (success or error)
+	backed       bool   // whether back() was called
+	offset, line int
+	cur          token
+}
+
+func newTextParser(s string) *textParser {
+	p := new(textParser)
+	p.s = s
+	p.line = 1
+	p.cur.line = 1
+	return p
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+	p.cur.err = pe
+	p.done = true
+	return pe
+}
+
+// Numbers and identifiers are matched by [-+._A-Za-z0-9]
+func isIdentOrNumberChar(c byte) bool {
+	switch {
+	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+		return true
+	case '0' <= c && c <= '9':
+		return true
+	}
+	switch c {
+	case '-', '+', '.', '_':
+		return true
+	}
+	return false
+}
+
+func isWhitespace(c byte) bool {
+	switch c {
+	case ' ', '\t', '\n', '\r':
+		return true
+	}
+	return false
+}
+
+func (p *textParser) skipWhitespace() {
+	i := 0
+	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+		if p.s[i] == '#' {
+			// comment; skip to end of line or input
+			for i < len(p.s) && p.s[i] != '\n' {
+				i++
+			}
+			if i == len(p.s) {
+				break
+			}
+		}
+		if p.s[i] == '\n' {
+			p.line++
+		}
+		i++
+	}
+	p.offset += i
+	p.s = p.s[i:len(p.s)]
+	if len(p.s) == 0 {
+		p.done = true
+	}
+}
+
+func (p *textParser) advance() {
+	// Skip whitespace
+	p.skipWhitespace()
+	if p.done {
+		return
+	}
+
+	// Start of non-whitespace
+	p.cur.err = nil
+	p.cur.offset, p.cur.line = p.offset, p.line
+	p.cur.unquoted = ""
+	switch p.s[0] {
+	case '<', '>', '{', '}', ':', '[', ']', ';', ',':
+		// Single symbol
+		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+	case '"', '\'':
+		// Quoted string
+		i := 1
+		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+			if p.s[i] == '\\' && i+1 < len(p.s) {
+				// skip escaped char
+				i++
+			}
+			i++
+		}
+		if i >= len(p.s) || p.s[i] != p.s[0] {
+			p.errorf("unmatched quote")
+			return
+		}
+		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+		if err != nil {
+			p.errorf("invalid quoted string %v", p.s[0:i+1])
+			return
+		}
+		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+		p.cur.unquoted = unq
+	default:
+		i := 0
+		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+			i++
+		}
+		if i == 0 {
+			p.errorf("unexpected byte %#x", p.s[0])
+			return
+		}
+		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+	}
+	p.offset += len(p.cur.value)
+}
+
+var (
+	errBadUTF8 = errors.New("proto: bad UTF-8")
+	errBadHex  = errors.New("proto: bad hexadecimal")
+)
+
+func unquoteC(s string, quote rune) (string, error) {
+	// This is based on C++'s tokenizer.cc.
+	// Despite its name, this is *not* parsing C syntax.
+	// For instance, "\0" is an invalid quoted string.
+
+	// Avoid allocation in trivial cases.
+	simple := true
+	for _, r := range s {
+		if r == '\\' || r == quote {
+			simple = false
+			break
+		}
+	}
+	if simple {
+		return s, nil
+	}
+
+	buf := make([]byte, 0, 3*len(s)/2)
+	for len(s) > 0 {
+		r, n := utf8.DecodeRuneInString(s)
+		if r == utf8.RuneError && n == 1 {
+			return "", errBadUTF8
+		}
+		s = s[n:]
+		if r != '\\' {
+			if r < utf8.RuneSelf {
+				buf = append(buf, byte(r))
+			} else {
+				buf = append(buf, string(r)...)
+			}
+			continue
+		}
+
+		ch, tail, err := unescape(s)
+		if err != nil {
+			return "", err
+		}
+		buf = append(buf, ch...)
+		s = tail
+	}
+	return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+	r, n := utf8.DecodeRuneInString(s)
+	if r == utf8.RuneError && n == 1 {
+		return "", "", errBadUTF8
+	}
+	s = s[n:]
+	switch r {
+	case 'a':
+		return "\a", s, nil
+	case 'b':
+		return "\b", s, nil
+	case 'f':
+		return "\f", s, nil
+	case 'n':
+		return "\n", s, nil
+	case 'r':
+		return "\r", s, nil
+	case 't':
+		return "\t", s, nil
+	case 'v':
+		return "\v", s, nil
+	case '?':
+		return "?", s, nil // trigraph workaround
+	case '\'', '"', '\\':
+		return string(r), s, nil
+	case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X':
+		if len(s) < 2 {
+			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+		}
+		base := 8
+		ss := s[:2]
+		s = s[2:]
+		if r == 'x' || r == 'X' {
+			base = 16
+		} else {
+			ss = string(r) + ss
+		}
+		i, err := strconv.ParseUint(ss, base, 8)
+		if err != nil {
+			return "", "", err
+		}
+		return string([]byte{byte(i)}), s, nil
+	case 'u', 'U':
+		n := 4
+		if r == 'U' {
+			n = 8
+		}
+		if len(s) < n {
+			return "", "", fmt.Errorf(`\%c requires %d digits`, r, n)
+		}
+
+		bs := make([]byte, n/2)
+		for i := 0; i < n; i += 2 {
+			a, ok1 := unhex(s[i])
+			b, ok2 := unhex(s[i+1])
+			if !ok1 || !ok2 {
+				return "", "", errBadHex
+			}
+			bs[i/2] = a<<4 | b
+		}
+		s = s[n:]
+		return string(bs), s, nil
+	}
+	return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+// Adapted from src/pkg/strconv/quote.go.
+func unhex(b byte) (v byte, ok bool) {
+	switch {
+	case '0' <= b && b <= '9':
+		return b - '0', true
+	case 'a' <= b && b <= 'f':
+		return b - 'a' + 10, true
+	case 'A' <= b && b <= 'F':
+		return b - 'A' + 10, true
+	}
+	return 0, false
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+	if p.backed || p.done {
+		p.backed = false
+		return &p.cur
+	}
+	p.advance()
+	if p.done {
+		p.cur.value = ""
+	} else if len(p.cur.value) > 0 && p.cur.value[0] == '"' {
+		// Look for multiple quoted strings separated by whitespace,
+		// and concatenate them.
+		cat := p.cur
+		for {
+			p.skipWhitespace()
+			if p.done || p.s[0] != '"' {
+				break
+			}
+			p.advance()
+			if p.cur.err != nil {
+				return &p.cur
+			}
+			cat.value += " " + p.cur.value
+			cat.unquoted += p.cur.unquoted
+		}
+		p.done = false // parser may have seen EOF, but we want to return cat
+		p.cur = cat
+	}
+	return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != s {
+		p.back()
+		return p.errorf("expected %q, found %q", s, tok.value)
+	}
+	return nil
+}
+
+// Return a RequiredNotSetError indicating which required field was not set.
+func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
+	st := sv.Type()
+	sprops := GetProperties(st)
+	for i := 0; i < st.NumField(); i++ {
+		if !isNil(sv.Field(i)) {
+			continue
+		}
+
+		props := sprops.Prop[i]
+		if props.Required {
+			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
+		}
+	}
+	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
+}
+
+// Returns the index in the struct for the named field, as well as the parsed tag properties.
+func structFieldByName(st reflect.Type, name string) (int, *Properties, bool) {
+	sprops := GetProperties(st)
+	i, ok := sprops.decoderOrigNames[name]
+	if ok {
+		return i, sprops.Prop[i], true
+	}
+	return -1, nil, false
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ":" {
+		// Colon is optional when the field is a group or message.
+		needColon := true
+		switch props.Wire {
+		case "group":
+			needColon = false
+		case "bytes":
+			// A "bytes" field is either a message, a string, or a repeated field;
+			// those three become *T, *string and []T respectively, so we can check for
+			// this field being a pointer to a non-string.
+			if typ.Kind() == reflect.Ptr {
+				// *T or *string
+				if typ.Elem().Kind() == reflect.String {
+					break
+				}
+			} else if typ.Kind() == reflect.Slice {
+				// []T or []*T
+				if typ.Elem().Kind() != reflect.Ptr {
+					break
+				}
+			} else if typ.Kind() == reflect.String {
+				// The proto3 exception is for a string field,
+				// which requires a colon.
+				break
+			}
+			needColon = false
+		}
+		if needColon {
+			return p.errorf("expected ':', found %q", tok.value)
+		}
+		p.back()
+	}
+	return nil
+}
+
+func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
+	st := sv.Type()
+	reqCount := GetProperties(st).reqCount
+	var reqFieldErr error
+	fieldSet := make(map[string]bool)
+	// A struct is a sequence of "name: value", terminated by one of
+	// '>' or '}', or the end of the input.  A name may also be
+	// "[extension]".
+	for {
+		tok := p.next()
+		if tok.err != nil {
+			return tok.err
+		}
+		if tok.value == terminator {
+			break
+		}
+		if tok.value == "[" {
+			// Looks like an extension.
+			//
+			// TODO: Check whether we need to handle
+			// namespace rooted names (e.g. ".something.Foo").
+			tok = p.next()
+			if tok.err != nil {
+				return tok.err
+			}
+			var desc *ExtensionDesc
+			// This could be faster, but it's functional.
+			// TODO: Do something smarter than a linear scan.
+			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
+				if d.Name == tok.value {
+					desc = d
+					break
+				}
+			}
+			if desc == nil {
+				return p.errorf("unrecognized extension %q", tok.value)
+			}
+			// Check the extension terminator.
+			tok = p.next()
+			if tok.err != nil {
+				return tok.err
+			}
+			if tok.value != "]" {
+				return p.errorf("unrecognized extension terminator %q", tok.value)
+			}
+
+			props := &Properties{}
+			props.Parse(desc.Tag)
+
+			typ := reflect.TypeOf(desc.ExtensionType)
+			if err := p.checkForColon(props, typ); err != nil {
+				return err
+			}
+
+			rep := desc.repeated()
+
+			// Read the extension structure, and set it in
+			// the value we're constructing.
+			var ext reflect.Value
+			if !rep {
+				ext = reflect.New(typ).Elem()
+			} else {
+				ext = reflect.New(typ.Elem()).Elem()
+			}
+			if err := p.readAny(ext, props); err != nil {
+				if _, ok := err.(*RequiredNotSetError); !ok {
+					return err
+				}
+				reqFieldErr = err
+			}
+			ep := sv.Addr().Interface().(extendableProto)
+			if !rep {
+				SetExtension(ep, desc, ext.Interface())
+			} else {
+				old, err := GetExtension(ep, desc)
+				var sl reflect.Value
+				if err == nil {
+					sl = reflect.ValueOf(old) // existing slice
+				} else {
+					sl = reflect.MakeSlice(typ, 0, 1)
+				}
+				sl = reflect.Append(sl, ext)
+				SetExtension(ep, desc, sl.Interface())
+			}
+		} else {
+			// This is a normal, non-extension field.
+			name := tok.value
+			fi, props, ok := structFieldByName(st, name)
+			if !ok {
+				return p.errorf("unknown field name %q in %v", name, st)
+			}
+
+			dst := sv.Field(fi)
+
+			if dst.Kind() == reflect.Map {
+				// Consume any colon.
+				if err := p.checkForColon(props, dst.Type()); err != nil {
+					return err
+				}
+
+				// Construct the map if it doesn't already exist.
+				if dst.IsNil() {
+					dst.Set(reflect.MakeMap(dst.Type()))
+				}
+				key := reflect.New(dst.Type().Key()).Elem()
+				val := reflect.New(dst.Type().Elem()).Elem()
+
+				// The map entry should be this sequence of tokens:
+				//	< key : KEY value : VALUE >
+				// Technically the "key" and "value" could come in any order,
+				// but in practice they won't.
+
+				tok := p.next()
+				var terminator string
+				switch tok.value {
+				case "<":
+					terminator = ">"
+				case "{":
+					terminator = "}"
+				default:
+					return p.errorf("expected '{' or '<', found %q", tok.value)
+				}
+				if err := p.consumeToken("key"); err != nil {
+					return err
+				}
+				if err := p.consumeToken(":"); err != nil {
+					return err
+				}
+				if err := p.readAny(key, props.mkeyprop); err != nil {
+					return err
+				}
+				if err := p.consumeToken("value"); err != nil {
+					return err
+				}
+				if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
+					return err
+				}
+				if err := p.readAny(val, props.mvalprop); err != nil {
+					return err
+				}
+				if err := p.consumeToken(terminator); err != nil {
+					return err
+				}
+
+				dst.SetMapIndex(key, val)
+				continue
+			}
+
+			// Check that it's not already set if it's not a repeated field.
+			if !props.Repeated && fieldSet[name] {
+				return p.errorf("non-repeated field %q was repeated", name)
+			}
+
+			if err := p.checkForColon(props, st.Field(fi).Type); err != nil {
+				return err
+			}
+
+			// Parse into the field.
+			fieldSet[name] = true
+			if err := p.readAny(dst, props); err != nil {
+				if _, ok := err.(*RequiredNotSetError); !ok {
+					return err
+				}
+				reqFieldErr = err
+			} else if props.Required {
+				reqCount--
+			}
+		}
+
+		// For backward compatibility, permit a semicolon or comma after a field.
+		tok = p.next()
+		if tok.err != nil {
+			return tok.err
+		}
+		if tok.value != ";" && tok.value != "," {
+			p.back()
+		}
+	}
+
+	if reqCount > 0 {
+		return p.missingRequiredFieldError(sv)
+	}
+	return reqFieldErr
+}
+
+func (p *textParser) readAny(v reflect.Value, props *Properties) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value == "" {
+		return p.errorf("unexpected EOF")
+	}
+	if len(props.CustomType) > 0 {
+		if props.Repeated {
+			t := reflect.TypeOf(v.Interface())
+			if t.Kind() == reflect.Slice {
+				tc := reflect.TypeOf(new(Marshaler))
+				ok := t.Elem().Implements(tc.Elem())
+				if ok {
+					fv := v
+					flen := fv.Len()
+					if flen == fv.Cap() {
+						nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1)
+						reflect.Copy(nav, fv)
+						fv.Set(nav)
+					}
+					fv.SetLen(flen + 1)
+
+					// Read one.
+					p.back()
+					return p.readAny(fv.Index(flen), props)
+				}
+			}
+		}
+		if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+			custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler)
+			err := custom.Unmarshal([]byte(tok.unquoted))
+			if err != nil {
+				return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+			}
+			v.Set(reflect.ValueOf(custom))
+		} else {
+			custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler)
+			err := custom.Unmarshal([]byte(tok.unquoted))
+			if err != nil {
+				return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+			}
+			v.Set(reflect.Indirect(reflect.ValueOf(custom)))
+		}
+		return nil
+	}
+	switch fv := v; fv.Kind() {
+	case reflect.Slice:
+		at := v.Type()
+		if at.Elem().Kind() == reflect.Uint8 {
+			// Special case for []byte
+			if tok.value[0] != '"' && tok.value[0] != '\'' {
+				// Deliberately written out here, as the error after
+				// this switch statement would write "invalid []byte: ...",
+				// which is not as user-friendly.
+				return p.errorf("invalid string: %v", tok.value)
+			}
+			bytes := []byte(tok.unquoted)
+			fv.Set(reflect.ValueOf(bytes))
+			return nil
+		}
+		// Repeated field. May already exist.
+		flen := fv.Len()
+		if flen == fv.Cap() {
+			nav := reflect.MakeSlice(at, flen, 2*flen+1)
+			reflect.Copy(nav, fv)
+			fv.Set(nav)
+		}
+		fv.SetLen(flen + 1)
+
+		// Read one.
+		p.back()
+		return p.readAny(fv.Index(flen), props)
+	case reflect.Bool:
+		// Either "true", "false", 1 or 0.
+		switch tok.value {
+		case "true", "1":
+			fv.SetBool(true)
+			return nil
+		case "false", "0":
+			fv.SetBool(false)
+			return nil
+		}
+	case reflect.Float32, reflect.Float64:
+		v := tok.value
+		// Ignore 'f' for compatibility with output generated by C++, but don't
+		// remove 'f' when the value is "-inf" or "inf".
+		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
+			v = v[:len(v)-1]
+		}
+		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
+			fv.SetFloat(f)
+			return nil
+		}
+	case reflect.Int32:
+		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+			fv.SetInt(x)
+			return nil
+		}
+
+		if len(props.Enum) == 0 {
+			break
+		}
+		m, ok := enumValueMaps[props.Enum]
+		if !ok {
+			break
+		}
+		x, ok := m[tok.value]
+		if !ok {
+			break
+		}
+		fv.SetInt(int64(x))
+		return nil
+	case reflect.Int64:
+		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+			fv.SetInt(x)
+			return nil
+		}
+
+	case reflect.Ptr:
+		// A basic field (indirected through pointer), or a repeated message/group
+		p.back()
+		fv.Set(reflect.New(fv.Type().Elem()))
+		return p.readAny(fv.Elem(), props)
+	case reflect.String:
+		if tok.value[0] == '"' || tok.value[0] == '\'' {
+			fv.SetString(tok.unquoted)
+			return nil
+		}
+	case reflect.Struct:
+		var terminator string
+		switch tok.value {
+		case "{":
+			terminator = "}"
+		case "<":
+			terminator = ">"
+		default:
+			return p.errorf("expected '{' or '<', found %q", tok.value)
+		}
+		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
+		return p.readStruct(fv, terminator)
+	case reflect.Uint32:
+		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+			fv.SetUint(uint64(x))
+			return nil
+		}
+	case reflect.Uint64:
+		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+			fv.SetUint(x)
+			return nil
+		}
+	}
+	return p.errorf("invalid %v: %v", v.Type(), tok.value)
+}
+
+// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
+// before starting to unmarshal, so any existing data in pb is always removed.
+// If a required field is not set and no other error occurs,
+// UnmarshalText returns *RequiredNotSetError.
+func UnmarshalText(s string, pb Message) error {
+	if um, ok := pb.(encoding.TextUnmarshaler); ok {
+		err := um.UnmarshalText([]byte(s))
+		return err
+	}
+	pb.Reset()
+	v := reflect.ValueOf(pb)
+	if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil {
+		return pe
+	}
+	return nil
+}
diff --git a/vendor/github.com/google/cayley/.gitignore b/vendor/github.com/google/cayley/.gitignore
new file mode 100644
index 00000000..dfc9f945
--- /dev/null
+++ b/vendor/github.com/google/cayley/.gitignore
@@ -0,0 +1,10 @@
+*.swp
+main
+*.test
+*.peg.go
+cayley.cfg
+.cayley_history
+.DS_Store
+
+# The built binary
+/cayley
diff --git a/vendor/github.com/google/cayley/.goxc.json b/vendor/github.com/google/cayley/.goxc.json
new file mode 100644
index 00000000..d6553583
--- /dev/null
+++ b/vendor/github.com/google/cayley/.goxc.json
@@ -0,0 +1,6 @@
+{
+	"Arch": "arm amd64 386",
+	"Os": "linux darwin windows",
+	"ResourcesInclude": "README.md,static,templates,LICENSE,AUTHORS,CONTRIBUTORS,docs,cayley.cfg.example,data",
+	"ConfigVersion": "0.9"
+}
diff --git a/vendor/github.com/google/cayley/.travis.yml b/vendor/github.com/google/cayley/.travis.yml
new file mode 100644
index 00000000..14ce71dc
--- /dev/null
+++ b/vendor/github.com/google/cayley/.travis.yml
@@ -0,0 +1,25 @@
+language: go
+
+sudo: false
+
+go:
+  - 1.4
+  - 1.5
+  - tip
+
+install:
+  # Install our tracked dependencies
+  - go get github.com/tools/godep
+  - godep restore
+
+  # Google App Engine dependencies
+  - cd ..
+  - wget https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.23.zip
+  - unzip -q go_appengine_sdk_linux_amd64-1.9.23.zip
+  - export PATH=$PATH:$PWD/go_appengine/
+  - cd cayley
+
+script:
+  - go test -v ./...
+  - goapp test -v ./graph/gaedatastore
+
diff --git a/vendor/github.com/google/cayley/AUTHORS b/vendor/github.com/google/cayley/AUTHORS
new file mode 100644
index 00000000..c474d394
--- /dev/null
+++ b/vendor/github.com/google/cayley/AUTHORS
@@ -0,0 +1,21 @@
+# This is the official list of Cayley authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+#
+# Names should be added to this file as:
+# Name or Organization <email address>
+# The email address is not required for organizations.
+#
+# Please keep the list sorted.
+
+Alexander Peters <info@alexanderpeters.de>
+Andrew Dunham <andrew@du.nham.ca>
+Bram Leenders <bcleenders@gmail.com>
+Google Inc.
+Jay Graves <jaywgraves@gmail.com>
+Jeremy Jay <jeremy@pbnjay.com>
+Pius Uzamere <pius+github@alum.mit.edu>
+Robert Daniel Kortschak <dan.kortschak@adelaide.edu.au>
+Timothy Armstrong <armstrong.timothy@gmail.com>
+Zihua Li <i@zihua.li>
+Stefan Koshiw <anonwasere@gmail.com>
diff --git a/vendor/github.com/google/cayley/CONTRIBUTING.md b/vendor/github.com/google/cayley/CONTRIBUTING.md
new file mode 100644
index 00000000..eb5c65c8
--- /dev/null
+++ b/vendor/github.com/google/cayley/CONTRIBUTING.md
@@ -0,0 +1,61 @@
+# Contributing
+
+We want to make it as easy as possible for people to contribute cool new things to Cayley.
+
+## I want to build the community!
+
+This is, really, a community project and community is important. Write to the mailing list, ask and answer questions,
+and generally being involved in growing the project is, perhaps, the most important contribution.
+
+## I found a bug!
+
+Opening an issue on the issue tracker is the most helpful thing. However, some notes:
+
+* Check the issue tracker and mailing list to see if it's already a bug.
+* Include as many details in your bug as possible. Finding your log file (often in /tmp, but can be
+    controlled with command line flags) can be a great help.
+* Often a bug comes with unexpected behavior for a query. *Please include the query* and how you found the bug.
+
+## I want to contribute a pull request!
+
+First things first:
+
+**Sign the Google [Contributor License Agreement][cla]** (you can sign online at the bottom of that page). 
+
+You _must_ sign this form, otherwise we cannot merge in your changes. 
+**_Always_ mention in the pull request that you've signed it**, even 
+if you signed it for a previous pull request (you only need to sign the CLA once).
+
+If you're contributing on behalf of your company, please email the mailing list and look into signing
+Google's [Corporate Contributor License Agreement][cla-corp].
+
+### I'm not much of a coder, but I want to help!
+
+Documentation is always important. 
+If you want to make a passage clearer, expand on the implications, write about schema and best practices, these are just as helpful
+as code.
+
+Just running Cayley and coming up with benchmarks and performance numbers in docs and on the mailing list is also helpful.
+
+### I want to extend Cayley in code, but I don't know what's needed?
+
+Check out TODO.md for random thoughts that authors have contributed. Usually if it's agreed that it's a good 
+idea in the mailing list, in chat or elsewhere, a pull request to add to TODO.md is perfectly fine.
+
+If you want to start simple, find a place to improve test coverage. The coverage metrics are part of "make test" and anything that
+improves testing is good news.
+
+If you're a designer, most of the work on Cayley to date has been on the backend -- improving the UI is certainly helpful!
+
+### I want to (interface with a backend/write a new query language/add some other cool feature).
+
+Please do, and send the pull request. It may or may not get in as-is, but it will certainly generate discussion to see a working version. 
+Obviously, well-tested and documented code makes a stronger case.
+
+It's a general philosophy that, if it's modular and doesn't break things, it's generally a good thing to have! 
+The worst that will happen is it will go unused and possibly become deprecated, and ultimately removed by the maintainers. So if you have
+a pet project, make sure it's either something you'll maintain or has enough of a user base to stick around.
+
+
+[cla]: https://developers.google.com/open-source/cla/individual
+[cla-corp]:https://developers.google.com/open-source/cla/corporate
diff --git a/vendor/github.com/google/cayley/CONTRIBUTORS b/vendor/github.com/google/cayley/CONTRIBUTORS
new file mode 100644
index 00000000..23ab6522
--- /dev/null
+++ b/vendor/github.com/google/cayley/CONTRIBUTORS
@@ -0,0 +1,25 @@
+# People who have agreed to one of the CLAs and can contribute patches.
+# The AUTHORS file lists the copyright holders; this file
+# lists people.  For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# https://developers.google.com/open-source/cla/individual
+# https://developers.google.com/open-source/cla/corporate
+#
+# Names should be added to this file as:
+#     Name <email address>
+#
+# Please keep the list sorted.
+
+Alexander Peters <info@alexanderpeters.de>
+Andrew Dunham <andrew@du.nham.ca>
+Barak Michener <barakmich@google.com> <barak@cayley.io> <me@barakmich.com>
+Bram Leenders <bcleenders@gmail.com>
+Jay Graves <jaywgraves@gmail.com>
+Jeremy Jay <jeremy@pbnjay.com>
+Pius Uzamere <pius+github@alum.mit.edu>
+Robert Daniel Kortschak <dan.kortschak@adelaide.edu.au>
+Timothy Armstrong <armstrong.timothy@gmail.com>
+Tyler Gibbons <tyler.gibbons@ideogr.am>
+Zihua Li <i@zihua.li>
+Stefan Koshiw <anonwasere@gmail.com>
diff --git a/vendor/github.com/google/cayley/Godeps/Godeps.json b/vendor/github.com/google/cayley/Godeps/Godeps.json
new file mode 100644
index 00000000..3213d249
--- /dev/null
+++ b/vendor/github.com/google/cayley/Godeps/Godeps.json
@@ -0,0 +1,73 @@
+{
+	"ImportPath": "github.com/google/cayley",
+	"GoVersion": "go1.4.2",
+	"Packages": [
+		"./..."
+	],
+	"Deps": [
+		{
+			"ImportPath": "github.com/badgerodon/peg",
+			"Rev": "9e5f7f4d07ca576562618c23e8abadda278b684f"
+		},
+		{
+			"ImportPath": "github.com/barakmich/glog",
+			"Rev": "fafcb6128a8a2e6360ff034091434d547397d54a"
+		},
+		{
+			"ImportPath": "github.com/boltdb/bolt",
+			"Comment": "v1.0-111-g04a3e85",
+			"Rev": "04a3e85793043e76d41164037d0d7f9d53eecae3"
+		},
+		{
+			"ImportPath": "github.com/cznic/mathutil",
+			"Rev": "f9551431b78e71ee24939a1e9d8f49f43898b5cd"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/proto",
+			"Rev": "58bbd41c1a2d1b7154f5d99a8d0d839b3093301a"
+		},
+		{
+			"ImportPath": "github.com/julienschmidt/httprouter",
+			"Rev": "b59a38004596b696aca7aa2adccfa68760864d86"
+		},
+		{
+			"ImportPath": "github.com/lib/pq",
+			"Comment": "go1.0-cutoff-58-g0dad96c",
+			"Rev": "0dad96c0b94f8dee039aa40467f767467392a0af"
+		},
+		{
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+		},
+		{
+			"ImportPath": "github.com/peterh/liner",
+			"Rev": "1bb0d1c1a25ed393d8feb09bab039b2b1b1fbced"
+		},
+		{
+			"ImportPath": "github.com/robertkrimen/otto",
+			"Rev": "d1b4d8ef0e0e4b088c8328c95ca63ab9ebd8fc9d"
+		},
+		{
+			"ImportPath": "github.com/russross/blackfriday",
+			"Comment": "v1.2-54-g17bb799",
+			"Rev": "17bb7999de6cfb791d4f8986cc00b3309b370cdb"
+		},
+		{
+			"ImportPath": "github.com/shurcooL/sanitized_anchor_name",
+			"Rev": "8e87604bec3c645a4eeaee97dfec9f25811ff20d"
+		},
+		{
+			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
+			"Rev": "4875955338b0a434238a31165cb87255ab6e9e4a"
+		},
+		{
+			"ImportPath": "github.com/syndtr/gosnappy/snappy",
+			"Rev": "156a073208e131d7d2e212cb749feae7c339e846"
+		},
+		{
+			"ImportPath": "gopkg.in/mgo.v2",
+			"Comment": "r2015.01.24",
+			"Rev": "c6a7dce14133ccac2dcac3793f1d6e2ef048503a"
+		}
+	]
+}
diff --git a/vendor/github.com/google/cayley/Godeps/Readme b/vendor/github.com/google/cayley/Godeps/Readme
new file mode 100644
index 00000000..4cdaa53d
--- /dev/null
+++ b/vendor/github.com/google/cayley/Godeps/Readme
@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.
diff --git a/vendor/github.com/google/cayley/LICENSE b/vendor/github.com/google/cayley/LICENSE
new file mode 100644
index 00000000..67db8588
--- /dev/null
+++ b/vendor/github.com/google/cayley/LICENSE
@@ -0,0 +1,175 @@
+
+                                 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.
diff --git a/vendor/github.com/google/cayley/README.md b/vendor/github.com/google/cayley/README.md
new file mode 100644
index 00000000..8deb7967
--- /dev/null
+++ b/vendor/github.com/google/cayley/README.md
@@ -0,0 +1,173 @@
+<p align="center">
+  <img src="static/branding/cayley_side.png?raw=true" alt="Cayley" />
+</p>
+Cayley is an open-source graph inspired by the graph database behind [Freebase](http://freebase.com) and Google's [Knowledge Graph](https://en.wikipedia.org/wiki/Knowledge_Graph).
+
+Its goal is to be a part of the developer's toolbox where [Linked Data](http://linkeddata.org/) and graph-shaped data (semantic webs, social networks, etc) in general are concerned.
+
+[![Build Status](https://travis-ci.org/google/cayley.png?branch=master)](https://travis-ci.org/google/cayley) [Trello Board](https://trello.com/b/KioFZb5O)
+
+## Features
+
+* Written in [Go](http://golang.org)
+* Easy to get running (3 or 4 commands, below)
+* RESTful API
+  * or a REPL if you prefer
+* Built-in query editor and visualizer
+* Multiple query languages:
+  * JavaScript, with a [Gremlin](http://gremlindocs.com/)-inspired\* graph object.
+  * (simplified) [MQL](https://developers.google.com/freebase/v1/mql-overview), for Freebase fans
+* Plays well with multiple backend stores:
+  * [LevelDB](https://github.com/google/leveldb)
+  * [Bolt](https://github.com/boltdb/bolt)
+  * [MongoDB](https://www.mongodb.org) for distributed stores
+  * In-memory, ephemeral
+* Modular design; easy to extend with new languages and backends
+* Good test coverage
+* Speed, where possible.
+
+Rough performance testing shows that, on consumer hardware and an average disk, 134m quads in LevelDB is no problem and a multi-hop intersection query -- films starring X and Y -- takes ~150ms.
+
+\* Note that while it's not exactly Gremlin, it certainly takes inspiration from that API. For this flavor, [see the documentation](docs/GremlinAPI.md).
+
+## Getting Started
+
+Grab the latest [release binary](https://github.com/google/cayley/releases) and extract it wherever you like.
+
+If you prefer to build from source, see the documentation on the wiki at [How to start hacking on Cayley](https://github.com/google/cayley/wiki/How-to-start-hacking-on-Cayley) or type
+```
+mkdir -p ~/cayley && cd ~/cayley
+export GOPATH=`pwd`
+export PATH=$PATH:~/cayley/bin
+mkdir -p bin pkg src/github.com/google
+cd src/github.com/google
+git clone https://github.com/google/cayley
+cd cayley
+go get github.com/tools/godep
+godep restore
+go build ./cmd/cayley
+```
+
+Then `cd` to the directory and give it a quick test with:
+```
+./cayley repl --dbpath=data/testdata.nq
+```
+
+To run the web frontend, replace the "repl" command with "http"
+```
+./cayley http --dbpath=data/testdata.nq
+```
+
+You should see a `cayley>` REPL prompt. Go ahead and give it a try:
+
+```
+// Simple math
+cayley> 2 + 2
+
+// JavaScript syntax
+cayley> x = 2 * 8
+cayley> x
+
+// See all the entities in this small follow graph.
+cayley> graph.Vertex().All()
+
+// See only dani.
+cayley> graph.Vertex("dani").All()
+
+// See who dani follows.
+cayley> graph.Vertex("dani").Out("follows").All()
+```
+
+**Running the visualizer on the web frontend**
+
+To run the visualizer: click on visualize and enter:
+
+```
+// Visualize who dani follows.
+g.V("dani").Tag("source").Out("follows").Tag("target").All()
+```
+The visualizer expects to tag nodes as either "source" or "target."  Your source is represented as a blue node.
+While your target is represented as an orange node.
+The idea being that our node relationship goes from blue to orange (source to target).  
+
+**Sample Data**
+
+For somewhat more interesting data, a sample of 30k movies from Freebase comes in the checkout.
+
+```
+./cayley repl --dbpath=data/30kmoviedata.nq.gz
+```
+
+To run the web frontend, replace the "repl" command with "http"
+
+```
+./cayley http --dbpath=data/30kmoviedata.nq.gz
+```
+
+And visit port 64210 on your machine, commonly [http://localhost:64210](http://localhost:64210)
+
+
+## Running queries
+
+The default environment is based on [Gremlin](http://gremlindocs.com/) and is simply a JavaScript environment. If you can write jQuery, you can query a graph.
+
+You'll notice we have a special object, `graph` or `g`, which is how you can interact with the graph.
+
+The simplest query is merely to return a single vertex. Using the 30kmoviedata.nq dataset from above, let's walk through some simple queries:
+
+```javascript
+// Query all vertices in the graph, limit to the first 5 vertices found.
+graph.Vertex().GetLimit(5)
+
+// Start with only one vertex, the literal name "Humphrey Bogart", and retrieve all of them.
+graph.Vertex("Humphrey Bogart").All()
+
+// `g` and `V` are synonyms for `graph` and `Vertex` respectively, as they are quite common.
+g.V("Humphrey Bogart").All()
+
+// "Humphrey Bogart" is a name, but not an entity. Let's find the entities with this name in our dataset.
+// Follow links that are pointing In to our "Humphrey Bogart" node with the predicate "name".
+g.V("Humphrey Bogart").In("name").All()
+
+// Notice that "name" is a generic predicate in our dataset.
+// Starting with a movie gives a similar effect.
+g.V("Casablanca").In("name").All()
+
+// Relatedly, we can ask the reverse; all ids with the name "Casablanca"
+g.V().Has("name", "Casablanca").All()
+```
+
+
+You may start to notice a pattern here: with Gremlin, the query lines tend to:
+
+Start somewhere in the graph | Follow a path | Run the query with "All" or "GetLimit"
+
+g.V("Casablanca") | .In("name") | .All()
+
+And these pipelines continue...
+
+```javascript
+// Let's get the list of actors in the film
+g.V().Has("name","Casablanca")
+  .Out("/film/film/starring").Out("/film/performance/actor")
+  .Out("name").All()
+
+// But this is starting to get long. Let's use a morphism -- a pre-defined path stored in a variable -- as our linkage
+
+var filmToActor = g.Morphism().Out("/film/film/starring").Out("/film/performance/actor")
+
+g.V().Has("name", "Casablanca").Follow(filmToActor).Out("name").All()
+
+```
+
+There's more in the JavaScript API Documentation, but that should give you a feel for how to walk around the graph.
+
+## Disclaimer
+
+Not a Google project, but created and maintained [by a Googler](https://github.com/barakmich), with permission from and assignment to Google, under the [Apache License, version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
+
+## Contact
+
+* Email list: [cayley-users at Google Groups](https://groups.google.com/forum/?hl=en#!forum/cayley-users)
+* Twitter: [@cayleygraph](https://twitter.com/cayleygraph)
+* IRC: [#cayley on Freenode](http://webchat.freenode.net/?channels=%23cayley&uio=d4)
diff --git a/vendor/github.com/google/cayley/TODO.md b/vendor/github.com/google/cayley/TODO.md
new file mode 100644
index 00000000..1f5b4090
--- /dev/null
+++ b/vendor/github.com/google/cayley/TODO.md
@@ -0,0 +1,104 @@
+# TODOs
+
+## Short Term
+
+### Client modules
+
+In Python, Node.js, the usual suspects. Even cooler would be a node.js/Gremlin bridge that gave you the graph object.
+
+### Response wrapper details
+
+Query time, statistics, that sort of thing.
+
+### Better run-iterator centralization
+
+It's everywhere now, with subtly different semantics. Unify and do cool things (like abort).
+
+### More test coverage
+Always good. Break out test_utils and compare text and Javascript outputs.
+
+### More documentation
+Also always good.
+
+### Anything marked "TODO" in the code.
+Usually something that should be taken care of.
+
+### Bootstraps
+Start discussing bootstrap quads, things that make the database self-describing, if they exist (though they need not). Talk about sameAs and indexing and type systems and whatnot.
+
+### Better surfacing of Label
+It exists, it's indexed, but it's basically useless right now
+
+### Optimize HasA Iterator
+There are some simple optimizations that can be done there. And was the first one to get right, this is the next one.
+A simple example is just to convert the HasA to a fixed (next them out) if the subiterator size is guessable and small.
+
+### Gremlin features
+
+#### Mid-query Limit
+A way to limit the number of subresults at a point, without even running the query. Essentially, much as GetLimit() does for the end, be able to do the same in between
+
+#### "Up" and "Down" traversals
+Getting to the predicates from a node, or the nodes from a predicate, or some odd combinations thereof. Ditto for label.
+
+#### Value comparison
+Expose the value-comparison iterator in the language
+
+### MQL features
+See also bootstrapping. Things like finding "name" predicates, and various schema or type enforcement.
+
+An important failure of MQL before was that it was never well-specified. Let's not fall in that trap again, and be able to document what everything means.
+
+### New Iterators
+
+#### Limit Iterator
+The necessary component to make mid-query limit work. Acts as a limit on Next(), a passthrough on Contains(), and a limit on NextPath()
+
+## Medium Term
+
+### Direct JSON-LD loading
+  Because it's useful markup, and JSON is easy for Go to deal with. The NQuads library is nicely self-contained, there's no reason more formats can't be supported.
+
+### Value indexing
+  Since I have value comparison. It works, it's just not fast today. That could be improved.
+
+### Postgres Backend
+  It'd be nice to run on SQL as well. It's a big why not?
+#### Generalist layout
+  Notionally, this is a simple quad table with a number of indices. Iterators and iterator optimization (ie, rewriting SQL queries) is the 'fun' part
+#### "Short Schema" Layout?
+  This one is the crazy one. Suppose a world where we actually use the table schema for predicates, and update the table schema as we go along. Yes, it sucks when you add a new predicate (and the cell values are unclear) but for small worlds (or, "short schemas") it may (or may not) be interesting.
+
+
+### New Iterators
+#### Predicate Iterator
+  Really, this is just the generalized value comparison iterator, across strings and dates and such.
+
+## Longer Term (and fuzzy)
+
+### SPARQL and more traditional RDF
+  There's a whole body of work there, and a lot of interested researchers. They're the choir who already know the sermon of graph stores. Once ease-of-use gets people in the door, supporting extensions that make everyone happy seems like a win. And because we're query-language agnostic, it's a cleaner win. See also bootstrapping, which is the first goal toward this (eg, let's talk about sameAs, and index it appropriately.)
+
+### Replication
+  Technically it works now if you piggyback on someone else's replication, but that's cheating.  We speak HTTP, we can send quad sets over the wire to some other instance. Bonus points for a way to apply morphisms first -- massive graph on the backend, important graph on the frontend.
+
+### Related services
+  Eg, topic service, recon service -- whether in Cayley itself or as part of the greater project.
+
+### New languages
+  Javascript is nice for first-timers but experienced graph folks may want something more. Experiment with new languages, including but not limited to things that feel a lot like Datalog.
+
+### Meta-stores
+  Imagine an in-memory graph cache wrapped around another store.
+
+### New Iterators
+#### Cross Iterator
+  This is the nutty one that's undefined and slow. The notion is to make graph-shapes more efficient, but it's unclear how that'll happen.
+
+
+### All sorts of backends:
+#### Git?
+  Can we access git in a meaningful fashion, giving a history and rollbacks to memory/flat files?
+#### ElasticSearch
+#### Cassandra
+#### Redis
diff --git a/vendor/github.com/google/cayley/appengine/app.yaml b/vendor/github.com/google/cayley/appengine/app.yaml
new file mode 100644
index 00000000..21d547fe
--- /dev/null
+++ b/vendor/github.com/google/cayley/appengine/app.yaml
@@ -0,0 +1,8 @@
+application: cayley-test
+version: 1
+runtime: go
+api_version: go1.4.1
+
+handlers:
+- url: /.*
+  script: _go_app
diff --git a/vendor/github.com/google/cayley/appengine/appengine.go b/vendor/github.com/google/cayley/appengine/appengine.go
new file mode 100644
index 00000000..bb972c1c
--- /dev/null
+++ b/vendor/github.com/google/cayley/appengine/appengine.go
@@ -0,0 +1,112 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build appengine
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/internal/config"
+	"github.com/google/cayley/internal/db"
+	"github.com/google/cayley/internal/http"
+
+	_ "github.com/google/cayley/graph/gaedatastore"
+	_ "github.com/google/cayley/writer"
+)
+
+var (
+	quadFile           = ""
+	quadType           = "cquad"
+	cpuprofile         = ""
+	queryLanguage      = "gremlin"
+	configFile         = ""
+	databasePath       = ""
+	databaseBackend    = "gaedatastore"
+	replicationBackend = "single"
+	host               = "127.0.0.1"
+	loadSize           = 100
+	port               = "64210"
+	readOnly           = false
+	timeout            = 30 * time.Second
+)
+
+func configFrom(file string) (*config.Config, error) {
+	// Find the file...
+	if file != "" {
+		if _, err := os.Stat(file); os.IsNotExist(err) {
+			return nil, fmt.Errorf("Cannot find specified configuration file", file)
+		}
+	} else if _, err := os.Stat("/cayley_appengine.cfg"); err == nil {
+		file = "/cayley_appengine.cfg"
+	}
+	if file == "" {
+		glog.Infoln("Couldn't find a config file appengine.cfg. Going by flag defaults only.")
+	}
+	cfg, err := config.Load(file)
+	if err != nil {
+		return nil, err
+	}
+
+	if cfg.DatabasePath == "" {
+		cfg.DatabasePath = databasePath
+	}
+
+	if cfg.DatabaseType == "" {
+		cfg.DatabaseType = databaseBackend
+	}
+
+	if cfg.ReplicationType == "" {
+		cfg.ReplicationType = replicationBackend
+	}
+
+	if cfg.ListenHost == "" {
+		cfg.ListenHost = host
+	}
+
+	if cfg.ListenPort == "" {
+		cfg.ListenPort = port
+	}
+
+	if cfg.Timeout == 0 {
+		cfg.Timeout = timeout
+	}
+
+	if cfg.LoadSize == 0 {
+		cfg.LoadSize = loadSize
+	}
+
+	cfg.ReadOnly = cfg.ReadOnly || readOnly
+
+	return cfg, nil
+}
+
+func init() {
+	glog.SetToStderr(true)
+	cfg, err := configFrom("cayley_appengine.cfg")
+	if err != nil {
+		glog.Fatalln("Error loading config:", err)
+	}
+
+	handle, err := db.Open(cfg)
+	if err != nil {
+		glog.Fatalln("Error opening database:", err)
+	}
+	http.SetupRoutes(handle, cfg)
+}
diff --git a/vendor/github.com/google/cayley/appengine/cayley_appengine.cfg b/vendor/github.com/google/cayley/appengine/cayley_appengine.cfg
new file mode 100644
index 00000000..2b09e4cb
--- /dev/null
+++ b/vendor/github.com/google/cayley/appengine/cayley_appengine.cfg
@@ -0,0 +1,7 @@
+{
+"database": "gaedatastore",
+"read_only": false,
+"load_size": 100,
+"timeout": 10,
+"http_request_context":true
+}
diff --git a/vendor/github.com/google/cayley/cayley.cfg.example b/vendor/github.com/google/cayley/cayley.cfg.example
new file mode 100644
index 00000000..a1202239
--- /dev/null
+++ b/vendor/github.com/google/cayley/cayley.cfg.example
@@ -0,0 +1,5 @@
+{
+"database": "leveldb",
+"db_path": "/tmp/cayley_test",
+"read_only": false
+}
diff --git a/vendor/github.com/google/cayley/cmd/cayley/cayley.go b/vendor/github.com/google/cayley/cmd/cayley/cayley.go
new file mode 100644
index 00000000..edf0a661
--- /dev/null
+++ b/vendor/github.com/google/cayley/cmd/cayley/cayley.go
@@ -0,0 +1,279 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !appengine
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"time"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/internal"
+	"github.com/google/cayley/internal/config"
+	"github.com/google/cayley/internal/db"
+	"github.com/google/cayley/internal/http"
+
+	// Load all supported backends.
+	_ "github.com/google/cayley/graph/bolt"
+	_ "github.com/google/cayley/graph/leveldb"
+	_ "github.com/google/cayley/graph/memstore"
+	_ "github.com/google/cayley/graph/mongo"
+	_ "github.com/google/cayley/graph/sql"
+
+	// Load writer registry
+	_ "github.com/google/cayley/writer"
+)
+
+var (
+	quadFile           = flag.String("quads", "", "Quad file to load before going to REPL.")
+	quadType           = flag.String("format", "cquad", `Quad format to use for loading ("cquad" or "nquad").`)
+	cpuprofile         = flag.String("prof", "", "Output profiling file.")
+	queryLanguage      = flag.String("query_lang", "gremlin", "Use this parser as the query language.")
+	configFile         = flag.String("config", "", "Path to an explicit configuration file.")
+	databasePath       = flag.String("dbpath", "/tmp/testdb", "Path to the database.")
+	databaseBackend    = flag.String("db", "memstore", "Database Backend.")
+	dumpFile           = flag.String("dump", "dbdump.nq", `Quad file to dump the database to (".gz" supported, "-" for stdout).`)
+	dumpType           = flag.String("dump_type", "quad", `Quad file format ("json", "quad", "gml", "graphml").`)
+	replicationBackend = flag.String("replication", "single", "Replication method.")
+	host               = flag.String("host", "127.0.0.1", "Host to listen on (defaults to all).")
+	loadSize           = flag.Int("load_size", 10000, "Size of quadsets to load")
+	port               = flag.String("port", "64210", "Port to listen on.")
+	readOnly           = flag.Bool("read_only", false, "Disable writing via HTTP.")
+	timeout            = flag.Duration("timeout", 30*time.Second, "Elapsed time until an individual query times out.")
+)
+
+// Filled in by `go build ldflags="-X main.Version `ver`"`.
+var (
+	BuildDate string
+	Version   string
+)
+
+func usage() {
+	fmt.Fprintln(os.Stderr, `
+Usage:
+  cayley COMMAND [flags]
+
+Commands:
+  init      Create an empty database.
+  load      Bulk-load a quad file into the database.
+  http      Serve an HTTP endpoint on the given host and port.
+  dump      Bulk-dump the database into a quad file.
+  repl      Drop into a REPL of the given query language.
+  version   Version information.
+
+Flags:`)
+	flag.PrintDefaults()
+}
+
+func init() {
+	flag.Usage = usage
+}
+
+func configFrom(file string) *config.Config {
+	// Find the file...
+	if file != "" {
+		if _, err := os.Stat(file); os.IsNotExist(err) {
+			glog.Fatalln("Cannot find specified configuration file", file, ", aborting.")
+		}
+	} else if _, err := os.Stat(os.Getenv("CAYLEY_CFG")); err == nil {
+		file = os.Getenv("CAYLEY_CFG")
+	} else if _, err := os.Stat("/etc/cayley.cfg"); err == nil {
+		file = "/etc/cayley.cfg"
+	}
+	if file == "" {
+		glog.Infoln("Couldn't find a config file in either $CAYLEY_CFG or /etc/cayley.cfg. Going by flag defaults only.")
+	}
+	cfg, err := config.Load(file)
+	if err != nil {
+		glog.Fatalln(err)
+	}
+
+	if cfg.DatabasePath == "" {
+		cfg.DatabasePath = *databasePath
+	}
+
+	if cfg.DatabaseType == "" {
+		cfg.DatabaseType = *databaseBackend
+	}
+
+	if cfg.ReplicationType == "" {
+		cfg.ReplicationType = *replicationBackend
+	}
+
+	if cfg.ListenHost == "" {
+		cfg.ListenHost = *host
+	}
+
+	if cfg.ListenPort == "" {
+		cfg.ListenPort = *port
+	}
+
+	if cfg.Timeout == 0 {
+		cfg.Timeout = *timeout
+	}
+
+	if cfg.LoadSize == 0 {
+		cfg.LoadSize = *loadSize
+	}
+
+	cfg.ReadOnly = cfg.ReadOnly || *readOnly
+
+	return cfg
+}
+
+func main() {
+	// No command? It's time for usage.
+	if len(os.Args) == 1 {
+		fmt.Fprintln(os.Stderr, "Cayley is a graph store and graph query layer.")
+		usage()
+		os.Exit(1)
+	}
+
+	cmd := os.Args[1]
+	os.Args = append(os.Args[:1], os.Args[2:]...)
+	flag.Parse()
+
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			glog.Fatal(err)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+
+	var buildString string
+	if Version != "" {
+		buildString = fmt.Sprint("Cayley ", Version, " built ", BuildDate)
+		glog.Infoln(buildString)
+	}
+
+	cfg := configFrom(*configFile)
+
+	if os.Getenv("GOMAXPROCS") == "" {
+		runtime.GOMAXPROCS(runtime.NumCPU())
+		glog.Infoln("Setting GOMAXPROCS to", runtime.NumCPU())
+	} else {
+		glog.Infoln("GOMAXPROCS currently", os.Getenv("GOMAXPROCS"), " -- not adjusting")
+	}
+
+	var (
+		handle *graph.Handle
+		err    error
+	)
+	switch cmd {
+	case "version":
+		if Version != "" {
+			fmt.Println(buildString)
+		} else {
+			fmt.Println("Cayley snapshot")
+		}
+		os.Exit(0)
+
+	case "init":
+		err = db.Init(cfg)
+		if err != nil {
+			break
+		}
+		if *quadFile != "" {
+			handle, err = db.Open(cfg)
+			if err != nil {
+				break
+			}
+			err = internal.Load(handle.QuadWriter, cfg, *quadFile, *quadType)
+			if err != nil {
+				break
+			}
+			handle.Close()
+		}
+
+	case "load":
+		handle, err = db.Open(cfg)
+		if err != nil {
+			break
+		}
+		err = internal.Load(handle.QuadWriter, cfg, *quadFile, *quadType)
+		if err != nil {
+			break
+		}
+
+		handle.Close()
+
+	case "dump":
+		handle, err = db.Open(cfg)
+		if err != nil {
+			break
+		}
+		if !graph.IsPersistent(cfg.DatabaseType) {
+			err = internal.Load(handle.QuadWriter, cfg, *quadFile, *quadType)
+			if err != nil {
+				break
+			}
+		}
+
+		err = internal.Dump(handle.QuadStore, *dumpFile, *dumpType)
+		if err != nil {
+			break
+		}
+
+		handle.Close()
+
+	case "repl":
+		handle, err = db.Open(cfg)
+		if err != nil {
+			break
+		}
+		if !graph.IsPersistent(cfg.DatabaseType) {
+			err = internal.Load(handle.QuadWriter, cfg, "", *quadType)
+			if err != nil {
+				break
+			}
+		}
+
+		err = db.Repl(handle, *queryLanguage, cfg)
+
+		handle.Close()
+
+	case "http":
+		handle, err = db.Open(cfg)
+		if err != nil {
+			break
+		}
+		if !graph.IsPersistent(cfg.DatabaseType) {
+			err = internal.Load(handle.QuadWriter, cfg, "", *quadType)
+			if err != nil {
+				break
+			}
+		}
+
+		http.Serve(handle, cfg)
+
+		handle.Close()
+
+	default:
+		fmt.Println("No command", cmd)
+		usage()
+	}
+	if err != nil {
+		glog.Errorln(err)
+	}
+}
diff --git a/vendor/github.com/google/cayley/cmd/cayleyupgrade/cayleyupgrade.go b/vendor/github.com/google/cayley/cmd/cayleyupgrade/cayleyupgrade.go
new file mode 100644
index 00000000..146dd578
--- /dev/null
+++ b/vendor/github.com/google/cayley/cmd/cayleyupgrade/cayleyupgrade.go
@@ -0,0 +1,79 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !appengine
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/internal/config"
+
+	// Load all supported backends.
+
+	_ "github.com/google/cayley/graph/bolt"
+	_ "github.com/google/cayley/graph/leveldb"
+	_ "github.com/google/cayley/graph/memstore"
+	_ "github.com/google/cayley/graph/mongo"
+)
+
+var (
+	configFile      = flag.String("config", "", "Path to an explicit configuration file.")
+	databasePath    = flag.String("dbpath", "/tmp/testdb", "Path to the database.")
+	databaseBackend = flag.String("db", "memstore", "Database Backend.")
+)
+
+func configFrom(file string) *config.Config {
+	// Find the file...
+	if file != "" {
+		if _, err := os.Stat(file); os.IsNotExist(err) {
+			glog.Fatalln("Cannot find specified configuration file", file, ", aborting.")
+		}
+	} else if _, err := os.Stat(os.Getenv("CAYLEY_CFG")); err == nil {
+		file = os.Getenv("CAYLEY_CFG")
+	} else if _, err := os.Stat("/etc/cayley.cfg"); err == nil {
+		file = "/etc/cayley.cfg"
+	}
+	if file == "" {
+		glog.Infoln("Couldn't find a config file in either $CAYLEY_CFG or /etc/cayley.cfg. Going by flag defaults only.")
+	}
+	cfg, err := config.Load(file)
+	if err != nil {
+		glog.Fatalln(err)
+	}
+	if cfg.DatabasePath == "" {
+		cfg.DatabasePath = *databasePath
+	}
+
+	if cfg.DatabaseType == "" {
+		cfg.DatabaseType = *databaseBackend
+	}
+	return cfg
+}
+
+func main() {
+	flag.Parse()
+	cfg := configFrom(*configFile)
+
+	err := graph.UpgradeQuadStore(cfg.DatabaseType, cfg.DatabasePath, nil)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
diff --git a/vendor/github.com/google/cayley/data/30kmoviedata.nq.gz b/vendor/github.com/google/cayley/data/30kmoviedata.nq.gz
new file mode 100644
index 00000000..ddb21a45
Binary files /dev/null and b/vendor/github.com/google/cayley/data/30kmoviedata.nq.gz differ
diff --git a/vendor/github.com/google/cayley/data/testdata.nq b/vendor/github.com/google/cayley/data/testdata.nq
new file mode 100644
index 00000000..12fe713d
--- /dev/null
+++ b/vendor/github.com/google/cayley/data/testdata.nq
@@ -0,0 +1,13 @@
+<alice> <follows> <bob> .
+<bob> <follows> <fred> .
+<bob> <status> "cool_person" .
+<charlie> <follows> <bob> .
+<charlie> <follows> <dani> .
+<dani> <follows> <bob> .
+<dani> <follows> <greg> .
+<dani> <status> "cool_person" .
+<emily> <follows> <fred> .
+<fred> <follows> <greg> .
+<greg> <status> "cool_person" .
+<predicates> <are> <follows> .
+<predicates> <are> <status> .
diff --git a/vendor/github.com/google/cayley/docs/Configuration.md b/vendor/github.com/google/cayley/docs/Configuration.md
new file mode 100644
index 00000000..70e1745d
--- /dev/null
+++ b/vendor/github.com/google/cayley/docs/Configuration.md
@@ -0,0 +1,145 @@
+# Configuration File
+
+## Overview
+
+Cayley expects, in the usual case, to be run with a configuration file, though it can also be run purely through configuration flags. The configuration file contains a JSON object with any of the documented parameters.
+
+Cayley looks in the following locations for the configuration file
+
+  * Command line flag
+  * The environment variable $CAYLEY_CFG
+  * /etc/cayley.cfg
+
+All command line flags take precedence over the configuration file.
+
+## Main Options
+
+#### **`database`**
+
+  * Type: String
+  * Default: "mem"
+
+  Determines the type of the underlying database. Options include:
+
+  * `mem`: An in-memory store, based on an initial N-Quads file. Loses all changes when the process exits.
+  * `leveldb`: A persistent on-disk store backed by [LevelDB](https://github.com/google/leveldb).
+  * `bolt`: Stores the graph data on-disk in a [Bolt](http://github.com/boltdb/bolt) file. Uses more disk space and memory than LevelDB for smaller stores, but is often faster to write to and comparable for large ones, with faster average query times.
+  * `mongo`: Stores the graph data and indices in a [MongoDB](http://mongodb.org) instance. Slower, as it incurs network traffic, but multiple Cayley instances can disappear and reconnect at will, across a potentially horizontally-scaled store.
+
+#### **`db_path`**
+
+  * Type: String
+  * Default: "/tmp/testdb"
+
+  Where does the database actually live? Dependent on the type of database. For each datastore:
+
+  * `mem`: Path to a quad file to automatically load.
+  * `leveldb`: Directory to hold the LevelDB database files.
+  * `bolt`: Path to the persistent single Bolt database file.
+  * `mongo`: "hostname:port" of the desired MongoDB server.
+
+#### **`listen_host`**
+
+  * Type: String
+  * Default: "127.0.0.1"
+
+  The hostname or IP address for Cayley's HTTP server to listen on. Defaults to all interfaces.
+
+#### **`listen_port`**
+
+  * Type: String
+  * Default: "64210"
+
+  The port for Cayley's HTTP server to listen on.
+
+#### **`read_only`**
+
+  * Type: Boolean
+  * Default: false
+
+  If true, disables the ability to write to the database using the HTTP API (will return a 400 for any write request). Useful for testing or instances that shouldn't change.
+
+#### **`load_size`**
+
+  * Type: Integer
+  * Default: 10000
+
+  The number of quads to buffer from a loaded file before writing a block of quads to the database. Larger numbers are good for larger loads.
+
+#### **`db_options`**
+
+  * Type: Object
+
+  See Per-Database Options, below.
+
+## Language Options
+
+#### **`timeout`**
+
+  * Type: Integer or String
+  * Default: 30
+
+The maximum length of time the Javascript runtime should run until cancelling the query and returning a 408 Timeout. When timeout is an integer is is interpreted as seconds, when it is a string it is [parsed](http://golang.org/pkg/time/#ParseDuration) as a Go time.Duration. A negative duration means no limit.
+
+## Per-Database Options
+
+The `db_options` object in the main configuration file contains any of these following options that change the behavior of the datastore.
+
+### Memory
+
+No special options.
+
+### LevelDB
+
+#### **`write_buffer_mb`**
+
+  * Type: Integer
+  * Default: 20
+
+The size in MiB of the LevelDB write cache. Increasing this number allows for more/faster writes before syncing to disk. Default is 20, for large loads, a recommended value is 200+.
+
+#### **`cache_size_mb`**
+
+  * Type: Integer
+  * Default: 2
+
+The size in MiB of the LevelDB block cache. Increasing this number uses more memory to maintain a bigger cache of quad blocks for better performance.
+
+### Bolt
+
+#### **`nosync`**
+
+  * Type: Boolean
+  * Default: false
+
+Optionally disable syncing to disk per transaction. Nosync being true means much faster load times, but without consistency guarantees.
+
+### Mongo
+
+
+#### **`database_name`**
+
+  * Type: String
+  * Default: "cayley"
+
+The name of the database within MongoDB to connect to. Manages its own collections and indices therein.
+
+## Per-Replication Options
+
+The `replication_options` object in the main configuration file contains any of these following options that change the behavior of the replication manager.
+
+### All
+
+#### **`ignore_missing`**
+
+  * Type: Boolean
+  * Default: false
+
+Optionally ignore missing quad on delete.
+
+#### **`ignore_duplicate`**
+
+  * Type: Boolean
+  * Default: false
+
+Optionally ignore duplicated quad on add.
diff --git a/vendor/github.com/google/cayley/docs/GremlinAPI.md b/vendor/github.com/google/cayley/docs/GremlinAPI.md
new file mode 100644
index 00000000..f02d2219
--- /dev/null
+++ b/vendor/github.com/google/cayley/docs/GremlinAPI.md
@@ -0,0 +1,446 @@
+# Javascript/Gremlin API documentation
+
+## The `graph` object
+
+Alias: `g`
+
+This is the only special object in the environment, generates the query objects. Under the hood, they're simple objects that get compiled to a Go iterator tree when executed.
+
+#### **`graph.Vertex([nodeId],[nodeId]...)`**
+
+Alias: `graph.V`
+
+Arguments:
+
+  * `nodeId` (Optional): A string or list of strings representing the starting vertices.
+
+Returns: Query object
+
+Starts a query path at the given vertex/vertices. No ids means "all vertices".
+
+####**`graph.Morphism()`**
+
+Alias: `graph.M`
+
+Arguments: none
+
+Returns: Path object
+
+Creates a morphism path object. Unqueryable on it's own, defines one end of the path. Saving these to variables with
+
+```javascript
+var shorterPath = graph.Morphism().Out("foo").Out("bar")
+```
+
+is the common use case. See also: `path.Follow()`, `path.FollowR()`
+
+####**`graph.Emit(data)`**
+
+Arguments:
+
+  * `data`: A Javascript object that can be serialized to JSON
+
+Adds data programmatically to the JSON result list. Can be any JSON type.
+
+
+## Path objects
+
+Both `.Morphism()` and `.Vertex()` create path objects, which provide the following traversal methods. Note that `.Vertex()` returns a query object, which is a subclass of path object.
+
+For these examples, suppose we have the following graph:
+```
+  +-------+                        +------+
+  | alice |-----                 ->| fred |<--
+  +-------+     \---->+-------+-/  +------+   \-+-------+
+                ----->| #bob# |       |         | emily |
+  +---------+--/  --->+-------+       |         +-------+
+  | charlie |    /                    v
+  +---------+   /                  +--------+
+    \---    +--------+             | #greg# |
+        \-->| #dani# |------------>+--------+
+            +--------+
+```
+
+Where every link is a "follows" relationship, and the nodes with an extra `#` in the name have an extra `status` link. As in,
+
+```
+dani -- status --> cool_person
+```
+Perhaps these are the influencers in our community.
+
+
+To load above graph into cayley and reproduce the following examples:
+
+`./cayley repl --dbpath=data/testdata.nq` for a REPL prompt, or 
+
+`./cayley http --dbpath=data/testdata.nq` for the web frontend.
+
+### Basic Traversals
+
+####**`path.Out([predicatePath], [tags])`**
+
+Arguments:
+
+  * `predicatePath` (Optional): One of:
+    * null or undefined: All predicates pointing out from this node
+    * a string: The predicate name to follow out from this node
+	* a list of strings: The predicates to follow out from this node
+	* a query path object: The target of which is a set of predicates to follow.
+  * `tags` (Optional): One of:
+	* null or undefined: No tags
+	* a string: A single tag to add the predicate used to the output set.
+	* a list of strings: Multiple tags to use as keys to save the predicate used to the output set.
+
+Out is the work-a-day way to get between nodes, in the forward direction. Starting with the nodes in `path` on the subject, follow the quads with predicates defined by `predicatePath` to their objects.
+
+Example:
+```javascript
+// The working set of this is bob and dani
+g.V("charlie").Out("follows")
+// The working set of this is fred, as alice follows bob and bob follows fred.
+g.V("alice").Out("follows").Out("follows")
+// Finds all things dani points at. Result is bob, greg and cool_person
+g.V("dani").Out()
+// Finds all things dani points at on the status linkage.
+// Result is bob, greg and cool_person
+g.V("dani").Out(["follows", "status"])
+// Finds all things dani points at on the status linkage, given from a separate query path.
+// Result is {"id": cool_person, "pred": "status"}
+g.V("dani").Out(g.V("status"), "pred")
+```
+
+####**`path.In([predicatePath], [tags])`**
+
+Arguments:
+
+  * `predicatePath` (Optional): One of:
+	* null or undefined: All predicates pointing into this node
+	* a string: The predicate name to follow into this node
+	* a list of strings: The predicates to follow into this node
+	* a query path object: The target of which is a set of predicates to follow.
+  * `tags` (Optional): One of:
+	* null or undefined: No tags
+	* a string: A single tag to add the predicate used to the output set.
+	* a list of strings: Multiple tags to use as keys to save the predicate used to the output set.
+
+Same as Out, but in the other direction.  Starting with the nodes in `path` on the object, follow the quads with predicates defined by `predicatePath` to their subjects.
+
+Example:
+```javascript
+// Find the cool people, bob, greg and dani
+g.V("cool_person").In("status")
+// Find who follows bob, in this case, alice, charlie, and dani
+g.V("bob").In("follows")
+// Find who follows the people emily follows, namely, emily and bob
+g.V("emily").Out("follows").In("follows")
+```
+
+####**`path.Both([predicatePath], [tags])`**
+
+Arguments:
+
+  * `predicatePath` (Optional): One of:
+	* null or undefined: All predicates pointing both into and out from this node
+	* a string: The predicate name to follow both into and out from this node
+	* a list of strings: The predicates to follow both into and out from this node
+	* a query path object: The target of which is a set of predicates to follow.
+  * `tags` (Optional): One of:
+	* null or undefined: No tags
+	* a string: A single tag to add the predicate used to the output set.
+	* a list of strings: Multiple tags to use as keys to save the predicate used to the output set.
+Follow the predicate in either direction. Same as
+
+Note: Less efficient, for the moment, as it's implemented with an Or, but useful where necessary.
+
+Example:
+```javascript
+// Find all followers/followees of fred. Returns bob, emily and greg
+g.V("fred").Both("follows")
+```
+
+
+####**`path.Is(node, [node..])`**
+
+Arguments:
+
+  * `node`: A string for a node. Can be repeated or a list of strings.
+
+Filter all paths to ones which, at this point, are on the given `node`.
+
+Example:
+```javascript
+// Starting from all nodes in the graph, find the paths that follow bob.
+// Results in three paths for bob (from alice, charlie and dani)
+g.V().Out("follows").Is("bob")
+```
+
+####**`path.Has(predicate, object)`**
+
+Arguments:
+
+  * `predicate`: A string for a predicate node.
+  * `object`: A string for a object node.
+
+Filter all paths which are, at this point, on the subject for the given predicate and object, but do not follow the path, merely filter the possible paths.
+
+Usually useful for starting with all nodes, or limiting to a subset depending on some predicate/value pair.
+
+Example:
+```javascript
+// Start from all nodes that follow bob -- results in alice, charlie and dani
+g.V().Has("follows", "bob")
+// People charlie follows who then follow fred. Results in bob.
+g.V("charlie").Out("follows").Has("follows", "fred")
+```
+
+### Tagging
+
+####**`path.Tag(tag)`**
+
+Alias: `path.As`
+
+Arguments:
+
+  * `tag`: A string or list of strings to act as a result key. The value for tag was the vertex the path was on at the time it reached "Tag"
+
+In order to save your work or learn more about how a path got to the end, we have tags. The simplest thing to do is to add a tag anywhere you'd like to put each node in the result set.
+
+
+Example:
+```javascript
+// Start from all nodes, save them into start, follow any status links, and return the result.
+// Results are: {"id": "cool_person", "start": "bob"}, {"id": "cool_person", "start": "greg"}, {"id": "cool_person", "start": "dani"}
+g.V().Tag("start").Out("status")
+```
+
+
+####**`path.Back(tag)`**
+
+Arguments:
+
+   * `tag`: A previous tag in the query to jump back to.
+
+If still valid, a path will now consider their vertex to be the same one as the previously tagged one, with the added constraint that it was valid all the way here. Useful for traversing back in queries and taking another route for things that have matched so far.
+
+Example:
+```javascript
+// Start from all nodes, save them into start, follow any status links, jump back to the starting node, and find who follows them. Return the result.
+// Results are:
+//   {"id": "alice", "start": "bob"},
+//   {"id": "charlie", "start": "bob"},
+//   {"id": "dani", "start": "bob"},
+//   {"id": "charlie", "start": "dani"},
+//   {"id": "dani", "start": "greg"}
+g.V().Tag("start").Out("status").Back("start").In("follows")
+```
+
+####**`path.Save(predicate, tag)`**
+
+Arguments:
+
+  * `predicate`: A string for a predicate node.
+  * `tag`: A string for a tag key to store the object node.
+
+From the current node as the subject, save the object of all quads with `predicate` into `tag`, without traversal.
+
+Example:
+```javascript
+// Start from dani and bob and save who they follow into "target"
+// Returns:
+//   {"id" : "dani", "target": "bob" },
+//   {"id" : "dani", "target": "greg" },
+//   {"id" : "bob", "target": "fred" },
+g.V("dani", "bob").Save("follows", "target")
+```
+
+### Joining
+
+####**`path.Intersect(query)`**
+
+Alias: `path.And`
+
+Arguments:
+
+  * `query`: Another query path, the result sets of which will be intersected
+
+Filters all paths by the result of another query path (efficiently computed).
+
+This is essentially a join where, at the stage of each path, a node is shared.
+Example:
+```javascript
+var cFollows = g.V("charlie").Out("follows")
+var dFollows = g.V("dani").Out("follows")
+// People followed by both charlie (bob and dani) and dani (bob and greg) -- returns bob.
+cFollows.Intersect(dFollows)
+// Equivalently, g.V("charlie").Out("follows").And(g.V("dani").Out("follows"))
+```
+
+####**`path.Union(query)`**
+
+Alias: `path.Or`
+
+Arguments:
+
+  * `query`: Another query path, the result sets of which will form a union
+
+Given two queries, returns the combined paths of the two queries.
+Notice that it's per-path, not per-node. Once again, if multiple paths reach the
+same destination, they might have had different ways of getting there (and different tags).
+See also: `path.Tag()`
+
+Example:
+```javascript
+var cFollows = g.V("charlie").Out("follows")
+var dFollows = g.V("dani").Out("follows")
+// People followed by both charlie (bob and dani) and dani (bob and greg) -- returns bob (from charlie), bob (from dani), dani and greg.
+cFollows.Union(dFollows)
+```
+####**`path.Except(query)`**
+
+Alias: `path.Difference`
+
+Arguments:
+
+  * `query`: Another query path, the result sets of which will be intersected and negated
+
+Removes all paths which match `query` from `path`.
+
+In a set-theoretic sense, this is (A - B). While `g.V().Except(path)` to achieve `U - B = !B` is supported, it's often very slow.
+
+Example:
+```javascript
+var cFollows = g.V("charlie").Out("follows")
+var dFollows = g.V("dani").Out("follows")
+// People followed by both charlie (bob and dani) and dani (bob and greg) -- returns bob.
+cFollows.Except(dFollows)   // The set (dani) -- what charlie follows that dani does not also follow.
+// Equivalently, g.V("charlie").Out("follows").Except(g.V("dani").Out("follows"))
+```
+
+
+### Using Morphisms
+
+####**`path.Follow(morphism)`**
+
+Arguments:
+
+  * `morphism`: A morphism path to follow
+
+With `graph.Morphism` we can prepare a path for later reuse. `Follow` is the way that's accomplished.
+Applies the path chain on the morphism object to the current path.
+
+Starts as if at the g.M() and follows through the morphism path.
+
+Example:
+```javascript:
+friendOfFriend = g.Morphism().Out("follows").Out("follows")
+// Returns the followed people of who charlie follows -- a simplistic "friend of my friend"
+// and whether or not they have a "cool" status. Potential for recommending followers abounds.
+// Returns bob and greg
+g.V("charlie").Follow(friendOfFriend).Has("status", "cool_person")
+```
+
+####**`path.FollowR(morphism)`**
+
+Arguments:
+
+  * `morphism`: A morphism path to follow
+
+Same as `Follow` but follows the chain in the reverse direction. Flips "In" and "Out" where appropriate,
+the net result being a virtual predicate followed in the reverse direction.
+
+Starts at the end of the morphism and follows it backwards (with appropriate flipped directions) to the g.M() location.
+
+Example:
+```javascript:
+friendOfFriend = g.Morphism().Out("follows").Out("follows")
+// Returns the third-tier of influencers -- people who follow people who follow the cool people.
+// Returns emily, bob, charlie (from bob) and charlie (from greg)
+g.V().Has("status", "cool_person").FollowR(friendOfFriend)
+```
+
+
+## Query objects (finals)
+
+Only `.Vertex()` objects -- that is, queries that have somewhere to start -- can be turned into queries. To actually execute the queries, an output step must be applied.
+
+####**`query.All()`**
+
+Arguments: None
+
+Returns: undefined
+
+Executes the query and adds the results, with all tags, as a string-to-string (tag to node) map in the output set, one for each path that a traversal could take.
+
+####**`query.GetLimit(size)`**
+
+Arguments:
+
+  * `size`: An integer value on the first `size` paths to return.
+
+ Returns: undefined
+
+Same as all, but limited to the first `size` unique nodes at the end of the path, and each of their possible traversals.
+
+####**`query.ToArray()`**
+
+Arguments: None
+
+Returns: Array
+
+Executes a query and returns the results at the end of the query path.
+Example:
+```javascript
+// bobFollowers contains an Array of followers of bob (alice, charlie, dani).
+var bobFollowers = g.V("bob").In("follows").ToArray()
+```
+
+####**`query.ToValue()`**
+
+Arguments: None
+
+Returns: String
+
+As `.ToArray` above, but limited to one result node -- a string. Like `.Limit(1)` for the above case (alice).
+
+####**`query.TagArray()`**
+
+Arguments: None
+
+Returns: Array of string-to-string objects
+
+As `.ToArray` above, but instead of a list of top-level strings, returns an Array of tag-to-string dictionaries, much as `.All` would, except inside the Javascript environment.
+Example:
+```javascript
+// bobFollowers contains an Array of followers of bob (alice, charlie, dani).
+var bobFollowers = g.V("bob").Tag("name").In("follows").ToArray()
+// nameValue should be the string "bob"
+var nameValue = bobTags[0]["name"]
+```
+
+####**`query.TagValue()`**
+
+Arguments: None
+
+Returns: A single string-to-string object
+
+As `.TagArray` above, but limited to one result node -- a string. Like `.Limit(1)` for the above case. Returns a tag-to-string map.
+
+
+####**`query.ForEach(callback), query.ForEach(limit, callback)`**
+
+Alias: `query.Map`
+
+Arguments:
+
+  * `limit` (Optional): An integer value on the first `limit` paths to process.
+  * `callback`: A javascript function of the form `function(data)`
+
+Returns: undefined
+
+For each tag-to-string result retrieved, as in the `All` case, calls `callback(data)` where `data` is the tag-to-string map.
+
+Example:
+```javascript
+// Simulate query.All()
+graph.V("foo").ForEach(function(d) { g.Emit(d) } )
+```
diff --git a/vendor/github.com/google/cayley/docs/HTTP.md b/vendor/github.com/google/cayley/docs/HTTP.md
new file mode 100644
index 00000000..d85a0359
--- /dev/null
+++ b/vendor/github.com/google/cayley/docs/HTTP.md
@@ -0,0 +1,128 @@
+# HTTP Methods
+
+## API v1
+
+Unless otherwise noted, all URIs take a POST command.
+
+### Queries and Results
+
+#### `/api/v1/query/gremlin`
+
+POST Body: Javascript source code of the query
+
+Response: JSON results, depending on the query.
+
+#### `/api/v1/query/mql`
+
+POST Body: JSON MQL query
+
+Response: JSON results, with a query wrapper:
+```json
+{
+	"result": <JSON Result set>
+}
+```
+
+If the JSON is invalid or an error occurs:
+
+```json
+{
+	"error": "Error message"
+}
+```
+
+
+### Query Shapes
+
+Result form:
+
+```json
+{
+	"nodes": [{
+		"id" : integer,
+		"tags": ["list of tags from the query"],
+		"values": ["known values from the query"],
+		"is_link_node": bool,  // Does the node represent the link or the node (the oval shapes)
+		"is_fixed": bool  // Is the node a fixed starting point of the query
+	}],
+
+	"links": [{
+		"source": integer,  // Node ID
+		"target": integer,  // Node ID
+		"link_node": integer  // Node ID
+	}]
+}
+```
+
+#### `/api/v1/shape/gremlin`
+
+POST Body: Javascript source code of the query
+
+Response: JSON description of the last query executed.
+
+#### `/api/v1/shape/mql`
+
+POST Body: JSON MQL query
+
+Response: JSON description of the query.
+
+### Write commands
+
+Responses come in the form
+
+200 Success:
+```json
+{
+	"result": "Success message."
+}
+```
+
+400 / 500 Error:
+```json
+{
+	"error": "Error message."
+}
+```
+
+#### `/api/v1/write`
+
+POST Body: JSON quads
+
+```json
+[{
+	"subject": "Subject Node",
+	"predicate": "Predicate Node",
+	"object": "Object node",
+	"label": "Label node"  // Optional
+}]   // More than one quad allowed.
+```
+
+Response: JSON response message
+
+
+#### `/api/v1/write/file/nquad`
+
+POST Body: Form-encoded body:
+ * Key: `NQuadFile`, Value: N-Quad file to write.
+
+Response: JSON response message
+
+Example:
+```
+curl http://localhost:64210/api/v1/write/file/nquad -F NQuadFile=@30k.n3
+```
+
+#### `/api/v1/delete`
+
+POST Body: JSON quads
+
+```json
+[{
+	"subject": "Subject Node",
+	"predicate": "Predicate Node",
+	"object": "Object node",
+	"label": "Label node"  // Optional
+}]   // More than one quad allowed.
+```
+
+Response: JSON response message.
diff --git a/vendor/github.com/google/cayley/docs/MQL.md b/vendor/github.com/google/cayley/docs/MQL.md
new file mode 100644
index 00000000..cfcb30e4
--- /dev/null
+++ b/vendor/github.com/google/cayley/docs/MQL.md
@@ -0,0 +1,86 @@
+# MQL Guide
+
+## General
+
+Cayley's MQL implementation is a work-in-progress clone of [Freebase's MQL API](https://developers.google.com/freebase/mql/). At the moment, it supports very basic queries without some of the extended features. It also aims to be database-agnostic, meaning that the schema inference from Freebase does not (yet) apply.
+
+Every JSON Object can be thought of as a node in the graph, and wrapping an object in a list means there may be several of these, or it may be repeated. A simple query like:
+
+```json
+[{
+  "id": null
+}]
+```
+
+Is equivalent to all nodes in the graph, where "id" is the special keyword for the value of the node.
+
+Predicates are added to the object to specify constraints.
+
+```json
+[{
+  "id": null,
+  "some_predicate": "some value"
+}]
+```
+
+Predicates can take as values objects or lists of objects (subqueries), strings and numbers (literal IDs that must match -- equivalent to the object {"id": "value"}) or null, which indicates that, while the object must have a predicate that matches, the matching values will replace the null. A single null is one such value, an empty list will be filled with all such values, as strings.
+
+## Keywords
+
+* `id`: The value of the node.
+
+## Reverse Predicates
+
+Predicates always assume a forward direction. That is,
+
+```json
+[{
+  "id": "A",
+  "some_predicate": "B"
+}]
+```
+
+will only match if the quad
+```
+A some_predicate B .
+```
+
+exists. In order to reverse the directions, "!predicates" are used. So that:
+
+```json
+[{
+  "id": "A",
+  "!some_predicate": "B"
+}]
+```
+
+will only match if the quad
+```
+B some_predicate A .
+```
+exists.
+
+## Multiple Predicates
+
+JSON does not specify the behavior of objects with the same key. In order to have separate constraints for the same predicate, the prefix "@name:" can be applied to any predicate. This is slightly different from traditional MQL in that fully-qualified http paths may be common predicates, so we have an "@name:" prefix instead.
+
+
+```json
+[{
+  "id": "A",
+  "@x:some_predicate": "B",
+  "@y:some_predicate": "C"
+
+}]
+```
+
+Will only match if *both*
+
+```
+A some_predicate B .
+A some_predicate C .
+```
+
+exist.
+
+This combines with the reversal rule to create paths like ``"@a:!some_predicate"``
diff --git a/vendor/github.com/google/cayley/docs/Overview.md b/vendor/github.com/google/cayley/docs/Overview.md
new file mode 100644
index 00000000..17cce4ac
--- /dev/null
+++ b/vendor/github.com/google/cayley/docs/Overview.md
@@ -0,0 +1,122 @@
+# Overview
+
+## Getting Started
+
+This guide will take you through starting a persistent graph based on the provided data, with some hints for each backend.
+
+Grab the latest [release binary](http://github.com/google/cayley/releases) and extract it wherever you like.
+
+If you prefer to build from source, see the documentation on the wiki at [How to start hacking on Cayley](https://github.com/google/cayley/wiki/How-to-start-hacking-on-Cayley)
+
+### Initialize A Graph
+
+Now that Cayley is built, let's create our database. `init` is the subcommand to set up a database and the right indices.
+
+You can set up a full [configuration file](/docs/Configuration.md) if you'd prefer, but it will also work from the command line.
+
+Examples for each backend:
+
+  * `leveldb`:  `./cayley init --db=leveldb --dbpath=/tmp/moviedb` -- where /tmp/moviedb is the path you'd like to store your data.
+  * `bolt`:  `./cayley init --db=bolt --dbpath=/tmp/moviedb` -- where /tmp/moviedb is the filename where you'd like to store your data.
+  * `mongo`: `./cayley init --db=mongo --dbpath="<HOSTNAME>:<PORT>"` -- where HOSTNAME and PORT point to your Mongo instance.
+
+Those two options (db and dbpath) are always going to be present. If you feel like not repeating yourself, setting up a configuration file for your backend might be something to do now. There's an example file, `cayley.cfg.example` in the root directory.
+
+You can repeat the `--db` and `--dbpath` flags from here forward instead of the config flag, but let's assume you created `cayley.cfg.overview`
+
+### Load Data Into A Graph
+
+First we load the data.
+
+```bash
+./cayley load --config=cayley.cfg.overview --quads=data/30kmoviedata.nq.gz
+```
+
+And wait. It will load. If you'd like to watch it load, you can run
+
+```bash
+./cayley load --config=cayley.cfg.overview --quads=data/30kmoviedata.nq.gz --alsologtostderr
+```
+
+And watch the log output go by.
+
+### Connect a REPL To Your Graph
+
+Now it's loaded. We can use Cayley now to connect to the graph. As you might have guessed, that command is:
+
+```bash
+./cayley repl --config=cayley.cfg.overview
+```
+
+Where you'll be given a `cayley>` prompt. It's expecting Gremlin/JS, but that can also be configured with a flag.
+
+New nodes and links can be added with the following command:
+
+```bash
+cayley> :a subject predicate object label .
+```
+
+Removing links works similarly:
+
+```bash
+cayley> :d subject predicate object .
+```
+
+This is great for testing, and ultimately also for scripting, but the real workhorse is the next step.
+
+### Serve Your Graph
+
+Just as before:
+
+```bash
+./cayley http --config=cayley.cfg.overview
+```
+
+And you'll see a message not unlike
+
+```bash
+Cayley now listening on 127.0.0.1:64210
+```
+
+If you visit that address (often, [http://localhost:64210](http://localhost:64210)) you'll see the full web interface and also have a graph ready to serve queries via the [HTTP API](/docs/HTTP.md)
+
+## UI Overview
+
+### Sidebar
+
+Along the side are the various actions or views you can take. From the top, these are:
+
+* Run Query (run the query)
+* Gremlin (a dropdown, to pick your query language)
+
+----
+
+* Query (a request/response editor for the query language)
+* Query Shape (a visualization of the shape of the final query. Does not execute the query.)
+* Visualize  (runs a query and, if tagged correctly, gives a sigmajs view of the results)
+* Write (an interface to write or remove individual quads or quad files)
+
+----
+
+* Documentation (this documentation)
+
+### Visualize
+
+To use the visualize function, emit, either through tags or JS post-processing, a set of JSON objects containing the keys `source` and `target`. These will be the links, and nodes will automatically be detected.
+
+For example:
+
+```javascript
+[
+{
+  "source": "node1"
+  "target": "node2"
+},
+{
+  "source": "node1"
+  "target": "node3"
+},
+]
+```
+
+Other keys are ignored. The upshot is that if you use the "Tag" functionality to add "source" and "target" tags, you can extract and quickly view subgraphs.
diff --git a/vendor/github.com/google/cayley/exporter/exporter.go b/vendor/github.com/google/cayley/exporter/exporter.go
new file mode 100644
index 00000000..39fdb4f5
--- /dev/null
+++ b/vendor/github.com/google/cayley/exporter/exporter.go
@@ -0,0 +1,185 @@
+package exporter
+
+import (
+	"encoding/json"
+	"io"
+	"strconv"
+
+	"github.com/google/cayley/graph"
+)
+
+type Exporter struct {
+	wr     io.Writer
+	qstore graph.QuadStore
+	qi     graph.Iterator
+	err    error
+	count  int
+}
+
+func NewExporter(writer io.Writer, qstore graph.QuadStore) *Exporter {
+	return NewExporterForIterator(writer, qstore, qstore.QuadsAllIterator())
+}
+
+func NewExporterForIterator(writer io.Writer, qstore graph.QuadStore, qi graph.Iterator) *Exporter {
+	return &Exporter{wr: writer, qstore: qstore, qi: qi}
+}
+
+// number of records
+func (exp *Exporter) Count() int {
+	return exp.count
+}
+
+func (exp *Exporter) ExportQuad() {
+	exp.qi.Reset()
+	for it := exp.qi; graph.Next(it); {
+		exp.count++
+		quad := exp.qstore.Quad(it.Result())
+
+		exp.WriteEscString(quad.Subject)
+		exp.Write(" ")
+		exp.WriteEscString(quad.Predicate)
+		exp.Write(" ")
+		exp.WriteEscString(quad.Object)
+		if quad.Label != "" {
+			exp.Write(" ")
+			exp.WriteEscString(quad.Label)
+		}
+		exp.Write(" .\n")
+	}
+}
+
+func (exp *Exporter) ExportJson() {
+	var jstr []byte
+	exp.Write("[")
+	exp.qi.Reset()
+	for it := exp.qi; graph.Next(it); {
+		exp.count++
+		if exp.count > 1 {
+			exp.Write(",")
+		}
+
+		jstr, exp.err = json.Marshal(exp.qstore.Quad(it.Result()))
+		if exp.err != nil {
+			return
+		}
+		exp.Write(string(jstr[:]))
+	}
+	exp.Write("]\n")
+}
+
+//experimental
+func (exp *Exporter) ExportGml() {
+	var seen map[string]int32 // todo eliminate this for large dbs
+	var id int32
+
+	exp.Write("Creator Cayley\ngraph\n[\n")
+
+	seen = make(map[string]int32)
+	exp.qi.Reset()
+	for it := exp.qi; graph.Next(it); {
+		cur := exp.qstore.Quad(it.Result())
+		if _, ok := seen[cur.Subject]; !ok {
+			exp.Write("  node\n  [\n    id ")
+			seen[cur.Subject] = id
+			exp.Write(strconv.FormatInt(int64(id), 10))
+			exp.Write("\n    label ")
+			exp.WriteEscString(cur.Subject)
+			exp.Write("\n  ]\n")
+			id++
+		}
+		if _, ok := seen[cur.Object]; !ok {
+			exp.Write("  node\n  [\n    id ")
+			seen[cur.Object] = id
+			exp.Write(strconv.FormatInt(int64(id), 10))
+			exp.Write("\n    label ")
+			exp.WriteEscString(cur.Object)
+			exp.Write("\n  ]\n")
+			id++
+		}
+		exp.count++
+	}
+
+	exp.qi.Reset()
+	for it := exp.qi; graph.Next(it); {
+		cur := exp.qstore.Quad(it.Result())
+		exp.Write("  edge\n  [\n    source ")
+		exp.Write(strconv.FormatInt(int64(seen[cur.Subject]), 10))
+		exp.Write("\n    target ")
+		exp.Write(strconv.FormatInt(int64(seen[cur.Object]), 10))
+		exp.Write("\n    label ")
+		exp.WriteEscString(cur.Predicate)
+		exp.Write("\n  ]\n")
+		exp.count++
+	}
+	exp.Write("]\n")
+}
+
+//experimental
+func (exp *Exporter) ExportGraphml() {
+	var seen map[string]bool // eliminate this for large databases
+
+	exp.Write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+	exp.Write("<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\"\n")
+	exp.Write("   xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n")
+	exp.Write("   xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd\">\n")
+	exp.Write("  <graph id=\"Caylay\" edgedefault=\"directed\">\n")
+
+	seen = make(map[string]bool)
+	exp.qi.Reset()
+	for it := exp.qi; graph.Next(it); {
+		cur := exp.qstore.Quad(it.Result())
+		if found := seen[cur.Subject]; !found {
+			seen[cur.Subject] = true
+			exp.Write("    <node id=")
+			exp.WriteEscString(cur.Subject)
+			exp.Write(" />\n")
+		}
+		if found := seen[cur.Object]; !found {
+			seen[cur.Object] = true
+			exp.Write("    <node id=")
+			exp.WriteEscString(cur.Object)
+			exp.Write(" />\n")
+		}
+		exp.count++
+	}
+
+	exp.qi.Reset()
+	for it := exp.qi; graph.Next(it); {
+		cur := exp.qstore.Quad(it.Result())
+		exp.Write("    <edge source=")
+		exp.WriteEscString(cur.Subject)
+		exp.Write(" target=")
+		exp.WriteEscString(cur.Object)
+		exp.Write(">\n")
+		exp.Write("      <data key=\"predicate\">")
+		exp.Write(cur.Predicate)
+		exp.Write("</data>\n    </edge>\n")
+		exp.count++
+	}
+	exp.Write("  </graph>\n</graphml>\n")
+}
+
+//print out the string quoted, escaped
+func (exp *Exporter) WriteEscString(str string) {
+	var esc []byte
+
+	if exp.err != nil {
+		return
+	}
+	esc, exp.err = json.Marshal(str)
+	if exp.err != nil {
+		return
+	}
+	_, exp.err = exp.wr.Write(esc)
+}
+
+func (exp *Exporter) Write(str string) {
+	if exp.err != nil {
+		return
+	}
+	_, exp.err = exp.wr.Write([]byte(str))
+}
+
+func (exp *Exporter) Err() error {
+	return exp.err
+}
diff --git a/vendor/github.com/google/cayley/graph/bolt/all_iterator.go b/vendor/github.com/google/cayley/graph/bolt/all_iterator.go
new file mode 100644
index 00000000..0677b14e
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/bolt/all_iterator.go
@@ -0,0 +1,211 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bolt
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/barakmich/glog"
+	"github.com/boltdb/bolt"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+type AllIterator struct {
+	uid    uint64
+	tags   graph.Tagger
+	bucket []byte
+	dir    quad.Direction
+	qs     *QuadStore
+	result *Token
+	err    error
+	buffer [][]byte
+	offset int
+	done   bool
+}
+
+func NewAllIterator(bucket []byte, d quad.Direction, qs *QuadStore) *AllIterator {
+	return &AllIterator{
+		uid:    iterator.NextUID(),
+		bucket: bucket,
+		dir:    d,
+		qs:     qs,
+	}
+}
+
+func (it *AllIterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *AllIterator) Reset() {
+	it.buffer = nil
+	it.offset = 0
+	it.done = false
+}
+
+func (it *AllIterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *AllIterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *AllIterator) Clone() graph.Iterator {
+	out := NewAllIterator(it.bucket, it.dir, it.qs)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+func (it *AllIterator) Next() bool {
+	if it.done {
+		return false
+	}
+	if len(it.buffer) <= it.offset+1 {
+		it.offset = 0
+		var last []byte
+		if it.buffer != nil {
+			last = it.buffer[len(it.buffer)-1]
+		}
+		it.buffer = make([][]byte, 0, bufferSize)
+		err := it.qs.db.View(func(tx *bolt.Tx) error {
+			i := 0
+			b := tx.Bucket(it.bucket)
+			cur := b.Cursor()
+			if last == nil {
+				k, _ := cur.First()
+				var out []byte
+				out = make([]byte, len(k))
+				copy(out, k)
+				it.buffer = append(it.buffer, out)
+				i++
+			} else {
+				k, _ := cur.Seek(last)
+				if !bytes.Equal(k, last) {
+					return fmt.Errorf("could not pick up after %v", k)
+				}
+			}
+			for i < bufferSize {
+				k, _ := cur.Next()
+				if k == nil {
+					it.buffer = append(it.buffer, k)
+					break
+				}
+				var out []byte
+				out = make([]byte, len(k))
+				copy(out, k)
+				it.buffer = append(it.buffer, out)
+				i++
+			}
+			return nil
+		})
+		if err != nil {
+			glog.Error("Error nexting in database: ", err)
+			it.err = err
+			it.done = true
+			return false
+		}
+	} else {
+		it.offset++
+	}
+	if it.Result() == nil {
+		it.done = true
+		return false
+	}
+	return true
+}
+
+func (it *AllIterator) Err() error {
+	return it.err
+}
+
+func (it *AllIterator) Result() graph.Value {
+	if it.done {
+		return nil
+	}
+	if it.result != nil {
+		return it.result
+	}
+	if it.offset >= len(it.buffer) {
+		return nil
+	}
+	if it.buffer[it.offset] == nil {
+		return nil
+	}
+	return &Token{bucket: it.bucket, key: it.buffer[it.offset]}
+}
+
+func (it *AllIterator) NextPath() bool {
+	return false
+}
+
+// No subiterators.
+func (it *AllIterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *AllIterator) Contains(v graph.Value) bool {
+	it.result = v.(*Token)
+	return true
+}
+
+func (it *AllIterator) Close() error {
+	it.result = nil
+	it.buffer = nil
+	it.done = true
+	return nil
+}
+
+func (it *AllIterator) Size() (int64, bool) {
+	return it.qs.size, true
+}
+
+func (it *AllIterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Size:      size,
+		Direction: it.dir,
+	}
+}
+
+func (it *AllIterator) Type() graph.Type { return graph.All }
+func (it *AllIterator) Sorted() bool     { return false }
+
+func (it *AllIterator) Optimize() (graph.Iterator, bool) {
+	return it, false
+}
+
+func (it *AllIterator) Stats() graph.IteratorStats {
+	s, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     2,
+		Size:         s,
+	}
+}
+
+var _ graph.Nexter = &AllIterator{}
diff --git a/vendor/github.com/google/cayley/graph/bolt/iterator.go b/vendor/github.com/google/cayley/graph/bolt/iterator.go
new file mode 100644
index 00000000..389aff18
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/bolt/iterator.go
@@ -0,0 +1,325 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bolt
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"github.com/barakmich/glog"
+	"github.com/boltdb/bolt"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/graph/proto"
+	"github.com/google/cayley/quad"
+)
+
+var (
+	boltType    graph.Type
+	bufferSize  = 50
+	errNotExist = errors.New("quad does not exist")
+)
+
+func init() {
+	boltType = graph.RegisterIterator("bolt")
+}
+
+type Iterator struct {
+	uid     uint64
+	tags    graph.Tagger
+	bucket  []byte
+	checkID []byte
+	dir     quad.Direction
+	qs      *QuadStore
+	result  *Token
+	buffer  [][]byte
+	offset  int
+	done    bool
+	size    int64
+	err     error
+}
+
+func NewIterator(bucket []byte, d quad.Direction, value graph.Value, qs *QuadStore) *Iterator {
+	tok := value.(*Token)
+	if !bytes.Equal(tok.bucket, nodeBucket) {
+		glog.Error("creating an iterator from a non-node value")
+		return &Iterator{done: true}
+	}
+
+	it := Iterator{
+		uid:    iterator.NextUID(),
+		bucket: bucket,
+		dir:    d,
+		qs:     qs,
+		size:   qs.SizeOf(value),
+	}
+
+	it.checkID = make([]byte, len(tok.key))
+	copy(it.checkID, tok.key)
+
+	return &it
+}
+
+func Type() graph.Type { return boltType }
+
+func (it *Iterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *Iterator) Reset() {
+	it.buffer = nil
+	it.offset = 0
+	it.done = false
+}
+
+func (it *Iterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Iterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Iterator) Clone() graph.Iterator {
+	out := NewIterator(it.bucket, it.dir, &Token{nodeBucket, it.checkID}, it.qs)
+	out.Tagger().CopyFrom(it)
+	return out
+}
+
+func (it *Iterator) Close() error {
+	it.result = nil
+	it.buffer = nil
+	it.done = true
+	return nil
+}
+
+func (it *Iterator) isLiveValue(val []byte) bool {
+	var entry proto.HistoryEntry
+	entry.Unmarshal(val)
+	return len(entry.History)%2 != 0
+}
+
+func (it *Iterator) Next() bool {
+	if it.done {
+		return false
+	}
+	if len(it.buffer) <= it.offset+1 {
+		it.offset = 0
+		var last []byte
+		if it.buffer != nil {
+			last = it.buffer[len(it.buffer)-1]
+		}
+		it.buffer = make([][]byte, 0, bufferSize)
+		err := it.qs.db.View(func(tx *bolt.Tx) error {
+			i := 0
+			b := tx.Bucket(it.bucket)
+			cur := b.Cursor()
+			if last == nil {
+				k, v := cur.Seek(it.checkID)
+				if bytes.HasPrefix(k, it.checkID) {
+					if it.isLiveValue(v) {
+						var out []byte
+						out = make([]byte, len(k))
+						copy(out, k)
+						it.buffer = append(it.buffer, out)
+						i++
+					}
+				} else {
+					it.buffer = append(it.buffer, nil)
+					return errNotExist
+				}
+			} else {
+				k, _ := cur.Seek(last)
+				if !bytes.Equal(k, last) {
+					return fmt.Errorf("could not pick up after %v", k)
+				}
+			}
+			for i < bufferSize {
+				k, v := cur.Next()
+				if k == nil || !bytes.HasPrefix(k, it.checkID) {
+					it.buffer = append(it.buffer, nil)
+					break
+				}
+				if !it.isLiveValue(v) {
+					continue
+				}
+				var out []byte
+				out = make([]byte, len(k))
+				copy(out, k)
+				it.buffer = append(it.buffer, out)
+				i++
+			}
+			return nil
+		})
+		if err != nil {
+			if err != errNotExist {
+				glog.Errorf("Error nexting in database: %v", err)
+				it.err = err
+			}
+			it.done = true
+			return false
+		}
+	} else {
+		it.offset++
+	}
+	if it.Result() == nil {
+		it.done = true
+		return false
+	}
+	return true
+}
+
+func (it *Iterator) Err() error {
+	return it.err
+}
+
+func (it *Iterator) Result() graph.Value {
+	if it.done {
+		return nil
+	}
+	if it.result != nil {
+		return it.result
+	}
+	if it.offset >= len(it.buffer) {
+		return nil
+	}
+	if it.buffer[it.offset] == nil {
+		return nil
+	}
+	return &Token{bucket: it.bucket, key: it.buffer[it.offset]}
+}
+
+func (it *Iterator) NextPath() bool {
+	return false
+}
+
+// No subiterators.
+func (it *Iterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func PositionOf(tok *Token, d quad.Direction, qs *QuadStore) int {
+	if bytes.Equal(tok.bucket, spoBucket) {
+		switch d {
+		case quad.Subject:
+			return 0
+		case quad.Predicate:
+			return hashSize
+		case quad.Object:
+			return 2 * hashSize
+		case quad.Label:
+			return 3 * hashSize
+		}
+	}
+	if bytes.Equal(tok.bucket, posBucket) {
+		switch d {
+		case quad.Subject:
+			return 2 * hashSize
+		case quad.Predicate:
+			return 0
+		case quad.Object:
+			return hashSize
+		case quad.Label:
+			return 3 * hashSize
+		}
+	}
+	if bytes.Equal(tok.bucket, ospBucket) {
+		switch d {
+		case quad.Subject:
+			return hashSize
+		case quad.Predicate:
+			return 2 * hashSize
+		case quad.Object:
+			return 0
+		case quad.Label:
+			return 3 * hashSize
+		}
+	}
+	if bytes.Equal(tok.bucket, cpsBucket) {
+		switch d {
+		case quad.Subject:
+			return 2 * hashSize
+		case quad.Predicate:
+			return hashSize
+		case quad.Object:
+			return 3 * hashSize
+		case quad.Label:
+			return 0
+		}
+	}
+	panic("unreachable")
+}
+
+func (it *Iterator) Contains(v graph.Value) bool {
+	val := v.(*Token)
+	if bytes.Equal(val.bucket, nodeBucket) {
+		return false
+	}
+	offset := PositionOf(val, it.dir, it.qs)
+	if len(val.key) != 0 && bytes.HasPrefix(val.key[offset:], it.checkID) {
+		// You may ask, why don't we check to see if it's a valid (not deleted) quad
+		// again?
+		//
+		// We've already done that -- in order to get the graph.Value token in the
+		// first place, we had to have done the check already; it came from a Next().
+		//
+		// However, if it ever starts coming from somewhere else, it'll be more
+		// efficient to change the interface of the graph.Value for LevelDB to a
+		// struct with a flag for isValid, to save another random read.
+		return true
+	}
+	return false
+}
+
+func (it *Iterator) Size() (int64, bool) {
+	return it.size, true
+}
+
+func (it *Iterator) Describe() graph.Description {
+	return graph.Description{
+		UID:       it.UID(),
+		Name:      it.qs.NameOf(&Token{it.bucket, it.checkID}),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Size:      it.size,
+		Direction: it.dir,
+	}
+}
+
+func (it *Iterator) Type() graph.Type { return boltType }
+func (it *Iterator) Sorted() bool     { return false }
+
+func (it *Iterator) Optimize() (graph.Iterator, bool) {
+	return it, false
+}
+
+func (it *Iterator) Stats() graph.IteratorStats {
+	s, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     4,
+		Size:         s,
+	}
+}
+
+var _ graph.Nexter = &Iterator{}
diff --git a/vendor/github.com/google/cayley/graph/bolt/migrate.go b/vendor/github.com/google/cayley/graph/bolt/migrate.go
new file mode 100644
index 00000000..afee99a6
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/bolt/migrate.go
@@ -0,0 +1,162 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bolt
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/barakmich/glog"
+	"github.com/boltdb/bolt"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/proto"
+)
+
+const latestDataVersion = 2
+const nilDataVersion = 1
+
+type upgradeFunc func(*bolt.DB) error
+
+var migrateFunctions = []upgradeFunc{
+	nil,
+	upgrade1To2,
+}
+
+func upgradeBolt(path string, opts graph.Options) error {
+	db, err := bolt.Open(path, 0600, nil)
+	defer db.Close()
+
+	if err != nil {
+		glog.Errorln("Error, couldn't open! ", err)
+		return err
+	}
+	var version int64
+	err = db.View(func(tx *bolt.Tx) error {
+		version, err = getInt64ForMetaKey(tx, "version", nilDataVersion)
+		return err
+	})
+	if err != nil {
+		glog.Errorln("error:", err)
+		return err
+	}
+
+	if version == latestDataVersion {
+		fmt.Printf("Already at latest version: %d\n", latestDataVersion)
+		return nil
+	}
+
+	if version > latestDataVersion {
+		err := fmt.Errorf("Unknown data version: %d -- upgrade this tool", version)
+		glog.Errorln("error:", err)
+		return err
+	}
+
+	for i := version; i < latestDataVersion; i++ {
+		err := migrateFunctions[i](db)
+		if err != nil {
+			return err
+		}
+		setVersion(db, i+1)
+	}
+
+	return nil
+}
+
+type v1ValueData struct {
+	Name string
+	Size int64
+}
+
+type v1IndexEntry struct {
+	History []int64
+}
+
+func upgrade1To2(db *bolt.DB) error {
+	fmt.Println("Upgrading v1 to v2...")
+	tx, err := db.Begin(true)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	fmt.Println("Upgrading bucket", string(logBucket))
+	lb := tx.Bucket(logBucket)
+	c := lb.Cursor()
+	for k, v := c.First(); k != nil; k, v = c.Next() {
+		var delta graph.Delta
+		err := json.Unmarshal(v, &delta)
+		if err != nil {
+			return err
+		}
+		newd := deltaToProto(delta)
+		data, err := newd.Marshal()
+		if err != nil {
+			return err
+		}
+		lb.Put(k, data)
+	}
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+	tx, err = db.Begin(true)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	fmt.Println("Upgrading bucket", string(nodeBucket))
+	nb := tx.Bucket(nodeBucket)
+	c = nb.Cursor()
+	for k, v := c.First(); k != nil; k, v = c.Next() {
+		var vd proto.NodeData
+		err := json.Unmarshal(v, &vd)
+		if err != nil {
+			return err
+		}
+		data, err := vd.Marshal()
+		if err != nil {
+			return err
+		}
+		nb.Put(k, data)
+	}
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	for _, bucket := range [4][]byte{spoBucket, ospBucket, posBucket, cpsBucket} {
+		tx, err = db.Begin(true)
+		if err != nil {
+			return err
+		}
+		defer tx.Rollback()
+		fmt.Println("Upgrading bucket", string(bucket))
+		b := tx.Bucket(bucket)
+		cur := b.Cursor()
+		for k, v := cur.First(); k != nil; k, v = cur.Next() {
+			var h proto.HistoryEntry
+			err := json.Unmarshal(v, &h)
+			if err != nil {
+				return err
+			}
+			data, err := h.Marshal()
+			if err != nil {
+				return err
+			}
+			b.Put(k, data)
+		}
+		if err := tx.Commit(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/google/cayley/graph/bolt/quadstore.go b/vendor/github.com/google/cayley/graph/bolt/quadstore.go
new file mode 100644
index 00000000..ea4b5765
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/bolt/quadstore.go
@@ -0,0 +1,589 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bolt
+
+import (
+	"bytes"
+	"crypto/sha1"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"hash"
+	"sync"
+
+	"github.com/barakmich/glog"
+	"github.com/boltdb/bolt"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/graph/proto"
+	"github.com/google/cayley/quad"
+)
+
+func init() {
+	graph.RegisterQuadStore(QuadStoreType, graph.QuadStoreRegistration{
+		NewFunc:           newQuadStore,
+		NewForRequestFunc: nil,
+		UpgradeFunc:       upgradeBolt,
+		InitFunc:          createNewBolt,
+		IsPersistent:      true,
+	})
+}
+
+var (
+	errNoBucket = errors.New("bolt: bucket is missing")
+)
+
+var (
+	hashPool = sync.Pool{
+		New: func() interface{} { return sha1.New() },
+	}
+	hashSize         = sha1.Size
+	localFillPercent = 0.7
+)
+
+const (
+	QuadStoreType = "bolt"
+)
+
+type Token struct {
+	bucket []byte
+	key    []byte
+}
+
+func (t *Token) Key() interface{} {
+	return fmt.Sprint(t.bucket, t.key)
+}
+
+type QuadStore struct {
+	db      *bolt.DB
+	path    string
+	open    bool
+	size    int64
+	horizon int64
+	version int64
+}
+
+func createNewBolt(path string, _ graph.Options) error {
+	db, err := bolt.Open(path, 0600, nil)
+	if err != nil {
+		glog.Errorf("Error: couldn't create Bolt database: %v", err)
+		return err
+	}
+	defer db.Close()
+	qs := &QuadStore{}
+	qs.db = db
+	err = qs.createBuckets()
+	if err != nil {
+		return err
+	}
+	err = setVersion(qs.db, latestDataVersion)
+	if err != nil {
+		return err
+	}
+	qs.Close()
+	return nil
+}
+
+func newQuadStore(path string, options graph.Options) (graph.QuadStore, error) {
+	var qs QuadStore
+	var err error
+	db, err := bolt.Open(path, 0600, nil)
+	if err != nil {
+		glog.Errorln("Error, couldn't open! ", err)
+		return nil, err
+	}
+	qs.db = db
+	// BoolKey returns false on non-existence. IE, Sync by default.
+	qs.db.NoSync, _, err = options.BoolKey("nosync")
+	if err != nil {
+		return nil, err
+	}
+	err = qs.getMetadata()
+	if err == errNoBucket {
+		return nil, errors.New("bolt: quadstore has not been initialised")
+	} else if err != nil {
+		return nil, err
+	}
+	if qs.version != latestDataVersion {
+		return nil, errors.New("bolt: data version is out of date. Run cayleyupgrade for your config to update the data.")
+	}
+	return &qs, nil
+}
+
+func (qs *QuadStore) createBuckets() error {
+	return qs.db.Update(func(tx *bolt.Tx) error {
+		var err error
+		for _, index := range [][4]quad.Direction{spo, osp, pos, cps} {
+			_, err = tx.CreateBucket(bucketFor(index))
+			if err != nil {
+				return fmt.Errorf("could not create bucket: %s", err)
+			}
+		}
+		_, err = tx.CreateBucket(logBucket)
+		if err != nil {
+			return fmt.Errorf("could not create bucket: %s", err)
+		}
+		_, err = tx.CreateBucket(nodeBucket)
+		if err != nil {
+			return fmt.Errorf("could not create bucket: %s", err)
+		}
+		_, err = tx.CreateBucket(metaBucket)
+		if err != nil {
+			return fmt.Errorf("could not create bucket: %s", err)
+		}
+		return nil
+	})
+}
+
+func setVersion(db *bolt.DB, version int64) error {
+	return db.Update(func(tx *bolt.Tx) error {
+		buf := new(bytes.Buffer)
+		err := binary.Write(buf, binary.LittleEndian, version)
+		if err != nil {
+			glog.Errorf("Couldn't convert version!")
+			return err
+		}
+		b := tx.Bucket(metaBucket)
+		werr := b.Put([]byte("version"), buf.Bytes())
+		if werr != nil {
+			glog.Error("Couldn't write version!")
+			return werr
+		}
+		return nil
+	})
+}
+
+func (qs *QuadStore) Size() int64 {
+	return qs.size
+}
+
+func (qs *QuadStore) Horizon() graph.PrimaryKey {
+	return graph.NewSequentialKey(qs.horizon)
+}
+
+func (qs *QuadStore) createDeltaKeyFor(id int64) []byte {
+	return []byte(fmt.Sprintf("%018x", id))
+}
+
+func bucketFor(d [4]quad.Direction) []byte {
+	return []byte{d[0].Prefix(), d[1].Prefix(), d[2].Prefix(), d[3].Prefix()}
+}
+
+func hashOf(s string) []byte {
+	h := hashPool.Get().(hash.Hash)
+	h.Reset()
+	defer hashPool.Put(h)
+	key := make([]byte, 0, hashSize)
+	h.Write([]byte(s))
+	key = h.Sum(key)
+	return key
+}
+
+func (qs *QuadStore) createKeyFor(d [4]quad.Direction, q quad.Quad) []byte {
+	key := make([]byte, 0, (hashSize * 4))
+	key = append(key, hashOf(q.Get(d[0]))...)
+	key = append(key, hashOf(q.Get(d[1]))...)
+	key = append(key, hashOf(q.Get(d[2]))...)
+	key = append(key, hashOf(q.Get(d[3]))...)
+	return key
+}
+
+func (qs *QuadStore) createValueKeyFor(s string) []byte {
+	key := make([]byte, 0, hashSize)
+	key = append(key, hashOf(s)...)
+	return key
+}
+
+var (
+	// Short hand for direction permutations.
+	spo = [4]quad.Direction{quad.Subject, quad.Predicate, quad.Object, quad.Label}
+	osp = [4]quad.Direction{quad.Object, quad.Subject, quad.Predicate, quad.Label}
+	pos = [4]quad.Direction{quad.Predicate, quad.Object, quad.Subject, quad.Label}
+	cps = [4]quad.Direction{quad.Label, quad.Predicate, quad.Subject, quad.Object}
+
+	// Byte arrays for each bucket name.
+	spoBucket  = bucketFor(spo)
+	ospBucket  = bucketFor(osp)
+	posBucket  = bucketFor(pos)
+	cpsBucket  = bucketFor(cps)
+	logBucket  = []byte("log")
+	nodeBucket = []byte("node")
+	metaBucket = []byte("meta")
+)
+
+func deltaToProto(delta graph.Delta) proto.LogDelta {
+	var newd proto.LogDelta
+	newd.ID = uint64(delta.ID.Int())
+	newd.Action = int32(delta.Action)
+	newd.Timestamp = delta.Timestamp.UnixNano()
+	newd.Quad = &proto.Quad{
+		Subject:   delta.Quad.Subject,
+		Predicate: delta.Quad.Predicate,
+		Object:    delta.Quad.Object,
+		Label:     delta.Quad.Label,
+	}
+	return newd
+}
+
+func (qs *QuadStore) ApplyDeltas(deltas []graph.Delta, ignoreOpts graph.IgnoreOpts) error {
+	oldSize := qs.size
+	oldHorizon := qs.horizon
+	err := qs.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket(logBucket)
+		b.FillPercent = localFillPercent
+		resizeMap := make(map[string]int64)
+		sizeChange := int64(0)
+		for _, d := range deltas {
+			if d.Action != graph.Add && d.Action != graph.Delete {
+				return errors.New("bolt: invalid action")
+			}
+			p := deltaToProto(d)
+			bytes, err := p.Marshal()
+			if err != nil {
+				return err
+			}
+			err = b.Put(qs.createDeltaKeyFor(d.ID.Int()), bytes)
+			if err != nil {
+				return err
+			}
+		}
+		for _, d := range deltas {
+			err := qs.buildQuadWrite(tx, d.Quad, d.ID.Int(), d.Action == graph.Add)
+			if err != nil {
+				if err == graph.ErrQuadExists && ignoreOpts.IgnoreDup {
+					continue
+				}
+				if err == graph.ErrQuadNotExist && ignoreOpts.IgnoreMissing {
+					continue
+				}
+				return err
+			}
+			delta := int64(1)
+			if d.Action == graph.Delete {
+				delta = int64(-1)
+			}
+			resizeMap[d.Quad.Subject] += delta
+			resizeMap[d.Quad.Predicate] += delta
+			resizeMap[d.Quad.Object] += delta
+			if d.Quad.Label != "" {
+				resizeMap[d.Quad.Label] += delta
+			}
+			sizeChange += delta
+			qs.horizon = d.ID.Int()
+		}
+		for k, v := range resizeMap {
+			if v != 0 {
+				err := qs.UpdateValueKeyBy(k, v, tx)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		qs.size += sizeChange
+		return qs.WriteHorizonAndSize(tx)
+	})
+
+	if err != nil {
+		glog.Error("Couldn't write to DB for Delta set. Error: ", err)
+		qs.horizon = oldHorizon
+		qs.size = oldSize
+		return err
+	}
+	return nil
+}
+
+func (qs *QuadStore) buildQuadWrite(tx *bolt.Tx, q quad.Quad, id int64, isAdd bool) error {
+	var entry proto.HistoryEntry
+	b := tx.Bucket(spoBucket)
+	b.FillPercent = localFillPercent
+	data := b.Get(qs.createKeyFor(spo, q))
+	if data != nil {
+		// We got something.
+		err := entry.Unmarshal(data)
+		if err != nil {
+			return err
+		}
+	}
+
+	if isAdd && len(entry.History)%2 == 1 {
+		glog.Errorf("attempt to add existing quad %v: %#v", entry, q)
+		return graph.ErrQuadExists
+	}
+	if !isAdd && len(entry.History)%2 == 0 {
+		glog.Errorf("attempt to delete non-existent quad %v: %#v", entry, q)
+		return graph.ErrQuadNotExist
+	}
+
+	entry.History = append(entry.History, uint64(id))
+
+	bytes, err := entry.Marshal()
+	if err != nil {
+		glog.Errorf("Couldn't write to buffer for entry %#v: %s", entry, err)
+		return err
+	}
+	for _, index := range [][4]quad.Direction{spo, osp, pos, cps} {
+		if index == cps && q.Get(quad.Label) == "" {
+			continue
+		}
+		b := tx.Bucket(bucketFor(index))
+		b.FillPercent = localFillPercent
+		err = b.Put(qs.createKeyFor(index, q), bytes)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (qs *QuadStore) UpdateValueKeyBy(name string, amount int64, tx *bolt.Tx) error {
+	value := proto.NodeData{
+		Name:  name,
+		Size_: amount,
+	}
+	b := tx.Bucket(nodeBucket)
+	b.FillPercent = localFillPercent
+	key := qs.createValueKeyFor(name)
+	data := b.Get(key)
+
+	if data != nil {
+		// Node exists in the database -- unmarshal and update.
+		var oldvalue proto.NodeData
+		err := oldvalue.Unmarshal(data)
+		if err != nil {
+			glog.Errorf("Error: couldn't reconstruct value: %v", err)
+			return err
+		}
+		oldvalue.Size_ += amount
+		value = oldvalue
+	}
+
+	// Are we deleting something?
+	if value.Size_ <= 0 {
+		value.Size_ = 0
+	}
+
+	// Repackage and rewrite.
+	bytes, err := value.Marshal()
+	if err != nil {
+		glog.Errorf("Couldn't write to buffer for value %s: %s", name, err)
+		return err
+	}
+	err = b.Put(key, bytes)
+	return err
+}
+
+func (qs *QuadStore) WriteHorizonAndSize(tx *bolt.Tx) error {
+	buf := new(bytes.Buffer)
+	err := binary.Write(buf, binary.LittleEndian, qs.size)
+	if err != nil {
+		glog.Errorf("Couldn't convert size!")
+		return err
+	}
+	b := tx.Bucket(metaBucket)
+	b.FillPercent = localFillPercent
+	werr := b.Put([]byte("size"), buf.Bytes())
+	if werr != nil {
+		glog.Error("Couldn't write size!")
+		return werr
+	}
+	buf.Reset()
+	err = binary.Write(buf, binary.LittleEndian, qs.horizon)
+
+	if err != nil {
+		glog.Errorf("Couldn't convert horizon!")
+	}
+
+	werr = b.Put([]byte("horizon"), buf.Bytes())
+
+	if werr != nil {
+		glog.Error("Couldn't write horizon!")
+		return werr
+	}
+	return err
+}
+
+func (qs *QuadStore) Close() {
+	qs.db.Update(func(tx *bolt.Tx) error {
+		return qs.WriteHorizonAndSize(tx)
+	})
+	qs.db.Close()
+	qs.open = false
+}
+
+func (qs *QuadStore) Quad(k graph.Value) quad.Quad {
+	var d proto.LogDelta
+	tok := k.(*Token)
+	err := qs.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket(tok.bucket)
+		data := b.Get(tok.key)
+		if data == nil {
+			return nil
+		}
+		var in proto.HistoryEntry
+		err := in.Unmarshal(data)
+		if err != nil {
+			return err
+		}
+		if len(in.History) == 0 {
+			return nil
+		}
+		b = tx.Bucket(logBucket)
+		data = b.Get(qs.createDeltaKeyFor(int64(in.History[len(in.History)-1])))
+		if data == nil {
+			// No harm, no foul.
+			return nil
+		}
+		return d.Unmarshal(data)
+	})
+	if err != nil {
+		glog.Error("Error getting quad: ", err)
+		return quad.Quad{}
+	}
+	return quad.Quad{
+		d.Quad.Subject,
+		d.Quad.Predicate,
+		d.Quad.Object,
+		d.Quad.Label,
+	}
+}
+
+func (qs *QuadStore) ValueOf(s string) graph.Value {
+	return &Token{
+		bucket: nodeBucket,
+		key:    qs.createValueKeyFor(s),
+	}
+}
+
+func (qs *QuadStore) valueData(t *Token) proto.NodeData {
+	var out proto.NodeData
+	if glog.V(3) {
+		glog.V(3).Infof("%s %v", string(t.bucket), t.key)
+	}
+	err := qs.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket(t.bucket)
+		data := b.Get(t.key)
+		if data != nil {
+			return out.Unmarshal(data)
+		}
+		return nil
+	})
+	if err != nil {
+		glog.Errorln("Error: couldn't get value")
+		return proto.NodeData{}
+	}
+	return out
+}
+
+func (qs *QuadStore) NameOf(k graph.Value) string {
+	if k == nil {
+		glog.V(2).Info("k was nil")
+		return ""
+	}
+	return qs.valueData(k.(*Token)).Name
+}
+
+func (qs *QuadStore) SizeOf(k graph.Value) int64 {
+	if k == nil {
+		return -1
+	}
+	return int64(qs.valueData(k.(*Token)).Size_)
+}
+
+func getInt64ForMetaKey(tx *bolt.Tx, key string, empty int64) (int64, error) {
+	var out int64
+	b := tx.Bucket(metaBucket)
+	if b == nil {
+		return empty, errNoBucket
+	}
+	data := b.Get([]byte(key))
+	if data == nil {
+		return empty, nil
+	}
+	buf := bytes.NewBuffer(data)
+	err := binary.Read(buf, binary.LittleEndian, &out)
+	if err != nil {
+		return 0, err
+	}
+	return out, nil
+}
+
+func (qs *QuadStore) getMetadata() error {
+	err := qs.db.View(func(tx *bolt.Tx) error {
+		var err error
+		qs.size, err = getInt64ForMetaKey(tx, "size", 0)
+		if err != nil {
+			return err
+		}
+		qs.version, err = getInt64ForMetaKey(tx, "version", nilDataVersion)
+		if err != nil {
+			return err
+		}
+		qs.horizon, err = getInt64ForMetaKey(tx, "horizon", 0)
+		return err
+	})
+	return err
+}
+
+func (qs *QuadStore) QuadIterator(d quad.Direction, val graph.Value) graph.Iterator {
+	var bucket []byte
+	switch d {
+	case quad.Subject:
+		bucket = spoBucket
+	case quad.Predicate:
+		bucket = posBucket
+	case quad.Object:
+		bucket = ospBucket
+	case quad.Label:
+		bucket = cpsBucket
+	default:
+		panic("unreachable " + d.String())
+	}
+	return NewIterator(bucket, d, val, qs)
+}
+
+func (qs *QuadStore) NodesAllIterator() graph.Iterator {
+	return NewAllIterator(nodeBucket, quad.Any, qs)
+}
+
+func (qs *QuadStore) QuadsAllIterator() graph.Iterator {
+	return NewAllIterator(posBucket, quad.Predicate, qs)
+}
+
+func (qs *QuadStore) QuadDirection(val graph.Value, d quad.Direction) graph.Value {
+	v := val.(*Token)
+	offset := PositionOf(v, d, qs)
+	if offset != -1 {
+		return &Token{
+			bucket: nodeBucket,
+			key:    v.key[offset : offset+hashSize],
+		}
+	}
+	return qs.ValueOf(qs.Quad(v).Get(d))
+}
+
+func compareTokens(a, b graph.Value) bool {
+	atok := a.(*Token)
+	btok := b.(*Token)
+	return bytes.Equal(atok.key, btok.key) && bytes.Equal(atok.bucket, btok.bucket)
+}
+
+func (qs *QuadStore) FixedIterator() graph.FixedIterator {
+	return iterator.NewFixed(compareTokens)
+}
+
+func (qs *QuadStore) Type() string {
+	return QuadStoreType
+}
diff --git a/vendor/github.com/google/cayley/graph/bolt/quadstore_iterator_optimize.go b/vendor/github.com/google/cayley/graph/bolt/quadstore_iterator_optimize.go
new file mode 100644
index 00000000..7d8a2aae
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/bolt/quadstore_iterator_optimize.go
@@ -0,0 +1,55 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bolt
+
+import (
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+)
+
+func (qs *QuadStore) OptimizeIterator(it graph.Iterator) (graph.Iterator, bool) {
+	switch it.Type() {
+	case graph.LinksTo:
+		return qs.optimizeLinksTo(it.(*iterator.LinksTo))
+
+	}
+	return it, false
+}
+
+func (qs *QuadStore) optimizeLinksTo(it *iterator.LinksTo) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	if len(subs) != 1 {
+		return it, false
+	}
+	primary := subs[0]
+	if primary.Type() == graph.Fixed {
+		size, _ := primary.Size()
+		if size == 1 {
+			if !graph.Next(primary) {
+				panic("unexpected size during optimize")
+			}
+			val := primary.Result()
+			newIt := qs.QuadIterator(it.Direction(), val)
+			nt := newIt.Tagger()
+			nt.CopyFrom(it)
+			for _, tag := range primary.Tagger().Tags() {
+				nt.AddFixed(tag, val)
+			}
+			it.Close()
+			return newIt, true
+		}
+	}
+	return it, false
+}
diff --git a/vendor/github.com/google/cayley/graph/gaedatastore/iterator.go b/vendor/github.com/google/cayley/graph/gaedatastore/iterator.go
new file mode 100644
index 00000000..2992f19b
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/gaedatastore/iterator.go
@@ -0,0 +1,330 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build appengine
+
+package gaedatastore
+
+import (
+	"fmt"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+
+	"appengine/datastore"
+	"github.com/barakmich/glog"
+)
+
+type Iterator struct {
+	uid    uint64
+	size   int64
+	tags   graph.Tagger
+	dir    quad.Direction
+	qs     *QuadStore
+	name   string
+	isAll  bool
+	kind   string
+	hash   string
+	done   bool
+	buffer []string
+	offset int
+	last   string
+	result graph.Value
+	err    error
+}
+
+var (
+	bufferSize = 50
+)
+
+func NewIterator(qs *QuadStore, k string, d quad.Direction, val graph.Value) *Iterator {
+	t := val.(*Token)
+	if t == nil {
+		glog.Error("Token == nil")
+	}
+	if t.Kind != nodeKind {
+		glog.Error("Cannot create an iterator from a non-node value")
+		return &Iterator{done: true}
+	}
+	if k != nodeKind && k != quadKind {
+		glog.Error("Cannot create iterator for unknown kind")
+		return &Iterator{done: true}
+	}
+	if qs.context == nil {
+		glog.Error("Cannot create iterator without a valid context")
+		return &Iterator{done: true}
+	}
+	name := qs.NameOf(t)
+
+	// The number of references to this node is held in the nodes entity
+	key := qs.createKeyFromToken(t)
+	foundNode := new(NodeEntry)
+	err := datastore.Get(qs.context, key, foundNode)
+	if err != nil && err != datastore.ErrNoSuchEntity {
+		glog.Errorf("Error: %v", err)
+		return &Iterator{done: true}
+	}
+	size := foundNode.Size
+
+	return &Iterator{
+		uid:   iterator.NextUID(),
+		name:  name,
+		dir:   d,
+		qs:    qs,
+		size:  size,
+		isAll: false,
+		kind:  k,
+		hash:  t.Hash,
+		done:  false,
+	}
+}
+
+func NewAllIterator(qs *QuadStore, kind string) *Iterator {
+	if kind != nodeKind && kind != quadKind {
+		glog.Error("Cannot create iterator for an unknown kind")
+		return &Iterator{done: true}
+	}
+	if qs.context == nil {
+		glog.Error("Cannot create iterator without a valid context")
+		return &Iterator{done: true}
+	}
+
+	var size int64
+	if kind == nodeKind {
+		size = qs.NodeSize()
+	} else {
+		size = qs.Size()
+	}
+
+	return &Iterator{
+		uid:   iterator.NextUID(),
+		qs:    qs,
+		size:  size,
+		dir:   quad.Any,
+		isAll: true,
+		kind:  kind,
+		done:  false,
+	}
+}
+
+func (it *Iterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *Iterator) Reset() {
+	it.buffer = nil
+	it.offset = 0
+	it.done = false
+	it.last = ""
+	it.result = nil
+}
+
+func (it *Iterator) Close() error {
+	it.buffer = nil
+	it.offset = 0
+	it.done = true
+	it.last = ""
+	it.result = nil
+	return nil
+}
+
+func (it *Iterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+func (it *Iterator) Contains(v graph.Value) bool {
+	graph.ContainsLogIn(it, v)
+	if it.isAll {
+		// The result needs to be set, so when contains is called, the result can be retrieved
+		it.result = v
+		return graph.ContainsLogOut(it, v, true)
+	}
+	t := v.(*Token)
+	if t == nil {
+		glog.Error("Could not cast to token")
+		return graph.ContainsLogOut(it, v, false)
+	}
+	if t.Kind == nodeKind {
+		glog.Error("Contains does not work with node values")
+		return graph.ContainsLogOut(it, v, false)
+	}
+	// Contains is for when you want to know that an iterator refers to a quad
+	var offset int
+	switch it.dir {
+	case quad.Subject:
+		offset = 0
+	case quad.Predicate:
+		offset = (hashSize * 2)
+	case quad.Object:
+		offset = (hashSize * 2) * 2
+	case quad.Label:
+		offset = (hashSize * 2) * 3
+	}
+	val := t.Hash[offset : offset+(hashSize*2)]
+	if val == it.hash {
+		return graph.ContainsLogOut(it, v, true)
+	}
+	return graph.ContainsLogOut(it, v, false)
+}
+
+func (it *Iterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Iterator) Clone() graph.Iterator {
+	if it.isAll {
+		m := NewAllIterator(it.qs, it.kind)
+		m.tags.CopyFrom(it)
+		return m
+	}
+
+	// Create a token, the tokens kind is ignored in creation of the iterator
+	t := &Token{nodeKind, it.hash}
+	m := NewIterator(it.qs, it.kind, it.dir, t)
+	m.tags.CopyFrom(it)
+	return m
+}
+
+func (it *Iterator) NextPath() bool {
+	return false
+}
+
+// No subiterators.
+func (it *Iterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *Iterator) Result() graph.Value {
+	return it.result
+}
+
+func (it *Iterator) Next() bool {
+	if it.offset+1 < len(it.buffer) {
+		it.offset++
+		it.result = &Token{Kind: it.kind, Hash: it.buffer[it.offset]}
+		return true
+	}
+	if it.done {
+		return false
+	}
+	// Reset buffer and offset
+	it.offset = 0
+	it.buffer = make([]string, 0, bufferSize)
+	// Create query
+	// TODO (panamafrancis) Keys only query?
+	q := datastore.NewQuery(it.kind).Limit(bufferSize)
+	if !it.isAll {
+		// Filter on the direction {subject,objekt...}
+		q = q.Filter(it.dir.String()+" =", it.name)
+	}
+	// Get last cursor position
+	cursor, err := datastore.DecodeCursor(it.last)
+	if err == nil {
+		q = q.Start(cursor)
+	}
+	// Buffer the keys of the next 50 matches
+	t := q.Run(it.qs.context)
+	for {
+		// Quirk of the datastore, you cannot pass a nil value to to Next()
+		// even if you just want the keys
+		var k *datastore.Key
+		skip := false
+		if it.kind == quadKind {
+			temp := new(QuadEntry)
+			k, err = t.Next(temp)
+			// Skip if quad has been deleted
+			if len(temp.Added) <= len(temp.Deleted) {
+				skip = true
+			}
+		} else {
+			temp := new(NodeEntry)
+			k, err = t.Next(temp)
+			// Skip if node has been deleted
+			if temp.Size == 0 {
+				skip = true
+			}
+		}
+		if err == datastore.Done {
+			it.done = true
+			break
+		}
+		if err != nil {
+			glog.Errorf("Error fetching next entry %v", err)
+			it.err = err
+			return false
+		}
+		if !skip {
+			it.buffer = append(it.buffer, k.StringID())
+		}
+	}
+	// Save cursor position
+	cursor, err = t.Cursor()
+	if err == nil {
+		it.last = cursor.String()
+	}
+	// Protect against bad queries
+	if it.done && len(it.buffer) == 0 {
+		glog.Warningf("Query did not return any results")
+		return false
+	}
+	// First result
+	it.result = &Token{Kind: it.kind, Hash: it.buffer[it.offset]}
+	return true
+}
+
+func (it *Iterator) Err() error {
+	return it.err
+}
+
+func (it *Iterator) Size() (int64, bool) {
+	return it.size, true
+}
+
+var gaedatastoreType graph.Type
+
+func init() {
+	gaedatastoreType = graph.RegisterIterator("gaedatastore")
+}
+
+func Type() graph.Type                                { return gaedatastoreType }
+func (it *Iterator) Type() graph.Type                 { return gaedatastoreType }
+func (it *Iterator) Sorted() bool                     { return false }
+func (it *Iterator) Optimize() (graph.Iterator, bool) { return it, false }
+func (it *Iterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:       it.UID(),
+		Name:      fmt.Sprintf("%s/%s", it.name, it.hash),
+		Type:      it.Type(),
+		Size:      size,
+		Tags:      it.tags.Tags(),
+		Direction: it.dir,
+	}
+}
+
+// TODO (panamafrancis) calculate costs
+func (it *Iterator) Stats() graph.IteratorStats {
+	size, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     5,
+		Size:         size,
+	}
+}
+
+var _ graph.Nexter = &Iterator{}
diff --git a/vendor/github.com/google/cayley/graph/gaedatastore/quadstore.go b/vendor/github.com/google/cayley/graph/gaedatastore/quadstore.go
new file mode 100644
index 00000000..35599e59
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/gaedatastore/quadstore.go
@@ -0,0 +1,568 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build appengine
+
+package gaedatastore
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"errors"
+	"hash"
+	"math"
+	"net/http"
+	"sync"
+
+	"github.com/barakmich/glog"
+
+	"appengine"
+	"appengine/datastore"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+const (
+	QuadStoreType = "gaedatastore"
+	quadKind      = "quad"
+	nodeKind      = "node"
+)
+
+var (
+	// Order of quad fields
+	spo      = [4]quad.Direction{quad.Subject, quad.Predicate, quad.Object, quad.Label}
+	hashPool = sync.Pool{
+		New: func() interface{} { return sha1.New() },
+	}
+	hashSize = sha1.Size
+)
+
+type QuadStore struct {
+	context appengine.Context
+}
+
+type MetadataEntry struct {
+	NodeCount int64
+	QuadCount int64
+}
+
+type Token struct {
+	Kind string
+	Hash string
+}
+
+type QuadEntry struct {
+	Hash      string
+	Added     []string `datastore:",noindex"`
+	Deleted   []string `datastore:",noindex"`
+	Subject   string   `datastore:"subject"`
+	Predicate string   `datastore:"predicate"`
+	Object    string   `datastore:"object"`
+	Label     string   `datastore:"label"`
+}
+
+type NodeEntry struct {
+	Name string
+	Size int64
+}
+
+type LogEntry struct {
+	LogID     string
+	Action    string
+	Key       string
+	Timestamp int64
+}
+
+func init() {
+	graph.RegisterQuadStore("gaedatastore", graph.QuadStoreRegistration{
+		NewFunc:           newQuadStore,
+		NewForRequestFunc: newQuadStoreForRequest,
+		UpgradeFunc:       nil,
+		InitFunc:          initQuadStore,
+		IsPersistent:      true,
+	})
+}
+
+func initQuadStore(_ string, _ graph.Options) error {
+	// TODO (panamafrancis) check appengine datastore for consistency
+	return nil
+}
+
+func newQuadStore(_ string, options graph.Options) (graph.QuadStore, error) {
+	var qs QuadStore
+	return &qs, nil
+}
+
+func newQuadStoreForRequest(qs graph.QuadStore, options graph.Options) (graph.QuadStore, error) {
+	newQs, err := newQuadStore("", options)
+	if err != nil {
+		return nil, err
+	}
+	t := newQs.(*QuadStore)
+	t.context, err = getContext(options)
+	return newQs, err
+}
+
+func (qs *QuadStore) createKeyForQuad(q quad.Quad) *datastore.Key {
+	id := hashOf(q.Subject)
+	id += hashOf(q.Predicate)
+	id += hashOf(q.Object)
+	id += hashOf(q.Label)
+	return qs.createKeyFromToken(&Token{quadKind, id})
+}
+
+func (qs *QuadStore) createKeyForNode(n string) *datastore.Key {
+	id := hashOf(n)
+	return qs.createKeyFromToken(&Token{nodeKind, id})
+}
+
+func (qs *QuadStore) createKeyForMetadata() *datastore.Key {
+	return qs.createKeyFromToken(&Token{"metadata", "metadataentry"})
+}
+
+func (qs *QuadStore) createKeyForLog(deltaID graph.PrimaryKey) *datastore.Key {
+	return datastore.NewKey(qs.context, "logentry", deltaID.String(), 0, nil)
+}
+
+func (qs *QuadStore) createKeyFromToken(t *Token) *datastore.Key {
+	return datastore.NewKey(qs.context, t.Kind, t.Hash, 0, nil)
+}
+
+func (qs *QuadStore) checkValid(k *datastore.Key) (bool, error) {
+	var q quad.Quad
+	err := datastore.Get(qs.context, k, &q)
+	if err == datastore.ErrNoSuchEntity {
+		return false, nil
+	}
+	if _, ok := err.(*datastore.ErrFieldMismatch); ok {
+		return true, nil
+	}
+	if err != nil {
+		glog.Warningf("Error occured when getting quad/node %s %v", k, err)
+		return false, err
+	}
+	return true, nil
+}
+
+func getContext(opts graph.Options) (appengine.Context, error) {
+	req := opts["HTTPRequest"].(*http.Request)
+	if req == nil {
+		err := errors.New("HTTP Request needed")
+		glog.Errorln(err)
+		return nil, err
+	}
+	return appengine.NewContext(req), nil
+}
+
+func (qs *QuadStore) ApplyDeltas(in []graph.Delta, ignoreOpts graph.IgnoreOpts) error {
+	if qs.context == nil {
+		return errors.New("No context, graph not correctly initialised")
+	}
+	toKeep := make([]graph.Delta, 0)
+	for _, d := range in {
+		if d.Action != graph.Add && d.Action != graph.Delete {
+			//Defensive shortcut
+			return errors.New("Datastore: invalid action")
+		}
+		key := qs.createKeyForQuad(d.Quad)
+		keep := false
+		switch d.Action {
+		case graph.Add:
+			found, err := qs.checkValid(key)
+			if err != nil {
+				return err
+			}
+			if !found || ignoreOpts.IgnoreDup {
+				keep = true
+			} else {
+				glog.Warningf("Quad exists already: %v", d)
+			}
+		case graph.Delete:
+			found, err := qs.checkValid(key)
+			if err != nil {
+				return err
+			}
+			if found || ignoreOpts.IgnoreMissing {
+				keep = true
+			} else {
+				glog.Warningf("Quad does not exist and so cannot be deleted: %v", d)
+			}
+		default:
+			keep = false
+		}
+		if keep {
+			toKeep = append(toKeep, d)
+		}
+	}
+	if len(toKeep) == 0 {
+		return nil
+	}
+	err := qs.updateLog(toKeep)
+	if err != nil {
+		glog.Errorf("Updating log failed %v", err)
+		return err
+	}
+
+	if glog.V(2) {
+		glog.Infoln("Existence verified. Proceeding.")
+	}
+
+	quadsAdded, err := qs.updateQuads(toKeep)
+	if err != nil {
+		glog.Errorf("UpdateQuads failed %v", err)
+		return err
+	}
+	nodesAdded, err := qs.updateNodes(toKeep)
+	if err != nil {
+		glog.Warningf("UpdateNodes failed %v", err)
+		return err
+	}
+	err = qs.updateMetadata(quadsAdded, nodesAdded)
+	if err != nil {
+		glog.Warningf("UpdateMetadata failed %v", err)
+		return err
+	}
+	return nil
+}
+
+func (qs *QuadStore) updateNodes(in []graph.Delta) (int64, error) {
+	// Collate changes to each node
+	var countDelta int64
+	var nodesAdded int64
+	nodeDeltas := make(map[string]int64)
+	for _, d := range in {
+		if d.Action == graph.Add {
+			countDelta = 1
+		} else {
+			countDelta = -1
+		}
+		nodeDeltas[d.Quad.Subject] += countDelta
+		nodeDeltas[d.Quad.Object] += countDelta
+		nodeDeltas[d.Quad.Predicate] += countDelta
+		if d.Quad.Label != "" {
+			nodeDeltas[d.Quad.Label] += countDelta
+		}
+		nodesAdded += countDelta
+	}
+	// Create keys and new nodes
+	keys := make([]*datastore.Key, 0, len(nodeDeltas))
+	tempNodes := make([]NodeEntry, 0, len(nodeDeltas))
+	for k, v := range nodeDeltas {
+		keys = append(keys, qs.createKeyForNode(k))
+		tempNodes = append(tempNodes, NodeEntry{k, v})
+	}
+	// In accordance with the appengine datastore spec, cross group transactions
+	// like these can only be done in batches of 5
+	for i := 0; i < len(nodeDeltas); i += 5 {
+		j := int(math.Min(float64(len(nodeDeltas)-i), 5))
+		foundNodes := make([]NodeEntry, j)
+		err := datastore.RunInTransaction(qs.context, func(c appengine.Context) error {
+			err := datastore.GetMulti(c, keys[i:i+j], foundNodes)
+			// Sift through for errors
+			if me, ok := err.(appengine.MultiError); ok {
+				for _, merr := range me {
+					if merr != nil && merr != datastore.ErrNoSuchEntity {
+						glog.Errorf("Error: %v", merr)
+						return merr
+					}
+				}
+			}
+			// Carry forward the sizes of the nodes from the datastore
+			for k, _ := range foundNodes {
+				if foundNodes[k].Name != "" {
+					tempNodes[i+k].Size += foundNodes[k].Size
+				}
+			}
+			_, err = datastore.PutMulti(c, keys[i:i+j], tempNodes[i:i+j])
+			return err
+		}, &datastore.TransactionOptions{XG: true})
+		if err != nil {
+			glog.Errorf("Error: %v", err)
+			return 0, err
+		}
+	}
+
+	return nodesAdded, nil
+}
+
+func (qs *QuadStore) updateQuads(in []graph.Delta) (int64, error) {
+	keys := make([]*datastore.Key, 0, len(in))
+	for _, d := range in {
+		keys = append(keys, qs.createKeyForQuad(d.Quad))
+	}
+	var quadCount int64
+	for i := 0; i < len(in); i += 5 {
+		// Find the closest batch of 5
+		j := int(math.Min(float64(len(in)-i), 5))
+		err := datastore.RunInTransaction(qs.context, func(c appengine.Context) error {
+			foundQuads := make([]QuadEntry, j)
+			// We don't process errors from GetMulti as they don't mean anything,
+			// we've handled existing quad conflicts above and we overwrite everything again anyways
+			datastore.GetMulti(c, keys, foundQuads)
+			for k, _ := range foundQuads {
+				x := i + k
+				foundQuads[k].Hash = keys[x].StringID()
+				foundQuads[k].Subject = in[x].Quad.Subject
+				foundQuads[k].Predicate = in[x].Quad.Predicate
+				foundQuads[k].Object = in[x].Quad.Object
+				foundQuads[k].Label = in[x].Quad.Label
+
+				// If the quad exists the Added[] will be non-empty
+				if in[x].Action == graph.Add {
+					foundQuads[k].Added = append(foundQuads[k].Added, in[x].ID.String())
+					quadCount += 1
+				} else {
+					foundQuads[k].Deleted = append(foundQuads[k].Deleted, in[x].ID.String())
+					quadCount -= 1
+				}
+			}
+			_, err := datastore.PutMulti(c, keys[i:i+j], foundQuads)
+			return err
+		}, &datastore.TransactionOptions{XG: true})
+		if err != nil {
+			return 0, err
+		}
+	}
+	return quadCount, nil
+}
+
+func (qs *QuadStore) updateMetadata(quadsAdded int64, nodesAdded int64) error {
+	key := qs.createKeyForMetadata()
+	foundMetadata := new(MetadataEntry)
+	err := datastore.RunInTransaction(qs.context, func(c appengine.Context) error {
+		err := datastore.Get(c, key, foundMetadata)
+		if err != nil && err != datastore.ErrNoSuchEntity {
+			glog.Errorf("Error: %v", err)
+			return err
+		}
+		foundMetadata.QuadCount += quadsAdded
+		foundMetadata.NodeCount += nodesAdded
+		_, err = datastore.Put(c, key, foundMetadata)
+		if err != nil {
+			glog.Errorf("Error: %v", err)
+		}
+		return err
+	}, nil)
+	return err
+}
+
+func (qs *QuadStore) updateLog(in []graph.Delta) error {
+	if qs.context == nil {
+		err := errors.New("Error updating log, context is nil, graph not correctly initialised")
+		return err
+	}
+	if len(in) == 0 {
+		return errors.New("Nothing to log")
+	}
+	logEntries := make([]LogEntry, 0, len(in))
+	logKeys := make([]*datastore.Key, 0, len(in))
+	for _, d := range in {
+		var action string
+		if d.Action == graph.Add {
+			action = "Add"
+		} else {
+			action = "Delete"
+		}
+
+		entry := LogEntry{
+			LogID:     d.ID.String(),
+			Action:    action,
+			Key:       qs.createKeyForQuad(d.Quad).String(),
+			Timestamp: d.Timestamp.UnixNano(),
+		}
+		logEntries = append(logEntries, entry)
+		logKeys = append(logKeys, qs.createKeyForLog(d.ID))
+	}
+
+	_, err := datastore.PutMulti(qs.context, logKeys, logEntries)
+	if err != nil {
+		glog.Errorf("Error updating log: %v", err)
+	}
+	return err
+}
+
+func (qs *QuadStore) QuadIterator(dir quad.Direction, v graph.Value) graph.Iterator {
+	return NewIterator(qs, quadKind, dir, v)
+}
+
+func (qs *QuadStore) NodesAllIterator() graph.Iterator {
+	return NewAllIterator(qs, nodeKind)
+}
+
+func (qs *QuadStore) QuadsAllIterator() graph.Iterator {
+	return NewAllIterator(qs, quadKind)
+}
+
+func (qs *QuadStore) ValueOf(s string) graph.Value {
+	id := hashOf(s)
+	return &Token{Kind: nodeKind, Hash: id}
+}
+
+func (qs *QuadStore) NameOf(val graph.Value) string {
+	if qs.context == nil {
+		glog.Error("Error in NameOf, context is nil, graph not correctly initialised")
+		return ""
+	}
+	var key *datastore.Key
+	if t, ok := val.(*Token); ok && t.Kind == nodeKind {
+		key = qs.createKeyFromToken(t)
+	} else {
+		glog.Error("Token not valid")
+		return ""
+	}
+
+	// TODO (panamafrancis) implement a cache
+
+	node := new(NodeEntry)
+	err := datastore.Get(qs.context, key, node)
+	if err != nil {
+		glog.Errorf("Error: %v", err)
+		return ""
+	}
+	return node.Name
+}
+
+func (qs *QuadStore) Quad(val graph.Value) quad.Quad {
+	if qs.context == nil {
+		glog.Error("Error fetching quad, context is nil, graph not correctly initialised")
+		return quad.Quad{}
+	}
+	var key *datastore.Key
+	if t, ok := val.(*Token); ok && t.Kind == quadKind {
+		key = qs.createKeyFromToken(t)
+	} else {
+		glog.Error("Token not valid")
+		return quad.Quad{}
+	}
+
+	q := new(QuadEntry)
+	err := datastore.Get(qs.context, key, q)
+	if err != nil {
+		// Red herring error : ErrFieldMismatch can happen when a quad exists but a field is empty
+		if _, ok := err.(*datastore.ErrFieldMismatch); !ok {
+			glog.Errorf("Error: %v", err)
+		}
+	}
+	return quad.Quad{
+		Subject:   q.Subject,
+		Predicate: q.Predicate,
+		Object:    q.Object,
+		Label:     q.Label}
+}
+
+func (qs *QuadStore) Size() int64 {
+	if qs.context == nil {
+		glog.Error("Error fetching size, context is nil, graph not correctly initialised")
+		return 0
+	}
+	key := qs.createKeyForMetadata()
+	foundMetadata := new(MetadataEntry)
+	err := datastore.Get(qs.context, key, foundMetadata)
+	if err != nil {
+		glog.Warningf("Error: %v", err)
+		return 0
+	}
+	return foundMetadata.QuadCount
+}
+
+func (qs *QuadStore) NodeSize() int64 {
+	if qs.context == nil {
+		glog.Error("Error fetching node size, context is nil, graph not correctly initialised")
+		return 0
+	}
+	key := qs.createKeyForMetadata()
+	foundMetadata := new(MetadataEntry)
+	err := datastore.Get(qs.context, key, foundMetadata)
+	if err != nil {
+		glog.Warningf("Error: %v", err)
+		return 0
+	}
+	return foundMetadata.NodeCount
+}
+
+func (qs *QuadStore) Horizon() graph.PrimaryKey {
+	if qs.context == nil {
+		glog.Warning("Warning: HTTP Request context is nil, cannot get horizon from datastore.")
+		return graph.NewUniqueKey("")
+	}
+	// Query log for last entry...
+	q := datastore.NewQuery("logentry").Order("-Timestamp").Limit(1)
+	var logEntries []LogEntry
+	_, err := q.GetAll(qs.context, &logEntries)
+	if err != nil || len(logEntries) == 0 {
+		// Error fetching horizon, probably graph is empty
+		return graph.NewUniqueKey("")
+	}
+	return graph.NewUniqueKey(logEntries[0].LogID)
+}
+
+func compareTokens(a, b graph.Value) bool {
+	atok := a.(*Token)
+	btok := b.(*Token)
+	return atok.Kind == btok.Kind && atok.Hash == btok.Hash
+}
+
+func (qs *QuadStore) FixedIterator() graph.FixedIterator {
+	return iterator.NewFixed(compareTokens)
+}
+
+func (qs *QuadStore) OptimizeIterator(it graph.Iterator) (graph.Iterator, bool) {
+	return nil, false
+}
+
+func (qs *QuadStore) Close() {
+	qs.context = nil
+}
+
+func (qs *QuadStore) QuadDirection(val graph.Value, dir quad.Direction) graph.Value {
+	t, ok := val.(*Token)
+	if !ok {
+		glog.Error("Token not valid")
+		return nil
+	}
+	if t.Kind == nodeKind {
+		glog.Error("Node tokens not valid")
+		return nil
+	}
+	var offset int
+	switch dir {
+	case quad.Subject:
+		offset = 0
+	case quad.Predicate:
+		offset = (hashSize * 2)
+	case quad.Object:
+		offset = (hashSize * 2) * 2
+	case quad.Label:
+		offset = (hashSize * 2) * 3
+	}
+	sub := t.Hash[offset : offset+(hashSize*2)]
+	return &Token{Kind: nodeKind, Hash: sub}
+}
+
+func hashOf(s string) string {
+	h := hashPool.Get().(hash.Hash)
+	h.Reset()
+	defer hashPool.Put(h)
+
+	key := make([]byte, 0, hashSize)
+	h.Write([]byte(s))
+	key = h.Sum(key)
+	return hex.EncodeToString(key)
+}
+
+func (qs *QuadStore) Type() string {
+	return QuadStoreType
+}
diff --git a/vendor/github.com/google/cayley/graph/iterator.go b/vendor/github.com/google/cayley/graph/iterator.go
new file mode 100644
index 00000000..c2d46d9e
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator.go
@@ -0,0 +1,366 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package graph
+
+// Define the general iterator interface.
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/quad"
+)
+
+type Tagger struct {
+	tags      []string
+	fixedTags map[string]Value
+}
+
+// TODO(barakmich): Linkage is general enough that there are places we take
+//the combined arguments `quad.Direction, graph.Value` that it may be worth
+//converting these into Linkages. If nothing else, future indexed iterators may
+//benefit from the shared representation
+
+// Linkage is a union type representing a set of values established for a given
+// quad direction.
+type Linkage struct {
+	Dir   quad.Direction
+	Value Value
+}
+
+// TODO(barakmich): Helper functions as needed, eg, ValuesForDirection(quad.Direction) []Value
+
+// Add a tag to the iterator.
+func (t *Tagger) Add(tag string) {
+	t.tags = append(t.tags, tag)
+}
+
+func (t *Tagger) AddFixed(tag string, value Value) {
+	if t.fixedTags == nil {
+		t.fixedTags = make(map[string]Value)
+	}
+	t.fixedTags[tag] = value
+}
+
+// Tags returns the tags held in the tagger. The returned value must not be mutated.
+func (t *Tagger) Tags() []string {
+	return t.tags
+}
+
+// Fixed returns the fixed tags held in the tagger. The returned value must not be mutated.
+func (t *Tagger) Fixed() map[string]Value {
+	return t.fixedTags
+}
+
+func (t *Tagger) CopyFrom(src Iterator) {
+	t.CopyFromTagger(src.Tagger())
+}
+
+func (t *Tagger) CopyFromTagger(st *Tagger) {
+	t.tags = append(t.tags, st.tags...)
+
+	if t.fixedTags == nil {
+		t.fixedTags = make(map[string]Value, len(st.fixedTags))
+	}
+	for k, v := range st.fixedTags {
+		t.fixedTags[k] = v
+	}
+}
+
+type Iterator interface {
+	Tagger() *Tagger
+
+	// Fills a tag-to-result-value map.
+	TagResults(map[string]Value)
+
+	// Returns the current result.
+	Result() Value
+
+	// These methods are the heart and soul of the iterator, as they constitute
+	// the iteration interface.
+	//
+	// To get the full results of iteration, do the following:
+	//
+	//  for graph.Next(it) {
+	//  	val := it.Result()
+	//  	... do things with val.
+	//  	for it.NextPath() {
+	//  		... find other paths to iterate
+	//  	}
+	//  }
+	//
+	// All of them should set iterator.Last to be the last returned value, to
+	// make results work.
+	//
+	// NextPath() advances iterators that may have more than one valid result,
+	// from the bottom up.
+	NextPath() bool
+
+	// Contains returns whether the value is within the set held by the iterator.
+	Contains(Value) bool
+
+	// Err returns any error that was encountered by the Iterator.
+	Err() error
+
+	// Start iteration from the beginning
+	Reset()
+
+	// Create a new iterator just like this one
+	Clone() Iterator
+
+	// These methods relate to choosing the right iterator, or optimizing an
+	// iterator tree
+	//
+	// Stats() returns the relative costs of calling the iteration methods for
+	// this iterator, as well as the size. Roughly, it will take NextCost * Size
+	// "cost units" to get everything out of the iterator. This is a wibbly-wobbly
+	// thing, and not exact, but a useful heuristic.
+	Stats() IteratorStats
+
+	// Helpful accessor for the number of things in the iterator. The first return
+	// value is the size, and the second return value is whether that number is exact,
+	// or a conservative estimate.
+	Size() (int64, bool)
+
+	// Returns a string relating to what the function of the iterator is. By
+	// knowing the names of the iterators, we can devise optimization strategies.
+	Type() Type
+
+	// Optimizes an iterator. Can replace the iterator, or merely move things
+	// around internally. if it chooses to replace it with a better iterator,
+	// returns (the new iterator, true), if not, it returns (self, false).
+	Optimize() (Iterator, bool)
+
+	// Return a slice of the subiterators for this iterator.
+	SubIterators() []Iterator
+
+	// Return a string representation of the iterator.
+	Describe() Description
+
+	// Close the iterator and do internal cleanup.
+	Close() error
+
+	// UID returns the unique identifier of the iterator.
+	UID() uint64
+}
+
+type Description struct {
+	UID       uint64         `json:",omitempty"`
+	Name      string         `json:",omitempty"`
+	Type      Type           `json:",omitempty"`
+	Tags      []string       `json:",omitempty"`
+	Size      int64          `json:",omitempty"`
+	Direction quad.Direction `json:",omitempty"`
+	Iterator  *Description   `json:",omitempty"`
+	Iterators []Description  `json:",omitempty"`
+}
+
+// ApplyMorphism is a curried function that can generates a new iterator based on some prior iterator.
+type ApplyMorphism func(QuadStore, Iterator) Iterator
+
+type Nexter interface {
+	// Next advances the iterator to the next value, which will then be available through
+	// the Result method. It returns false if no further advancement is possible, or if an
+	// error was encountered during iteration.  Err should be consulted to distinguish
+	// between the two cases.
+	Next() bool
+
+	Iterator
+}
+
+// Next is a convenience function that conditionally calls the Next method
+// of an Iterator if it is a Nexter. If the Iterator is not a Nexter, Next
+// returns false.
+func Next(it Iterator) bool {
+	if n, ok := it.(Nexter); ok {
+		return n.Next()
+	}
+	glog.Errorln("Nexting an un-nextable iterator")
+	return false
+}
+
+// Height is a convienence function to measure the height of an iterator tree.
+func Height(it Iterator, until Type) int {
+	if it.Type() == until {
+		return 1
+	}
+	subs := it.SubIterators()
+	maxDepth := 0
+	for _, sub := range subs {
+		h := Height(sub, until)
+		if h > maxDepth {
+			maxDepth = h
+		}
+	}
+	return maxDepth + 1
+}
+
+// FixedIterator wraps iterators that are modifiable by addition of fixed value sets.
+type FixedIterator interface {
+	Iterator
+	Add(Value)
+}
+
+type IteratorStats struct {
+	ContainsCost int64
+	NextCost     int64
+	Size         int64
+	Next         int64
+	Contains     int64
+	ContainsNext int64
+}
+
+// Type enumerates the set of Iterator types.
+type Type int
+
+// These are the iterator types, defined as constants
+const (
+	Invalid Type = iota
+	All
+	And
+	Or
+	HasA
+	LinksTo
+	Comparison
+	Null
+	Fixed
+	Not
+	Optional
+	Materialize
+	Unique
+)
+
+var (
+	// We use a sync.Mutex rather than an RWMutex since the client packages keep
+	// the Type that was returned, so the only possibility for contention is at
+	// initialization.
+	lock sync.Mutex
+	// These strings must be kept in order consistent with the Type const block above.
+	types = []string{
+		"invalid",
+		"all",
+		"and",
+		"or",
+		"hasa",
+		"linksto",
+		"comparison",
+		"null",
+		"fixed",
+		"not",
+		"optional",
+		"materialize",
+		"unique",
+	}
+)
+
+// RegisterIterator adds a new iterator type to the set of acceptable types, returning
+// the registered Type.
+// Calls to Register are idempotent and must be made prior to use of the iterator.
+// The conventional approach for use is to include a call to Register in a package
+// init() function, saving the Type to a private package var.
+func RegisterIterator(name string) Type {
+	lock.Lock()
+	defer lock.Unlock()
+	for i, t := range types {
+		if t == name {
+			return Type(i)
+		}
+	}
+	types = append(types, name)
+	return Type(len(types) - 1)
+}
+
+// String returns a string representation of the Type.
+func (t Type) String() string {
+	if t < 0 || int(t) >= len(types) {
+		return "illegal-type"
+	}
+	return types[t]
+}
+
+func (t *Type) MarshalText() (text []byte, err error) {
+	if *t < 0 || int(*t) >= len(types) {
+		return nil, fmt.Errorf("graph: illegal iterator type: %d", *t)
+	}
+	return []byte(types[*t]), nil
+}
+
+func (t *Type) UnmarshalText(text []byte) error {
+	s := string(text)
+	for i, c := range types[1:] {
+		if c == s {
+			*t = Type(i + 1)
+			return nil
+		}
+	}
+	return fmt.Errorf("graph: unknown iterator label: %q", text)
+}
+
+type StatsContainer struct {
+	UID  uint64
+	Type Type
+	IteratorStats
+	SubIts []StatsContainer
+}
+
+func DumpStats(it Iterator) StatsContainer {
+	var out StatsContainer
+	out.IteratorStats = it.Stats()
+	out.Type = it.Type()
+	out.UID = it.UID()
+	for _, sub := range it.SubIterators() {
+		out.SubIts = append(out.SubIts, DumpStats(sub))
+	}
+	return out
+}
+
+// Utility logging functions for when an iterator gets called Next upon, or Contains upon, as
+// well as what they return. Highly useful for tracing the execution path of a query.
+
+func ContainsLogIn(it Iterator, val Value) {
+	if glog.V(4) {
+		glog.V(4).Infof("%s %d CHECK CONTAINS %v", strings.ToUpper(it.Type().String()), it.UID(), val)
+	}
+}
+
+func ContainsLogOut(it Iterator, val Value, good bool) bool {
+	if glog.V(4) {
+		if good {
+			glog.V(4).Infof("%s %d CHECK CONTAINS %v GOOD", strings.ToUpper(it.Type().String()), it.UID(), val)
+		} else {
+			glog.V(4).Infof("%s %d CHECK CONTAINS %v BAD", strings.ToUpper(it.Type().String()), it.UID(), val)
+		}
+	}
+	return good
+}
+
+func NextLogIn(it Iterator) {
+	if glog.V(4) {
+		glog.V(4).Infof("%s %d NEXT", strings.ToUpper(it.Type().String()), it.UID())
+	}
+}
+
+func NextLogOut(it Iterator, val Value, ok bool) bool {
+	if glog.V(4) {
+		if ok {
+			glog.V(4).Infof("%s %d NEXT IS %v", strings.ToUpper(it.Type().String()), it.UID(), val)
+		} else {
+			glog.V(4).Infof("%s %d NEXT DONE", strings.ToUpper(it.Type().String()), it.UID())
+		}
+	}
+	return ok
+}
diff --git a/vendor/github.com/google/cayley/graph/iterator/all_iterator.go b/vendor/github.com/google/cayley/graph/iterator/all_iterator.go
new file mode 100644
index 00000000..048a7b34
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/all_iterator.go
@@ -0,0 +1,165 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// Defines one of the base iterators, the All iterator. Which, logically
+// enough, represents all nodes or all links in the graph.
+//
+// This particular file is actually vestigial. It's up to the QuadStore to give
+// us an All iterator that represents all things in the graph. So this is
+// really the All iterator for the memstore.QuadStore. That said, it *is* one of
+// the base iterators, and it helps just to see it here.
+
+import (
+	"github.com/google/cayley/graph"
+)
+
+// An All iterator across a range of int64 values, from `max` to `min`.
+type Int64 struct {
+	uid      uint64
+	tags     graph.Tagger
+	max, min int64
+	at       int64
+	result   graph.Value
+	runstats graph.IteratorStats
+}
+
+// Creates a new Int64 with the given range.
+func NewInt64(min, max int64) *Int64 {
+	return &Int64{
+		uid: NextUID(),
+		min: min,
+		max: max,
+		at:  min,
+	}
+}
+
+func (it *Int64) UID() uint64 {
+	return it.uid
+}
+
+// Start back at the beginning
+func (it *Int64) Reset() {
+	it.at = it.min
+}
+
+func (it *Int64) Close() error {
+	return nil
+}
+
+func (it *Int64) Clone() graph.Iterator {
+	out := NewInt64(it.min, it.max)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+func (it *Int64) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// Fill the map based on the tags assigned to this iterator.
+func (it *Int64) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Int64) Describe() graph.Description {
+	return graph.Description{
+		UID:  it.UID(),
+		Type: it.Type(),
+		Tags: it.tags.Tags(),
+	}
+}
+
+// Next() on an Int64 all iterator is a simple incrementing counter.
+// Return the next integer, and mark it as the result.
+func (it *Int64) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+	if it.at == -1 {
+		return graph.NextLogOut(it, nil, false)
+	}
+	val := it.at
+	it.at = it.at + 1
+	if it.at > it.max {
+		it.at = -1
+	}
+	it.result = val
+	return graph.NextLogOut(it, val, true)
+}
+
+func (it *Int64) Err() error {
+	return nil
+}
+
+func (it *Int64) Result() graph.Value {
+	return it.result
+}
+
+func (it *Int64) NextPath() bool {
+	return false
+}
+
+// No sub-iterators.
+func (it *Int64) SubIterators() []graph.Iterator {
+	return nil
+}
+
+// The number of elements in an Int64 is the size of the range.
+// The size is exact.
+func (it *Int64) Size() (int64, bool) {
+	Size := ((it.max - it.min) + 1)
+	return Size, true
+}
+
+// Contains() for an Int64 is merely seeing if the passed value is
+// withing the range, assuming the value is an int64.
+func (it *Int64) Contains(tsv graph.Value) bool {
+	graph.ContainsLogIn(it, tsv)
+	it.runstats.Contains += 1
+	v := tsv.(int64)
+	if it.min <= v && v <= it.max {
+		it.result = v
+		return graph.ContainsLogOut(it, v, true)
+	}
+	return graph.ContainsLogOut(it, v, false)
+}
+
+// The type of this iterator is an "all". This is important, as it puts it in
+// the class of "all iterators.
+func (it *Int64) Type() graph.Type { return graph.All }
+
+// There's nothing to optimize about this little iterator.
+func (it *Int64) Optimize() (graph.Iterator, bool) { return it, false }
+
+// Stats for an Int64 are simple. Super cheap to do any operation,
+// and as big as the range.
+func (it *Int64) Stats() graph.IteratorStats {
+	s, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     1,
+		Size:         s,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+	}
+}
+
+var _ graph.Nexter = &Int64{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/and_iterator.go b/vendor/github.com/google/cayley/graph/iterator/and_iterator.go
new file mode 100644
index 00000000..26f47494
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/and_iterator.go
@@ -0,0 +1,301 @@
+// Defines the And iterator, one of the base iterators. And requires no
+// knowledge of the constituent QuadStore; its sole purpose is to act as an
+// intersection operator across the subiterators it is given. If one iterator
+// contains [1,3,5] and another [2,3,4] -- then And is an iterator that
+// 'contains' [3]
+//
+// It accomplishes this in one of two ways. If it is a Next()ed iterator (that
+// is, it is a top level iterator, or on the "Next() path", then it will Next()
+// it's primary iterator (helpfully, and.primary_it) and Contains() the resultant
+// value against it's other iterators. If it matches all of them, then it
+// returns that value. Otherwise, it repeats the process.
+//
+// If it's on a Contains() path, it merely Contains()s every iterator, and returns the
+// logical AND of each result.
+
+package iterator
+
+import (
+	"github.com/google/cayley/graph"
+)
+
+// The And iterator. Consists of a number of subiterators, the primary of which will
+// be Next()ed if next is called.
+type And struct {
+	uid               uint64
+	tags              graph.Tagger
+	internalIterators []graph.Iterator
+	itCount           int
+	primaryIt         graph.Iterator
+	checkList         []graph.Iterator
+	result            graph.Value
+	runstats          graph.IteratorStats
+	err               error
+	qs                graph.QuadStore
+}
+
+// NewAnd creates an And iterator. `qs` is only required when needing a handle
+// for QuadStore-specific optimizations, otherwise nil is acceptable.
+func NewAnd(qs graph.QuadStore) *And {
+	return &And{
+		uid:               NextUID(),
+		internalIterators: make([]graph.Iterator, 0, 20),
+		qs:                qs,
+	}
+}
+
+func (it *And) UID() uint64 {
+	return it.uid
+}
+
+// Reset all internal iterators
+func (it *And) Reset() {
+	it.result = nil
+	it.primaryIt.Reset()
+	for _, sub := range it.internalIterators {
+		sub.Reset()
+	}
+	it.checkList = nil
+}
+
+func (it *And) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// An extended TagResults, as it needs to add it's own results and
+// recurse down it's subiterators.
+func (it *And) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	if it.primaryIt != nil {
+		it.primaryIt.TagResults(dst)
+	}
+	for _, sub := range it.internalIterators {
+		sub.TagResults(dst)
+	}
+}
+
+func (it *And) Clone() graph.Iterator {
+	and := NewAnd(it.qs)
+	and.AddSubIterator(it.primaryIt.Clone())
+	and.tags.CopyFrom(it)
+	for _, sub := range it.internalIterators {
+		and.AddSubIterator(sub.Clone())
+	}
+	if it.checkList != nil {
+		and.optimizeContains()
+	}
+	return and
+}
+
+// Returns a slice of the subiterators, in order (primary iterator first).
+func (it *And) SubIterators() []graph.Iterator {
+	iters := make([]graph.Iterator, len(it.internalIterators)+1)
+	iters[0] = it.primaryIt
+	copy(iters[1:], it.internalIterators)
+	return iters
+}
+
+func (it *And) Describe() graph.Description {
+	subIts := make([]graph.Description, len(it.internalIterators))
+	for i, sub := range it.internalIterators {
+		subIts[i] = sub.Describe()
+	}
+	primary := it.primaryIt.Describe()
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Iterator:  &primary,
+		Iterators: subIts,
+	}
+}
+
+// Add a subiterator to this And iterator.
+//
+// The first iterator that is added becomes the primary iterator. This is
+// important. Calling Optimize() is the way to change the order based on
+// subiterator statistics. Without Optimize(), the order added is the order
+// used.
+func (it *And) AddSubIterator(sub graph.Iterator) {
+	if it.itCount > 0 {
+		it.internalIterators = append(it.internalIterators, sub)
+		it.itCount++
+		return
+	}
+	it.primaryIt = sub
+	it.itCount++
+}
+
+// Returns advances the And iterator. Because the And is the intersection of its
+// subiterators, it must choose one subiterator to produce a candidate, and check
+// this value against the subiterators. A productive choice of primary iterator
+// is therefore very important.
+func (it *And) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+	for graph.Next(it.primaryIt) {
+		curr := it.primaryIt.Result()
+		if it.subItsContain(curr, nil) {
+			it.result = curr
+			return graph.NextLogOut(it, curr, true)
+		}
+	}
+	it.err = it.primaryIt.Err()
+	return graph.NextLogOut(it, nil, false)
+}
+
+func (it *And) Err() error {
+	return it.err
+}
+
+func (it *And) Result() graph.Value {
+	return it.result
+}
+
+// Checks a value against the non-primary iterators, in order.
+func (it *And) subItsContain(val graph.Value, lastResult graph.Value) bool {
+	var subIsGood = true
+	for i, sub := range it.internalIterators {
+		subIsGood = sub.Contains(val)
+		if !subIsGood {
+			if lastResult != nil {
+				for j := 0; j < i; j++ {
+					it.internalIterators[j].Contains(lastResult)
+				}
+			}
+			break
+		}
+	}
+	return subIsGood
+}
+
+func (it *And) checkContainsList(val graph.Value, lastResult graph.Value) bool {
+	ok := true
+	for i, c := range it.checkList {
+		ok = c.Contains(val)
+		if !ok {
+			it.err = c.Err()
+			if it.err != nil {
+				return false
+			}
+
+			if lastResult != nil {
+				for j := 0; j < i; j++ {
+					// One of the iterators has determined that this value doesn't
+					// match. However, the iterators that came before in the list
+					// may have returned "ok" to Contains().  We need to set all
+					// the tags back to what the previous result was -- effectively
+					// seeking back exactly one -- so we check all the prior iterators
+					// with the (already verified) result and throw away the result,
+					// which will be 'true'
+					it.checkList[j].Contains(lastResult)
+
+					it.err = it.checkList[j].Err()
+					if it.err != nil {
+						return false
+					}
+				}
+			}
+			break
+		}
+	}
+	if ok {
+		it.result = val
+	}
+	return graph.ContainsLogOut(it, val, ok)
+}
+
+// Check a value against the entire iterator, in order.
+func (it *And) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	it.runstats.Contains += 1
+	lastResult := it.result
+	if it.checkList != nil {
+		return it.checkContainsList(val, lastResult)
+	}
+	mainGood := it.primaryIt.Contains(val)
+	if mainGood {
+		othersGood := it.subItsContain(val, lastResult)
+		if othersGood {
+			it.result = val
+			return graph.ContainsLogOut(it, val, true)
+		}
+	}
+	if lastResult != nil {
+		it.primaryIt.Contains(lastResult)
+	}
+	return graph.ContainsLogOut(it, val, false)
+}
+
+// Returns the approximate size of the And iterator. Because we're dealing
+// with an intersection, we know that the largest we can be is the size of the
+// smallest iterator. This is the heuristic we shall follow. Better heuristics
+// welcome.
+func (it *And) Size() (int64, bool) {
+	val, b := it.primaryIt.Size()
+	for _, sub := range it.internalIterators {
+		newval, newb := sub.Size()
+		if val > newval {
+			val = newval
+		}
+		b = newb && b
+	}
+	return val, b
+}
+
+// An And has no NextPath of its own -- that is, there are no other values
+// which satisfy our previous result that are not the result itself. Our
+// subiterators might, however, so just pass the call recursively.
+func (it *And) NextPath() bool {
+	if it.primaryIt.NextPath() {
+		return true
+	}
+	it.err = it.primaryIt.Err()
+	if it.err != nil {
+		return false
+	}
+	for _, sub := range it.internalIterators {
+		if sub.NextPath() {
+			return true
+		}
+
+		it.err = sub.Err()
+		if it.err != nil {
+			return false
+		}
+	}
+	return false
+}
+
+// Perform and-specific cleanup, of which there currently is none.
+func (it *And) cleanUp() {}
+
+// Close this iterator, and, by extension, close the subiterators.
+// Close should be idempotent, and it follows that if it's subiterators
+// follow this contract, the And follows the contract.  It closes all
+// subiterators it can, but returns the first error it encounters.
+func (it *And) Close() error {
+	it.cleanUp()
+
+	err := it.primaryIt.Close()
+	for _, sub := range it.internalIterators {
+		_err := sub.Close()
+		if _err != nil && err == nil {
+			err = _err
+		}
+	}
+
+	return err
+}
+
+// Register this as an "and" iterator.
+func (it *And) Type() graph.Type { return graph.And }
+
+var _ graph.Nexter = &And{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/and_iterator_optimize.go b/vendor/github.com/google/cayley/graph/iterator/and_iterator_optimize.go
new file mode 100644
index 00000000..10aa803b
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/and_iterator_optimize.go
@@ -0,0 +1,375 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+import (
+	"sort"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+)
+
+// Perhaps the most tricky file in this entire module. Really a method on the
+// And, but important enough to deserve its own file.
+//
+// Calling Optimize() on an And iterator, like any iterator, requires that we
+// preserve the underlying meaning. However, the And has many choices, namely,
+// which one of it's subiterators will be the branch that does the Next()ing,
+// and which ordering of the remaining iterators is the most efficient. In
+// short, this is where a lot of the query optimization happens, and there are
+// many wins to be had here, as well as many bad bugs. The worst class of bug
+// changes the meaning of the query. The second worst class makes things really
+// slow.
+//
+// The good news is this: If Optimize() is never called (turned off, perhaps) we can
+// be sure the results are as good as the query language called for.
+//
+// In short, tread lightly.
+
+// Optimizes the And, by picking the most efficient way to Next() and
+// Contains() its subiterators. For SQL fans, this is equivalent to JOIN.
+func (it *And) Optimize() (graph.Iterator, bool) {
+	// First, let's get the slice of iterators, in order (first one is Next()ed,
+	// the rest are Contains()ed)
+	old := it.SubIterators()
+
+	// And call Optimize() on our subtree, replacing each one in the order we
+	// found them. it_list is the newly optimized versions of these, and changed
+	// is another list, of only the ones that have returned replacements and
+	// changed.
+	its := optimizeSubIterators(old)
+
+	// Close the replaced iterators (they ought to close themselves, but Close()
+	// is idempotent, so this just protects against any machinations).
+	closeIteratorList(old, nil)
+
+	// If we can find only one subiterator which is equivalent to this whole and,
+	// we can replace the And...
+	out := it.optimizeReplacement(its)
+	if out != nil {
+		// ...Move the tags to the replacement...
+		moveTagsTo(out, it)
+		// ...Close everyone except `out`, our replacement...
+		closeIteratorList(its, out)
+		// ...And return it.
+		return out, true
+	}
+
+	// And now, without changing any of the iterators, we reorder them. it_list is
+	// now a permutation of itself, but the contents are unchanged.
+	its = it.optimizeOrder(its)
+
+	its = materializeIts(its)
+
+	// Okay! At this point we have an optimized order.
+
+	// The easiest thing to do at this point is merely to create a new And iterator
+	// and replace ourselves with our (reordered, optimized) clone.
+	newAnd := NewAnd(it.qs)
+
+	// Add the subiterators in order.
+	for _, sub := range its {
+		newAnd.AddSubIterator(sub)
+	}
+
+	// Move the tags hanging on us (like any good replacement).
+	newAnd.tags.CopyFrom(it)
+
+	newAnd.optimizeContains()
+	glog.V(3).Infoln(it.UID(), "became", newAnd.UID())
+
+	// And close ourselves but not our subiterators -- some may still be alive in
+	// the new And (they were unchanged upon calling Optimize() on them, at the
+	// start).
+	it.cleanUp()
+
+	// Ask the graph.QuadStore if we can be replaced. Often times, this is a great
+	// optimization opportunity (there's a fixed iterator underneath us, for
+	// example).
+	if it.qs != nil {
+		newReplacement, hasOne := it.qs.OptimizeIterator(newAnd)
+		if hasOne {
+			newAnd.Close()
+			glog.V(3).Infoln(it.UID(), "became", newReplacement.UID(), "from quadstore")
+			return newReplacement, true
+		}
+	}
+
+	return newAnd, true
+}
+
+// Closes a list of iterators, except the one passed in `except`. Closes all
+// of the iterators in the list if `except` is nil.
+func closeIteratorList(its []graph.Iterator, except graph.Iterator) {
+	for _, it := range its {
+		if it != except {
+			it.Close()
+		}
+	}
+}
+
+// Find if there is a single subiterator which is a valid replacement for this
+// And.
+func (*And) optimizeReplacement(its []graph.Iterator) graph.Iterator {
+	// If we were created with no SubIterators, we're as good as Null.
+	if len(its) == 0 {
+		return &Null{}
+	}
+	if len(its) == 1 {
+		// When there's only one iterator, there's only one choice.
+		return its[0]
+	}
+	// If any of our subiterators, post-optimization, are also Null, then
+	// there's no point in continuing the branch, we will have no results
+	// and we are null as well.
+	if hasAnyNullIterators(its) {
+		return &Null{}
+	}
+
+	// If we have one useful iterator, use that.
+	it := hasOneUsefulIterator(its)
+	if it != nil {
+		return it
+	}
+	return nil
+}
+
+// optimizeOrder(l) takes a list and returns a list, containing the same contents
+// but with a new ordering, however it wishes.
+func (it *And) optimizeOrder(its []graph.Iterator) []graph.Iterator {
+	var (
+		// bad contains iterators that can't be (efficiently) nexted, such as
+		// graph.Optional or graph.Not. Separate them out and tack them on at the end.
+		out, bad []graph.Iterator
+		best     graph.Iterator
+		bestCost = int64(1 << 62)
+	)
+
+	// Find the iterator with the projected "best" total cost.
+	// Total cost is defined as The Next()ed iterator's cost to Next() out
+	// all of it's contents, and to Contains() each of those against everyone
+	// else.
+	for _, root := range its {
+		if _, canNext := root.(graph.Nexter); !canNext {
+			bad = append(bad, root)
+			continue
+		}
+		rootStats := root.Stats()
+		cost := rootStats.NextCost
+		for _, f := range its {
+			if _, canNext := f.(graph.Nexter); !canNext {
+				continue
+			}
+			if f == root {
+				continue
+			}
+			stats := f.Stats()
+			cost += stats.ContainsCost * (1 + (rootStats.Size / (stats.Size + 1)))
+		}
+		cost *= rootStats.Size
+		if glog.V(3) {
+			glog.V(3).Infoln("And:", it.UID(), "Root:", root.UID(), "Total Cost:", cost, "Best:", bestCost)
+		}
+		if cost < bestCost {
+			best = root
+			bestCost = cost
+		}
+	}
+	if glog.V(3) {
+		glog.V(3).Infoln("And:", it.UID(), "Choosing:", best.UID(), "Best:", bestCost)
+	}
+
+	// TODO(barakmich): Optimization of order need not stop here. Picking a smart
+	// Contains() order based on probability of getting a false Contains() first is
+	// useful (fail faster).
+
+	// Put the best iterator (the one we wish to Next()) at the front...
+	out = append(out, best)
+
+	// ... push everyone else after...
+	for _, it := range its {
+		if _, canNext := it.(graph.Nexter); !canNext {
+			continue
+		}
+		if it != best {
+			out = append(out, it)
+		}
+	}
+
+	// ...and finally, the difficult children on the end.
+	return append(out, bad...)
+}
+
+type byCost []graph.Iterator
+
+func (c byCost) Len() int           { return len(c) }
+func (c byCost) Less(i, j int) bool { return c[i].Stats().ContainsCost < c[j].Stats().ContainsCost }
+func (c byCost) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
+
+// optimizeContains() creates an alternate check list, containing the same contents
+// but with a new ordering, however it wishes.
+func (it *And) optimizeContains() {
+	// GetSubIterators allocates, so this is currently safe.
+	// TODO(kortschak) Reuse it.checkList if possible.
+	// This involves providing GetSubIterators with a slice to fill.
+	// Generally this is a worthwhile thing to do in other places as well.
+	it.checkList = it.SubIterators()
+	sort.Sort(byCost(it.checkList))
+}
+
+// If we're replacing ourselves by a single iterator, we need to grab the
+// result tags from the iterators that, while still valid and would hold
+// the same values as this and, are not going to stay.
+// getSubTags() returns a map of the tags for all the subiterators.
+func (it *And) getSubTags() map[string]struct{} {
+	tags := make(map[string]struct{})
+	for _, sub := range it.SubIterators() {
+		for _, tag := range sub.Tagger().Tags() {
+			tags[tag] = struct{}{}
+		}
+	}
+	for _, tag := range it.tags.Tags() {
+		tags[tag] = struct{}{}
+	}
+	return tags
+}
+
+// moveTagsTo() gets the tags for all of the src's subiterators and the
+// src itself, and moves them to dst.
+func moveTagsTo(dst graph.Iterator, src *And) {
+	tags := src.getSubTags()
+	for _, tag := range dst.Tagger().Tags() {
+		if _, ok := tags[tag]; ok {
+			delete(tags, tag)
+		}
+	}
+	dt := dst.Tagger()
+	for k := range tags {
+		dt.Add(k)
+	}
+}
+
+// optimizeSubIterators(l) takes a list of iterators and calls Optimize() on all
+// of them. It returns two lists -- the first contains the same list as l, where
+// any replacements are made by Optimize() and the second contains the originals
+// which were replaced.
+func optimizeSubIterators(its []graph.Iterator) []graph.Iterator {
+	var optIts []graph.Iterator
+	for _, it := range its {
+		o, changed := it.Optimize()
+		if changed {
+			optIts = append(optIts, o)
+		} else {
+			optIts = append(optIts, it.Clone())
+		}
+	}
+	return optIts
+}
+
+// Check a list of iterators for any Null iterators.
+func hasAnyNullIterators(its []graph.Iterator) bool {
+	for _, it := range its {
+		if it.Type() == graph.Null {
+			return true
+		}
+	}
+	return false
+}
+
+// There are two "not-useful" iterators -- namely graph.Null which returns
+// nothing, and graph.All which returns everything. Particularly, we want
+// to see if we're intersecting with a bunch of graph.All iterators, and,
+// if we are, then we have only one useful iterator.
+//
+// We already checked for hasAnyNullIteratators() -- so now we're considering
+// All iterators.
+func hasOneUsefulIterator(its []graph.Iterator) graph.Iterator {
+	usefulCount := 0
+	var usefulIt graph.Iterator
+	for _, it := range its {
+		switch it.Type() {
+		case graph.All:
+			continue
+		case graph.Optional:
+			// Optional is weird -- it's not useful, but we can't optimize
+			// away from it. Therefore, we skip this optimization
+			// if we see one.
+			return nil
+		default:
+			usefulCount++
+			usefulIt = it
+		}
+	}
+
+	if usefulCount == 1 {
+		return usefulIt
+	}
+	if usefulCount == 0 {
+		// It's full of All iterators. We can safely return one of them.
+		return its[0]
+	}
+	return nil
+}
+
+func materializeIts(its []graph.Iterator) []graph.Iterator {
+	var out []graph.Iterator
+
+	allStats := getStatsForSlice(its)
+	out = append(out, its[0])
+	for _, it := range its[1:] {
+		stats := it.Stats()
+		if stats.Size*stats.NextCost < (stats.ContainsCost * (1 + (stats.Size / (allStats.Size + 1)))) {
+			if graph.Height(it, graph.Materialize) > 10 {
+				out = append(out, NewMaterialize(it))
+				continue
+			}
+		}
+		out = append(out, it)
+	}
+	return out
+}
+
+func getStatsForSlice(its []graph.Iterator) graph.IteratorStats {
+	primary := its[0]
+	primaryStats := primary.Stats()
+	ContainsCost := primaryStats.ContainsCost
+	NextCost := primaryStats.NextCost
+	Size := primaryStats.Size
+	for _, sub := range its[1:] {
+		stats := sub.Stats()
+		NextCost += stats.ContainsCost * (1 + (primaryStats.Size / (stats.Size + 1)))
+		ContainsCost += stats.ContainsCost
+		if Size > stats.Size {
+			Size = stats.Size
+		}
+	}
+	return graph.IteratorStats{
+		ContainsCost: ContainsCost,
+		NextCost:     NextCost,
+		Size:         Size,
+	}
+
+}
+
+// and.Stats() lives here in and-iterator-optimize.go because it may
+// in the future return different statistics based on how it is optimized.
+// For now, however, it's pretty static.
+func (it *And) Stats() graph.IteratorStats {
+	stats := getStatsForSlice(it.SubIterators())
+	stats.Next = it.runstats.Next
+	stats.Contains = it.runstats.Contains
+	return stats
+}
diff --git a/vendor/github.com/google/cayley/graph/iterator/fixed_iterator.go b/vendor/github.com/google/cayley/graph/iterator/fixed_iterator.go
new file mode 100644
index 00000000..c41def33
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/fixed_iterator.go
@@ -0,0 +1,191 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// Defines one of the base iterators, the Fixed iterator. A fixed iterator is quite simple; it
+// contains an explicit fixed array of values.
+//
+// A fixed iterator requires an Equality function to be passed to it, by reason that graph.Value, the
+// opaque Quad store value, may not answer to ==.
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/google/cayley/graph"
+)
+
+// A Fixed iterator consists of it's values, an index (where it is in the process of Next()ing) and
+// an equality function.
+type Fixed struct {
+	uid       uint64
+	tags      graph.Tagger
+	values    []graph.Value
+	lastIndex int
+	cmp       Equality
+	result    graph.Value
+}
+
+// Define the signature of an equality function.
+type Equality func(a, b graph.Value) bool
+
+// Define an equality function of purely ==, which works for native types.
+func Identity(a, b graph.Value) bool {
+	return a == b
+}
+
+// Creates a new Fixed iterator with a custom comparator.
+func NewFixed(cmp Equality) *Fixed {
+	return &Fixed{
+		uid:    NextUID(),
+		values: make([]graph.Value, 0, 20),
+		cmp:    cmp,
+	}
+}
+
+func (it *Fixed) UID() uint64 {
+	return it.uid
+}
+
+func (it *Fixed) Reset() {
+	it.lastIndex = 0
+}
+
+func (it *Fixed) Close() error {
+	return nil
+}
+
+func (it *Fixed) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Fixed) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Fixed) Clone() graph.Iterator {
+	out := NewFixed(it.cmp)
+	for _, val := range it.values {
+		out.Add(val)
+	}
+	out.tags.CopyFrom(it)
+	return out
+}
+
+// Add a value to the iterator. The array now contains this value.
+// TODO(barakmich): This ought to be a set someday, disallowing repeated values.
+func (it *Fixed) Add(v graph.Value) {
+	it.values = append(it.values, v)
+}
+
+func (it *Fixed) Describe() graph.Description {
+	var value string
+	if len(it.values) > 0 {
+		value = fmt.Sprint(it.values[0])
+	}
+	fixed := make([]string, 0, len(it.tags.Fixed()))
+	for k := range it.tags.Fixed() {
+		fixed = append(fixed, k)
+	}
+	sort.Strings(fixed)
+	return graph.Description{
+		UID:  it.UID(),
+		Name: value,
+		Type: it.Type(),
+		Tags: fixed,
+		Size: int64(len(it.values)),
+	}
+}
+
+// Register this iterator as a Fixed iterator.
+func (it *Fixed) Type() graph.Type { return graph.Fixed }
+
+// Check if the passed value is equal to one of the values stored in the iterator.
+func (it *Fixed) Contains(v graph.Value) bool {
+	// Could be optimized by keeping it sorted or using a better datastructure.
+	// However, for fixed iterators, which are by definition kind of tiny, this
+	// isn't a big issue.
+	graph.ContainsLogIn(it, v)
+	for _, x := range it.values {
+		if it.cmp(x, v) {
+			it.result = x
+			return graph.ContainsLogOut(it, v, true)
+		}
+	}
+	return graph.ContainsLogOut(it, v, false)
+}
+
+// Next advances the iterator.
+func (it *Fixed) Next() bool {
+	graph.NextLogIn(it)
+	if it.lastIndex == len(it.values) {
+		return graph.NextLogOut(it, nil, false)
+	}
+	out := it.values[it.lastIndex]
+	it.result = out
+	it.lastIndex++
+	return graph.NextLogOut(it, out, true)
+}
+
+func (it *Fixed) Err() error {
+	return nil
+}
+
+func (it *Fixed) Result() graph.Value {
+	return it.result
+}
+
+func (it *Fixed) NextPath() bool {
+	return false
+}
+
+// No sub-iterators.
+func (it *Fixed) SubIterators() []graph.Iterator {
+	return nil
+}
+
+// Optimize() for a Fixed iterator is simple. Returns a Null iterator if it's empty
+// (so that other iterators upstream can treat this as null) or there is no
+// optimization.
+func (it *Fixed) Optimize() (graph.Iterator, bool) {
+	if len(it.values) == 1 && it.values[0] == nil {
+		return &Null{}, true
+	}
+
+	return it, false
+}
+
+// Size is the number of values stored.
+func (it *Fixed) Size() (int64, bool) {
+	return int64(len(it.values)), true
+}
+
+// As we right now have to scan the entire list, Next and Contains are linear with the
+// size. However, a better data structure could remove these limits.
+func (it *Fixed) Stats() graph.IteratorStats {
+	return graph.IteratorStats{
+		ContainsCost: int64(len(it.values)),
+		NextCost:     int64(len(it.values)),
+		Size:         int64(len(it.values)),
+	}
+}
+
+var _ graph.Nexter = &Fixed{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/hasa_iterator.go b/vendor/github.com/google/cayley/graph/iterator/hasa_iterator.go
new file mode 100644
index 00000000..32be43bf
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/hasa_iterator.go
@@ -0,0 +1,283 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// Defines one of the base iterators, the HasA iterator. The HasA takes a
+// subiterator of links, and acts as an iterator of nodes in the given
+// direction. The name comes from the idea that a "link HasA subject" or a "link
+// HasA predicate".
+//
+// HasA is weird in that it may return the same value twice if on the Next()
+// path. That's okay -- in reality, it can be viewed as returning the value for
+// a new quad, but to make logic much simpler, here we have the HasA.
+//
+// Likewise, it's important to think about Contains()ing a HasA. When given a
+// value to check, it means "Check all predicates that have this value for your
+// direction against the subiterator." This would imply that there's more than
+// one possibility for the same Contains()ed value. While we could return the
+// number of options, it's simpler to return one, and then call NextPath()
+// enough times to enumerate the options. (In fact, one could argue that the
+// raison d'etre for NextPath() is this iterator).
+//
+// Alternatively, can be seen as the dual of the LinksTo iterator.
+
+import (
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+// A HasA consists of a reference back to the graph.QuadStore that it references,
+// a primary subiterator, a direction in which the quads for that subiterator point,
+// and a temporary holder for the iterator generated on Contains().
+type HasA struct {
+	uid       uint64
+	tags      graph.Tagger
+	qs        graph.QuadStore
+	primaryIt graph.Iterator
+	dir       quad.Direction
+	resultIt  graph.Iterator
+	result    graph.Value
+	runstats  graph.IteratorStats
+	err       error
+}
+
+// Construct a new HasA iterator, given the quad subiterator, and the quad
+// direction for which it stands.
+func NewHasA(qs graph.QuadStore, subIt graph.Iterator, d quad.Direction) *HasA {
+	return &HasA{
+		uid:       NextUID(),
+		qs:        qs,
+		primaryIt: subIt,
+		dir:       d,
+	}
+}
+
+func (it *HasA) UID() uint64 {
+	return it.uid
+}
+
+// Return our sole subiterator.
+func (it *HasA) SubIterators() []graph.Iterator {
+	return []graph.Iterator{it.primaryIt}
+}
+
+func (it *HasA) Reset() {
+	it.primaryIt.Reset()
+	if it.resultIt != nil {
+		it.resultIt.Close()
+	}
+}
+
+func (it *HasA) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *HasA) Clone() graph.Iterator {
+	out := NewHasA(it.qs, it.primaryIt.Clone(), it.dir)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+// Direction accessor.
+func (it *HasA) Direction() quad.Direction { return it.dir }
+
+// Pass the Optimize() call along to the subiterator. If it becomes Null,
+// then the HasA becomes Null (there are no quads that have any directions).
+func (it *HasA) Optimize() (graph.Iterator, bool) {
+	newPrimary, changed := it.primaryIt.Optimize()
+	if changed {
+		it.primaryIt = newPrimary
+		if it.primaryIt.Type() == graph.Null {
+			return it.primaryIt, true
+		}
+	}
+	// Ask the graph.QuadStore if we can be replaced. Often times, this is a great
+	// optimization opportunity (there's a fixed iterator underneath us, for
+	// example).
+	newReplacement, hasOne := it.qs.OptimizeIterator(it)
+	if hasOne {
+		it.Close()
+		return newReplacement, true
+	}
+	return it, false
+}
+
+// Pass the TagResults down the chain.
+func (it *HasA) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	it.primaryIt.TagResults(dst)
+}
+
+func (it *HasA) Describe() graph.Description {
+	primary := it.primaryIt.Describe()
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Direction: it.dir,
+		Iterator:  &primary,
+	}
+}
+
+// Check a value against our internal iterator. In order to do this, we must first open a new
+// iterator of "quads that have `val` in our direction", given to us by the quad store,
+// and then Next() values out of that iterator and Contains() them against our subiterator.
+func (it *HasA) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	it.runstats.Contains += 1
+	if glog.V(4) {
+		glog.V(4).Infoln("Id is", it.qs.NameOf(val))
+	}
+	// TODO(barakmich): Optimize this
+	if it.resultIt != nil {
+		it.resultIt.Close()
+	}
+	it.resultIt = it.qs.QuadIterator(it.dir, val)
+	ok := it.NextContains()
+	if it.err != nil {
+		return false
+	}
+	return graph.ContainsLogOut(it, val, ok)
+}
+
+// NextContains() is shared code between Contains() and GetNextResult() -- calls next on the
+// result iterator (a quad iterator based on the last checked value) and returns true if
+// another match is made.
+func (it *HasA) NextContains() bool {
+	for graph.Next(it.resultIt) {
+		it.runstats.ContainsNext += 1
+		link := it.resultIt.Result()
+		if glog.V(4) {
+			glog.V(4).Infoln("Quad is", it.qs.Quad(link))
+		}
+		if it.primaryIt.Contains(link) {
+			it.result = it.qs.QuadDirection(link, it.dir)
+			return true
+		}
+	}
+	it.err = it.resultIt.Err()
+	return false
+}
+
+// Get the next result that matches this branch.
+func (it *HasA) NextPath() bool {
+	// Order here is important. If the subiterator has a NextPath, then we
+	// need do nothing -- there is a next result, and we shouldn't move forward.
+	// However, we then need to get the next result from our last Contains().
+	//
+	// The upshot is, the end of NextPath() bubbles up from the bottom of the
+	// iterator tree up, and we need to respect that.
+	glog.V(4).Infoln("HASA", it.UID(), "NextPath")
+	if it.primaryIt.NextPath() {
+		return true
+	}
+	it.err = it.primaryIt.Err()
+	if it.err != nil {
+		return false
+	}
+
+	result := it.NextContains() // Sets it.err if there's an error
+	if it.err != nil {
+		return false
+	}
+	glog.V(4).Infoln("HASA", it.UID(), "NextPath Returns", result, "")
+	return result
+}
+
+// Next advances the iterator. This is simpler than Contains. We have a
+// subiterator we can get a value from, and we can take that resultant quad,
+// pull our direction out of it, and return that.
+func (it *HasA) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+	if it.resultIt != nil {
+		it.resultIt.Close()
+	}
+	it.resultIt = &Null{}
+
+	if !graph.Next(it.primaryIt) {
+		it.err = it.primaryIt.Err()
+		return graph.NextLogOut(it, 0, false)
+	}
+	tID := it.primaryIt.Result()
+	val := it.qs.QuadDirection(tID, it.dir)
+	it.result = val
+	return graph.NextLogOut(it, val, true)
+}
+
+func (it *HasA) Err() error {
+	return it.err
+}
+
+func (it *HasA) Result() graph.Value {
+	return it.result
+}
+
+// GetStats() returns the statistics on the HasA iterator. This is curious. Next
+// cost is easy, it's an extra call or so on top of the subiterator Next cost.
+// ContainsCost involves going to the graph.QuadStore, iterating out values, and hoping
+// one sticks -- potentially expensive, depending on fanout. Size, however, is
+// potentially smaller. we know at worst it's the size of the subiterator, but
+// if there are many repeated values, it could be much smaller in totality.
+func (it *HasA) Stats() graph.IteratorStats {
+	subitStats := it.primaryIt.Stats()
+	// TODO(barakmich): These should really come from the quadstore itself
+	// and be optimized.
+	faninFactor := int64(1)
+	fanoutFactor := int64(30)
+	nextConstant := int64(2)
+	quadConstant := int64(1)
+	return graph.IteratorStats{
+		NextCost:     quadConstant + subitStats.NextCost,
+		ContainsCost: (fanoutFactor * nextConstant) * subitStats.ContainsCost,
+		Size:         faninFactor * subitStats.Size,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+		ContainsNext: it.runstats.ContainsNext,
+	}
+}
+
+// Close the subiterator, the result iterator (if any) and the HasA. It closes
+// all subiterators it can, but returns the first error it encounters.
+func (it *HasA) Close() error {
+	err := it.primaryIt.Close()
+
+	if it.resultIt != nil {
+		_err := it.resultIt.Close()
+		if err == nil {
+			err = _err
+		}
+	}
+
+	return err
+}
+
+// Register this iterator as a HasA.
+func (it *HasA) Type() graph.Type { return graph.HasA }
+
+func (it *HasA) Size() (int64, bool) {
+	return it.Stats().Size, false
+}
+
+var _ graph.Nexter = &HasA{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/iterator.go b/vendor/github.com/google/cayley/graph/iterator/iterator.go
new file mode 100644
index 00000000..b3269966
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/iterator.go
@@ -0,0 +1,122 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// Define the general iterator interface.
+
+import (
+	"sync/atomic"
+
+	"github.com/google/cayley/graph"
+)
+
+var nextIteratorID uint64
+
+func init() {
+	atomic.StoreUint64(&nextIteratorID, 1)
+}
+
+func NextUID() uint64 {
+	return atomic.AddUint64(&nextIteratorID, 1) - 1
+}
+
+// Here we define the simplest iterator -- the Null iterator. It contains nothing.
+// It is the empty set. Often times, queries that contain one of these match nothing,
+// so it's important to give it a special iterator.
+type Null struct {
+	uid  uint64
+	tags graph.Tagger
+}
+
+// Fairly useless New function.
+func NewNull() *Null {
+	return &Null{uid: NextUID()}
+}
+
+func (it *Null) UID() uint64 {
+	return it.uid
+}
+
+func (it *Null) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// Fill the map based on the tags assigned to this iterator.
+func (it *Null) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Null) Contains(graph.Value) bool {
+	return false
+}
+
+func (it *Null) Clone() graph.Iterator { return NewNull() }
+
+// Name the null iterator.
+func (it *Null) Type() graph.Type { return graph.Null }
+
+// A good iterator will close itself when it returns true.
+// Null has nothing it needs to do.
+func (it *Null) Optimize() (graph.Iterator, bool) { return it, false }
+
+func (it *Null) Describe() graph.Description {
+	return graph.Description{
+		UID:  it.UID(),
+		Type: it.Type(),
+	}
+}
+
+func (it *Null) Next() bool {
+	return false
+}
+
+func (it *Null) Err() error {
+	return nil
+}
+
+func (it *Null) Result() graph.Value {
+	return nil
+}
+
+func (it *Null) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *Null) NextPath() bool {
+	return false
+}
+
+func (it *Null) Size() (int64, bool) {
+	return 0, true
+}
+
+func (it *Null) Reset() {}
+
+func (it *Null) Close() error {
+	return nil
+}
+
+// A null iterator costs nothing. Use it!
+func (it *Null) Stats() graph.IteratorStats {
+	return graph.IteratorStats{}
+}
+
+var _ graph.Nexter = &Null{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/linksto_iterator.go b/vendor/github.com/google/cayley/graph/iterator/linksto_iterator.go
new file mode 100644
index 00000000..ab4c3f3c
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/linksto_iterator.go
@@ -0,0 +1,237 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// Defines one of the base iterators, the LinksTo iterator. A LinksTo takes a
+// subiterator of nodes, and contains an iteration of links which "link to"
+// those nodes in a given direction.
+//
+// Next()ing a LinksTo is straightforward -- iterate through all links to //
+// things in the subiterator, and then advance the subiterator, and do it again.
+// LinksTo is therefore sensitive to growing with a fanout. (A small-sized
+// subiterator could cause LinksTo to be large).
+//
+// Contains()ing a LinksTo means, given a link, take the direction we care about
+// and check if it's in our subiterator. Checking is therefore fairly cheap, and
+// similar to checking the subiterator alone.
+//
+// Can be seen as the dual of the HasA iterator.
+
+import (
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+// A LinksTo has a reference back to the graph.QuadStore (to create the iterators
+// for each node) the subiterator, and the direction the iterator comes from.
+// `next_it` is the tempoarary iterator held per result in `primary_it`.
+type LinksTo struct {
+	uid       uint64
+	tags      graph.Tagger
+	qs        graph.QuadStore
+	primaryIt graph.Iterator
+	dir       quad.Direction
+	nextIt    graph.Iterator
+	result    graph.Value
+	runstats  graph.IteratorStats
+	err       error
+}
+
+// Construct a new LinksTo iterator around a direction and a subiterator of
+// nodes.
+func NewLinksTo(qs graph.QuadStore, it graph.Iterator, d quad.Direction) *LinksTo {
+	return &LinksTo{
+		uid:       NextUID(),
+		qs:        qs,
+		primaryIt: it,
+		dir:       d,
+		nextIt:    &Null{},
+	}
+}
+
+func (it *LinksTo) UID() uint64 {
+	return it.uid
+}
+
+func (it *LinksTo) Reset() {
+	it.primaryIt.Reset()
+	if it.nextIt != nil {
+		it.nextIt.Close()
+	}
+	it.nextIt = &Null{}
+}
+
+func (it *LinksTo) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *LinksTo) Clone() graph.Iterator {
+	out := NewLinksTo(it.qs, it.primaryIt.Clone(), it.dir)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+// Return the direction under consideration.
+func (it *LinksTo) Direction() quad.Direction { return it.dir }
+
+// Tag these results, and our subiterator's results.
+func (it *LinksTo) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	it.primaryIt.TagResults(dst)
+}
+
+func (it *LinksTo) Describe() graph.Description {
+	primary := it.primaryIt.Describe()
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Direction: it.dir,
+		Iterator:  &primary,
+	}
+}
+
+// If it checks in the right direction for the subiterator, it is a valid link
+// for the LinksTo.
+func (it *LinksTo) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	it.runstats.Contains += 1
+	node := it.qs.QuadDirection(val, it.dir)
+	if it.primaryIt.Contains(node) {
+		it.result = val
+		return graph.ContainsLogOut(it, val, true)
+	}
+	it.err = it.primaryIt.Err()
+	return graph.ContainsLogOut(it, val, false)
+}
+
+// Return a list containing only our subiterator.
+func (it *LinksTo) SubIterators() []graph.Iterator {
+	return []graph.Iterator{it.primaryIt}
+}
+
+// Optimize the LinksTo, by replacing it if it can be.
+func (it *LinksTo) Optimize() (graph.Iterator, bool) {
+	newPrimary, changed := it.primaryIt.Optimize()
+	if changed {
+		it.primaryIt = newPrimary
+		if it.primaryIt.Type() == graph.Null {
+			it.nextIt.Close()
+			return it.primaryIt, true
+		}
+	}
+	// Ask the graph.QuadStore if we can be replaced. Often times, this is a great
+	// optimization opportunity (there's a fixed iterator underneath us, for
+	// example).
+	newReplacement, hasOne := it.qs.OptimizeIterator(it)
+	if hasOne {
+		it.Close()
+		return newReplacement, true
+	}
+	return it, false
+}
+
+// Next()ing a LinksTo operates as described above.
+func (it *LinksTo) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+	if graph.Next(it.nextIt) {
+		it.runstats.ContainsNext += 1
+		it.result = it.nextIt.Result()
+		return graph.NextLogOut(it, it.nextIt, true)
+	}
+
+	// If there's an error in the 'next' iterator, we save it and we're done.
+	it.err = it.nextIt.Err()
+	if it.err != nil {
+		return false
+	}
+
+	// Subiterator is empty, get another one
+	if !graph.Next(it.primaryIt) {
+		// Possibly save error
+		it.err = it.primaryIt.Err()
+
+		// We're out of nodes in our subiterator, so we're done as well.
+		return graph.NextLogOut(it, 0, false)
+	}
+	it.nextIt.Close()
+	it.nextIt = it.qs.QuadIterator(it.dir, it.primaryIt.Result())
+
+	// Recurse -- return the first in the next set.
+	return it.Next()
+}
+
+func (it *LinksTo) Err() error {
+	return it.err
+}
+
+func (it *LinksTo) Result() graph.Value {
+	return it.result
+}
+
+// Close closes the iterator.  It closes all subiterators it can, but
+// returns the first error it encounters.
+func (it *LinksTo) Close() error {
+	err := it.nextIt.Close()
+
+	_err := it.primaryIt.Close()
+	if _err != nil && err == nil {
+		err = _err
+	}
+
+	return err
+}
+
+// We won't ever have a new result, but our subiterators might.
+func (it *LinksTo) NextPath() bool {
+	ok := it.primaryIt.NextPath()
+	if !ok {
+		it.err = it.primaryIt.Err()
+	}
+	return ok
+}
+
+// Register the LinksTo.
+func (it *LinksTo) Type() graph.Type { return graph.LinksTo }
+
+// Return a guess as to how big or costly it is to next the iterator.
+func (it *LinksTo) Stats() graph.IteratorStats {
+	subitStats := it.primaryIt.Stats()
+	// TODO(barakmich): These should really come from the quadstore itself
+	fanoutFactor := int64(20)
+	checkConstant := int64(1)
+	nextConstant := int64(2)
+	return graph.IteratorStats{
+		NextCost:     nextConstant + subitStats.NextCost,
+		ContainsCost: checkConstant + subitStats.ContainsCost,
+		Size:         fanoutFactor * subitStats.Size,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+		ContainsNext: it.runstats.ContainsNext,
+	}
+}
+
+func (it *LinksTo) Size() (int64, bool) {
+	return it.Stats().Size, false
+}
+
+var _ graph.Nexter = &LinksTo{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/materialize_iterator.go b/vendor/github.com/google/cayley/graph/iterator/materialize_iterator.go
new file mode 100644
index 00000000..f7cbe4aa
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/materialize_iterator.go
@@ -0,0 +1,308 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// A simple iterator that, when first called Contains() or Next() upon, materializes the whole subiterator, stores it locally, and responds. Essentially a cache.
+
+import (
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+)
+
+var abortMaterializeAt = 1000
+
+type result struct {
+	id   graph.Value
+	tags map[string]graph.Value
+}
+
+// Keyer provides a method for comparing types that are not otherwise comparable.
+// The Key method must return a dynamic type that is comparable according to the
+// Go language specification. The returned value must be unique for each receiver
+// value.
+type Keyer interface {
+	Key() interface{}
+}
+
+type Materialize struct {
+	uid         uint64
+	tags        graph.Tagger
+	containsMap map[graph.Value]int
+	values      [][]result
+	actualSize  int64
+	index       int
+	subindex    int
+	subIt       graph.Iterator
+	hasRun      bool
+	aborted     bool
+	runstats    graph.IteratorStats
+	err         error
+}
+
+func NewMaterialize(sub graph.Iterator) *Materialize {
+	return &Materialize{
+		uid:         NextUID(),
+		containsMap: make(map[graph.Value]int),
+		subIt:       sub,
+		index:       -1,
+	}
+}
+
+func (it *Materialize) UID() uint64 {
+	return it.uid
+}
+
+func (it *Materialize) Reset() {
+	it.subIt.Reset()
+	it.index = -1
+}
+
+func (it *Materialize) Close() error {
+	it.containsMap = nil
+	it.values = nil
+	it.hasRun = false
+	return it.subIt.Close()
+}
+
+func (it *Materialize) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Materialize) TagResults(dst map[string]graph.Value) {
+	if !it.hasRun {
+		return
+	}
+	if it.aborted {
+		it.subIt.TagResults(dst)
+		for _, tag := range it.tags.Tags() {
+			dst[tag] = it.Result()
+		}
+		return
+	}
+	if it.Result() == nil {
+		return
+	}
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+	for tag, value := range it.values[it.index][it.subindex].tags {
+		dst[tag] = value
+	}
+}
+
+func (it *Materialize) Clone() graph.Iterator {
+	out := NewMaterialize(it.subIt.Clone())
+	out.tags.CopyFrom(it)
+	if it.hasRun {
+		out.hasRun = true
+		out.aborted = it.aborted
+		out.err = it.err
+		out.values = it.values
+		out.containsMap = it.containsMap
+		out.actualSize = it.actualSize
+	}
+	return out
+}
+
+func (it *Materialize) Describe() graph.Description {
+	primary := it.subIt.Describe()
+	return graph.Description{
+		UID:      it.UID(),
+		Type:     it.Type(),
+		Tags:     it.tags.Tags(),
+		Size:     int64(len(it.values)),
+		Iterator: &primary,
+	}
+}
+
+// Register this iterator as a Materialize iterator.
+func (it *Materialize) Type() graph.Type { return graph.Materialize }
+
+func (it *Materialize) Result() graph.Value {
+	if it.aborted {
+		return it.subIt.Result()
+	}
+	if len(it.values) == 0 {
+		return nil
+	}
+	if it.index == -1 {
+		return nil
+	}
+	if it.index >= len(it.values) {
+		return nil
+	}
+	return it.values[it.index][it.subindex].id
+}
+
+func (it *Materialize) SubIterators() []graph.Iterator {
+	return []graph.Iterator{it.subIt}
+}
+
+func (it *Materialize) Optimize() (graph.Iterator, bool) {
+	newSub, changed := it.subIt.Optimize()
+	if changed {
+		it.subIt = newSub
+		if it.subIt.Type() == graph.Null {
+			return it.subIt, true
+		}
+	}
+	return it, false
+}
+
+// Size is the number of values stored, if we've got them all.
+// Otherwise, guess based on the size of the subiterator.
+func (it *Materialize) Size() (int64, bool) {
+	if it.hasRun && !it.aborted {
+		glog.V(2).Infoln("returning size", it.actualSize)
+		return it.actualSize, true
+	}
+	glog.V(2).Infoln("bailing size", it.actualSize)
+	return it.subIt.Size()
+}
+
+// The entire point of Materialize is to amortize the cost by
+// putting it all up front.
+func (it *Materialize) Stats() graph.IteratorStats {
+	overhead := int64(2)
+	size, _ := it.Size()
+	subitStats := it.subIt.Stats()
+	return graph.IteratorStats{
+		ContainsCost: overhead * subitStats.NextCost,
+		NextCost:     overhead * subitStats.NextCost,
+		Size:         size,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+	}
+}
+
+func (it *Materialize) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+	if !it.hasRun {
+		it.materializeSet()
+	}
+	if it.err != nil {
+		return false
+	}
+	if it.aborted {
+		n := graph.Next(it.subIt)
+		it.err = it.subIt.Err()
+		return n
+	}
+
+	it.index++
+	it.subindex = 0
+	if it.index >= len(it.values) {
+		return graph.NextLogOut(it, nil, false)
+	}
+	return graph.NextLogOut(it, it.Result(), true)
+}
+
+func (it *Materialize) Err() error {
+	return it.err
+}
+
+func (it *Materialize) Contains(v graph.Value) bool {
+	graph.ContainsLogIn(it, v)
+	it.runstats.Contains += 1
+	if !it.hasRun {
+		it.materializeSet()
+	}
+	if it.err != nil {
+		return false
+	}
+	if it.aborted {
+		return it.subIt.Contains(v)
+	}
+	key := v
+	if h, ok := v.(Keyer); ok {
+		key = h.Key()
+	}
+	if i, ok := it.containsMap[key]; ok {
+		it.index = i
+		it.subindex = 0
+		return graph.ContainsLogOut(it, v, true)
+	}
+	return graph.ContainsLogOut(it, v, false)
+}
+
+func (it *Materialize) NextPath() bool {
+	if !it.hasRun {
+		it.materializeSet()
+	}
+	if it.err != nil {
+		return false
+	}
+	if it.aborted {
+		return it.subIt.NextPath()
+	}
+
+	it.subindex++
+	if it.subindex >= len(it.values[it.index]) {
+		// Don't go off the end of the world
+		it.subindex--
+		return false
+	}
+	return true
+}
+
+func (it *Materialize) materializeSet() {
+	i := 0
+	for graph.Next(it.subIt) {
+		i++
+		if i > abortMaterializeAt {
+			it.aborted = true
+			break
+		}
+		id := it.subIt.Result()
+		val := id
+		if h, ok := id.(Keyer); ok {
+			val = h.Key()
+		}
+		if _, ok := it.containsMap[val]; !ok {
+			it.containsMap[val] = len(it.values)
+			it.values = append(it.values, nil)
+		}
+		index := it.containsMap[val]
+		tags := make(map[string]graph.Value)
+		it.subIt.TagResults(tags)
+		it.values[index] = append(it.values[index], result{id: id, tags: tags})
+		it.actualSize += 1
+		for it.subIt.NextPath() {
+			i++
+			if i > abortMaterializeAt {
+				it.aborted = true
+				break
+			}
+			tags := make(map[string]graph.Value)
+			it.subIt.TagResults(tags)
+			it.values[index] = append(it.values[index], result{id: id, tags: tags})
+			it.actualSize += 1
+		}
+	}
+	it.err = it.subIt.Err()
+	if it.err == nil && it.aborted {
+		if glog.V(2) {
+			glog.V(2).Infoln("Aborting subiterator")
+		}
+		it.values = nil
+		it.containsMap = nil
+		it.subIt.Reset()
+	}
+	it.hasRun = true
+}
+
+var _ graph.Nexter = &Materialize{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/not_iterator.go b/vendor/github.com/google/cayley/graph/iterator/not_iterator.go
new file mode 100644
index 00000000..6813a5db
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/not_iterator.go
@@ -0,0 +1,178 @@
+package iterator
+
+import (
+	"github.com/google/cayley/graph"
+)
+
+// Not iterator acts like a complement for the primary iterator.
+// It will return all the vertices which are not part of the primary iterator.
+type Not struct {
+	uid       uint64
+	tags      graph.Tagger
+	primaryIt graph.Iterator
+	allIt     graph.Iterator
+	result    graph.Value
+	runstats  graph.IteratorStats
+	err       error
+}
+
+func NewNot(primaryIt, allIt graph.Iterator) *Not {
+	return &Not{
+		uid:       NextUID(),
+		primaryIt: primaryIt,
+		allIt:     allIt,
+	}
+}
+
+func (it *Not) UID() uint64 {
+	return it.uid
+}
+
+// Reset resets the internal iterators and the iterator itself.
+func (it *Not) Reset() {
+	it.result = nil
+	it.primaryIt.Reset()
+	it.allIt.Reset()
+}
+
+func (it *Not) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Not) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	if it.primaryIt != nil {
+		it.primaryIt.TagResults(dst)
+	}
+}
+
+func (it *Not) Clone() graph.Iterator {
+	not := NewNot(it.primaryIt.Clone(), it.allIt.Clone())
+	not.tags.CopyFrom(it)
+	return not
+}
+
+// SubIterators returns a slice of the sub iterators.
+// The first iterator is the primary iterator, for which the complement
+// is generated.
+func (it *Not) SubIterators() []graph.Iterator {
+	return []graph.Iterator{it.primaryIt, it.allIt}
+}
+
+// Next advances the Not iterator. It returns whether there is another valid
+// new value. It fetches the next value of the all iterator which is not
+// contained by the primary iterator.
+func (it *Not) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+
+	for graph.Next(it.allIt) {
+		if curr := it.allIt.Result(); !it.primaryIt.Contains(curr) {
+			it.result = curr
+			it.runstats.ContainsNext += 1
+			return graph.NextLogOut(it, curr, true)
+		}
+	}
+	it.err = it.allIt.Err()
+	return graph.NextLogOut(it, nil, false)
+}
+
+func (it *Not) Err() error {
+	return it.err
+}
+
+func (it *Not) Result() graph.Value {
+	return it.result
+}
+
+// Contains checks whether the passed value is part of the primary iterator's
+// complement. For a valid value, it updates the Result returned by the iterator
+// to the value itself.
+func (it *Not) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	it.runstats.Contains += 1
+
+	if it.primaryIt.Contains(val) {
+		return graph.ContainsLogOut(it, val, false)
+	}
+
+	it.err = it.primaryIt.Err()
+	if it.err != nil {
+		// Explicitly return 'false', since an error occurred.
+		return false
+	}
+
+	it.result = val
+	return graph.ContainsLogOut(it, val, true)
+}
+
+// NextPath checks whether there is another path. Not applicable, hence it will
+// return false.
+func (it *Not) NextPath() bool {
+	return false
+}
+
+// Close closes the primary and all iterators.  It closes all subiterators
+// it can, but returns the first error it encounters.
+func (it *Not) Close() error {
+	err := it.primaryIt.Close()
+
+	_err := it.allIt.Close()
+	if _err != nil && err == nil {
+		err = _err
+	}
+
+	return err
+}
+
+func (it *Not) Type() graph.Type { return graph.Not }
+
+func (it *Not) Optimize() (graph.Iterator, bool) {
+	// TODO - consider wrapping the primaryIt with a MaterializeIt
+	optimizedPrimaryIt, optimized := it.primaryIt.Optimize()
+	if optimized {
+		it.primaryIt = optimizedPrimaryIt
+	}
+	it.primaryIt = NewMaterialize(it.primaryIt)
+	return it, false
+}
+
+func (it *Not) Stats() graph.IteratorStats {
+	primaryStats := it.primaryIt.Stats()
+	allStats := it.allIt.Stats()
+	return graph.IteratorStats{
+		NextCost:     allStats.NextCost + primaryStats.ContainsCost,
+		ContainsCost: primaryStats.ContainsCost,
+		Size:         allStats.Size - primaryStats.Size,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+		ContainsNext: it.runstats.ContainsNext,
+	}
+}
+
+func (it *Not) Size() (int64, bool) {
+	return it.Stats().Size, false
+}
+
+func (it *Not) Describe() graph.Description {
+	subIts := []graph.Description{
+		it.primaryIt.Describe(),
+		it.allIt.Describe(),
+	}
+
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Iterators: subIts,
+	}
+}
+
+var _ graph.Nexter = &Not{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/optional_iterator.go b/vendor/github.com/google/cayley/graph/iterator/optional_iterator.go
new file mode 100644
index 00000000..3cc32e2c
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/optional_iterator.go
@@ -0,0 +1,161 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// "Optional" is kind of odd. It's not an iterator in the strictest sense, but
+// it's easier to implement as an iterator.
+//
+// Consider what it means. It means that we have a subconstraint which we do
+// not want to constrain the query -- we just want it to return the matching
+// subgraph if one matches at all. By analogy to regular expressions, it is the
+// '?' operator.
+//
+// If it were a proper iterator of its own (and indeed, a reasonable refactor
+// of this iterator would be to make it such) it would contain an all iterator
+// -- all things in the graph. It matches everything (as does the regex "(a)?")
+
+import (
+	"github.com/google/cayley/graph"
+)
+
+// An optional iterator has the sub-constraint iterator we wish to be optional
+// and whether the last check we received was true or false.
+type Optional struct {
+	uid       uint64
+	tags      graph.Tagger
+	subIt     graph.Iterator
+	lastCheck bool
+	result    graph.Value
+	err       error
+}
+
+// Creates a new optional iterator.
+func NewOptional(it graph.Iterator) *Optional {
+	return &Optional{
+		uid:   NextUID(),
+		subIt: it,
+	}
+}
+
+func (it *Optional) UID() uint64 {
+	return it.uid
+}
+
+func (it *Optional) Reset() {
+	it.subIt.Reset()
+	it.lastCheck = false
+}
+
+func (it *Optional) Close() error {
+	return it.subIt.Close()
+}
+
+func (it *Optional) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Optional) Clone() graph.Iterator {
+	out := NewOptional(it.subIt.Clone())
+	out.tags.CopyFrom(it)
+	return out
+}
+
+func (it *Optional) Err() error {
+	return it.err
+}
+
+func (it *Optional) Result() graph.Value {
+	return it.result
+}
+
+// An optional iterator only has a next result if, (a) last time we checked
+// we had any results whatsoever, and (b) there was another subresult in our
+// optional subbranch.
+func (it *Optional) NextPath() bool {
+	if it.lastCheck {
+		ok := it.subIt.NextPath()
+		if !ok {
+			it.err = it.subIt.Err()
+		}
+		return ok
+	}
+	return false
+}
+
+// No subiterators.
+func (it *Optional) SubIterators() []graph.Iterator {
+	return nil
+}
+
+// Contains() is the real hack of this iterator. It always returns true, regardless
+// of whether the subiterator matched. But we keep track of whether the subiterator
+// matched for results purposes.
+func (it *Optional) Contains(val graph.Value) bool {
+	checked := it.subIt.Contains(val)
+	it.lastCheck = checked
+	it.err = it.subIt.Err()
+	it.result = val
+	return true
+}
+
+// If we failed the check, then the subiterator should not contribute to the result
+// set. Otherwise, go ahead and tag it.
+func (it *Optional) TagResults(dst map[string]graph.Value) {
+	if it.lastCheck == false {
+		return
+	}
+	it.subIt.TagResults(dst)
+}
+
+// Registers the optional iterator.
+func (it *Optional) Type() graph.Type { return graph.Optional }
+
+func (it *Optional) Describe() graph.Description {
+	primary := it.subIt.Describe()
+	return graph.Description{
+		UID:      it.UID(),
+		Type:     it.Type(),
+		Tags:     it.tags.Tags(),
+		Iterator: &primary,
+	}
+}
+
+// There's nothing to optimize for an optional. Optimize the subiterator and
+// potentially replace it.
+func (it *Optional) Optimize() (graph.Iterator, bool) {
+	newSub, changed := it.subIt.Optimize()
+	if changed {
+		it.subIt.Close()
+		it.subIt = newSub
+	}
+	return it, false
+}
+
+// We're only as expensive as our subiterator. Except, we can't be nexted.
+func (it *Optional) Stats() graph.IteratorStats {
+	subStats := it.subIt.Stats()
+	return graph.IteratorStats{
+		ContainsCost: subStats.ContainsCost,
+		NextCost:     int64(1 << 62),
+		Size:         subStats.Size,
+	}
+}
+
+// If you're empty and you know it, clap your hands.
+func (it *Optional) Size() (int64, bool) {
+	return 0, true
+}
+
+var _ graph.Iterator = &Optional{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/or_iterator.go b/vendor/github.com/google/cayley/graph/iterator/or_iterator.go
new file mode 100644
index 00000000..c94d8a18
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/or_iterator.go
@@ -0,0 +1,315 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// Defines the or and short-circuiting or iterator. Or is the union operator for it's subiterators.
+// Short-circuiting-or is a little different. It will return values from the first graph.iterator that returns
+// values at all, and then stops.
+//
+// Never reorders the iterators from the order they arrive. It is either the union or the first one.
+// May return the same value twice -- once for each branch.
+
+import (
+	"github.com/google/cayley/graph"
+)
+
+type Or struct {
+	uid               uint64
+	tags              graph.Tagger
+	isShortCircuiting bool
+	internalIterators []graph.Iterator
+	itCount           int
+	currentIterator   int
+	result            graph.Value
+	err               error
+}
+
+func NewOr() *Or {
+	return &Or{
+		uid:               NextUID(),
+		internalIterators: make([]graph.Iterator, 0, 20),
+		currentIterator:   -1,
+	}
+}
+
+func NewShortCircuitOr() *Or {
+	return &Or{
+		uid:               NextUID(),
+		internalIterators: make([]graph.Iterator, 0, 20),
+		isShortCircuiting: true,
+		currentIterator:   -1,
+	}
+}
+
+func (it *Or) UID() uint64 {
+	return it.uid
+}
+
+// Reset all internal iterators
+func (it *Or) Reset() {
+	for _, sub := range it.internalIterators {
+		sub.Reset()
+	}
+	it.currentIterator = -1
+}
+
+func (it *Or) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Or) Clone() graph.Iterator {
+	var or *Or
+	if it.isShortCircuiting {
+		or = NewShortCircuitOr()
+	} else {
+		or = NewOr()
+	}
+	for _, sub := range it.internalIterators {
+		or.AddSubIterator(sub.Clone())
+	}
+	or.tags.CopyFrom(it)
+	return or
+}
+
+// Returns a list.List of the subiterators, in order. The returned slice must not be modified.
+func (it *Or) SubIterators() []graph.Iterator {
+	return it.internalIterators
+}
+
+// Overrides BaseIterator TagResults, as it needs to add it's own results and
+// recurse down it's subiterators.
+func (it *Or) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	it.internalIterators[it.currentIterator].TagResults(dst)
+}
+
+func (it *Or) Describe() graph.Description {
+	subIts := make([]graph.Description, len(it.internalIterators))
+	for i, sub := range it.internalIterators {
+		subIts[i] = sub.Describe()
+	}
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Iterators: subIts,
+	}
+}
+
+// Add a subiterator to this Or graph.iterator. Order matters.
+func (it *Or) AddSubIterator(sub graph.Iterator) {
+	it.internalIterators = append(it.internalIterators, sub)
+	it.itCount++
+}
+
+// Next advances the Or graph.iterator. Because the Or is the union of its
+// subiterators, it must produce from all subiterators -- unless it it
+// shortcircuiting, in which case, it is the first one that returns anything.
+func (it *Or) Next() bool {
+	graph.NextLogIn(it)
+	var first bool
+	for {
+		if it.currentIterator == -1 {
+			it.currentIterator = 0
+			first = true
+		}
+		curIt := it.internalIterators[it.currentIterator]
+
+		if graph.Next(curIt) {
+			it.result = curIt.Result()
+			return graph.NextLogOut(it, it.result, true)
+		}
+
+		it.err = curIt.Err()
+		if it.err != nil {
+			return graph.NextLogOut(it, nil, false)
+		}
+
+		if it.isShortCircuiting && !first {
+			break
+		}
+		it.currentIterator++
+		if it.currentIterator == it.itCount {
+			break
+		}
+	}
+
+	return graph.NextLogOut(it, nil, false)
+}
+
+func (it *Or) Err() error {
+	return it.err
+}
+
+func (it *Or) Result() graph.Value {
+	return it.result
+}
+
+// Checks a value against the iterators, in order.
+func (it *Or) subItsContain(val graph.Value) (bool, error) {
+	var subIsGood = false
+	for i, sub := range it.internalIterators {
+		subIsGood = sub.Contains(val)
+		if subIsGood {
+			it.currentIterator = i
+			break
+		}
+
+		err := sub.Err()
+		if err != nil {
+			return false, err
+		}
+	}
+	return subIsGood, nil
+}
+
+// Check a value against the entire graph.iterator, in order.
+func (it *Or) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	anyGood, err := it.subItsContain(val)
+	if err != nil {
+		it.err = err
+		return false
+	} else if !anyGood {
+		return graph.ContainsLogOut(it, val, false)
+	}
+	it.result = val
+	return graph.ContainsLogOut(it, val, true)
+}
+
+// Returns the approximate size of the Or graph.iterator. Because we're dealing
+// with a union, we know that the largest we can be is the sum of all the iterators,
+// or in the case of short-circuiting, the longest.
+func (it *Or) Size() (int64, bool) {
+	var val int64
+	var b bool
+	if it.isShortCircuiting {
+		val = 0
+		b = true
+		for _, sub := range it.internalIterators {
+			newval, newb := sub.Size()
+			if val < newval {
+				val = newval
+			}
+			b = newb && b
+		}
+	} else {
+		val = 0
+		b = true
+		for _, sub := range it.internalIterators {
+			newval, newb := sub.Size()
+			val += newval
+			b = newb && b
+		}
+	}
+	return val, b
+}
+
+// An Or has no NextPath of its own -- that is, there are no other values
+// which satisfy our previous result that are not the result itself. Our
+// subiterators might, however, so just pass the call recursively. In the case of
+// shortcircuiting, only allow new results from the currently checked graph.iterator
+func (it *Or) NextPath() bool {
+	if it.currentIterator != -1 {
+		currIt := it.internalIterators[it.currentIterator]
+		ok := currIt.NextPath()
+		if !ok {
+			it.err = currIt.Err()
+		}
+		return ok
+	}
+	return false
+}
+
+// Perform or-specific cleanup, of which there currently is none.
+func (it *Or) cleanUp() {}
+
+// Close this graph.iterator, and, by extension, close the subiterators.
+// Close should be idempotent, and it follows that if it's subiterators
+// follow this contract, the Or follows the contract.  It closes all
+// subiterators it can, but returns the first error it encounters.
+func (it *Or) Close() error {
+	it.cleanUp()
+
+	var err error
+	for _, sub := range it.internalIterators {
+		_err := sub.Close()
+		if _err != nil && err == nil {
+			err = _err
+		}
+	}
+
+	return err
+}
+
+func (it *Or) Optimize() (graph.Iterator, bool) {
+	old := it.SubIterators()
+	optIts := optimizeSubIterators(old)
+	// Close the replaced iterators (they ought to close themselves, but Close()
+	// is idempotent, so this just protects against any machinations).
+	closeIteratorList(old, nil)
+	newOr := NewOr()
+	newOr.isShortCircuiting = it.isShortCircuiting
+
+	// Add the subiterators in order.
+	for _, o := range optIts {
+		newOr.AddSubIterator(o)
+	}
+
+	// Move the tags hanging on us (like any good replacement).
+	newOr.tags.CopyFrom(it)
+
+	// And close ourselves but not our subiterators -- some may still be alive in
+	// the new And (they were unchanged upon calling Optimize() on them, at the
+	// start).
+	it.cleanUp()
+	return newOr, true
+}
+
+func (it *Or) Stats() graph.IteratorStats {
+	ContainsCost := int64(0)
+	NextCost := int64(0)
+	Size := int64(0)
+	for _, sub := range it.internalIterators {
+		stats := sub.Stats()
+		NextCost += stats.NextCost
+		ContainsCost += stats.ContainsCost
+		if it.isShortCircuiting {
+			if Size < stats.Size {
+				Size = stats.Size
+			}
+		} else {
+			Size += stats.Size
+		}
+	}
+	return graph.IteratorStats{
+		ContainsCost: ContainsCost,
+		NextCost:     NextCost,
+		Size:         Size,
+	}
+
+}
+
+// Register this as an "or" graph.iterator.
+func (it *Or) Type() graph.Type { return graph.Or }
+
+var _ graph.Nexter = &Or{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/query_shape.go b/vendor/github.com/google/cayley/graph/iterator/query_shape.go
new file mode 100644
index 00000000..ad914875
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/query_shape.go
@@ -0,0 +1,178 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+import (
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+type Node struct {
+	ID         int      `json:"id"`
+	Tags       []string `json:"tags,omitempty"`
+	Values     []string `json:"values,omitempty"`
+	IsLinkNode bool     `json:"is_link_node"`
+	IsFixed    bool     `json:"is_fixed"`
+}
+
+type Link struct {
+	Source   int `json:"source"`
+	Target   int `json:"target"`
+	Pred     int `json:"type"`
+	LinkNode int `json:"link_node"`
+}
+
+type queryShape struct {
+	nodes    []Node
+	links    []Link
+	qs       graph.QuadStore
+	nodeID   int
+	hasaIDs  []int
+	hasaDirs []quad.Direction
+}
+
+func OutputQueryShapeForIterator(it graph.Iterator, qs graph.QuadStore, outputMap map[string]interface{}) {
+	s := &queryShape{
+		qs:     qs,
+		nodeID: 1,
+	}
+
+	node := s.MakeNode(it.Clone())
+	s.AddNode(node)
+	outputMap["nodes"] = s.nodes
+	outputMap["links"] = s.links
+}
+
+func (s *queryShape) AddNode(n *Node) {
+	s.nodes = append(s.nodes, *n)
+}
+
+func (s *queryShape) AddLink(l *Link) {
+	s.links = append(s.links, *l)
+}
+
+func (s *queryShape) LastHasa() (int, quad.Direction) {
+	return s.hasaIDs[len(s.hasaIDs)-1], s.hasaDirs[len(s.hasaDirs)-1]
+}
+
+func (s *queryShape) PushHasa(i int, d quad.Direction) {
+	s.hasaIDs = append(s.hasaIDs, i)
+	s.hasaDirs = append(s.hasaDirs, d)
+}
+
+func (s *queryShape) RemoveHasa() {
+	s.hasaIDs = s.hasaIDs[:len(s.hasaIDs)-1]
+	s.hasaDirs = s.hasaDirs[:len(s.hasaDirs)-1]
+}
+
+func (s *queryShape) StealNode(left *Node, right *Node) {
+	for _, v := range right.Values {
+		left.Values = append(left.Values, v)
+	}
+	for _, v := range right.Tags {
+		left.Tags = append(left.Tags, v)
+	}
+	left.IsLinkNode = left.IsLinkNode || right.IsLinkNode
+	left.IsFixed = left.IsFixed || right.IsFixed
+	for i, link := range s.links {
+		rewrite := false
+		if link.LinkNode == right.ID {
+			link.LinkNode = left.ID
+			rewrite = true
+		}
+		if link.Source == right.ID {
+			link.Source = left.ID
+			rewrite = true
+		}
+		if link.Target == right.ID {
+			link.Target = left.ID
+			rewrite = true
+		}
+		if rewrite {
+			s.links = append(append(s.links[:i], s.links[i+1:]...), link)
+		}
+	}
+}
+
+func (s *queryShape) MakeNode(it graph.Iterator) *Node {
+	n := Node{ID: s.nodeID}
+	for _, tag := range it.Tagger().Tags() {
+		n.Tags = append(n.Tags, tag)
+	}
+	for k := range it.Tagger().Fixed() {
+		n.Tags = append(n.Tags, k)
+	}
+
+	switch it.Type() {
+	case graph.And:
+		for _, sub := range it.SubIterators() {
+			s.nodeID++
+			newNode := s.MakeNode(sub)
+			if sub.Type() != graph.Or {
+				s.StealNode(&n, newNode)
+			} else {
+				s.AddNode(newNode)
+				s.AddLink(&Link{n.ID, newNode.ID, 0, 0})
+			}
+		}
+	case graph.Fixed:
+		n.IsFixed = true
+		for graph.Next(it) {
+			n.Values = append(n.Values, s.qs.NameOf(it.Result()))
+		}
+	case graph.HasA:
+		hasa := it.(*HasA)
+		s.PushHasa(n.ID, hasa.dir)
+		s.nodeID++
+		newNode := s.MakeNode(hasa.primaryIt)
+		s.AddNode(newNode)
+		s.RemoveHasa()
+	case graph.Or:
+		for _, sub := range it.SubIterators() {
+			s.nodeID++
+			newNode := s.MakeNode(sub)
+			if sub.Type() == graph.Or {
+				s.StealNode(&n, newNode)
+			} else {
+				s.AddNode(newNode)
+				s.AddLink(&Link{n.ID, newNode.ID, 0, 0})
+			}
+		}
+	case graph.LinksTo:
+		n.IsLinkNode = true
+		lto := it.(*LinksTo)
+		s.nodeID++
+		newNode := s.MakeNode(lto.primaryIt)
+		hasaID, hasaDir := s.LastHasa()
+		if (hasaDir == quad.Subject && lto.dir == quad.Object) ||
+			(hasaDir == quad.Object && lto.dir == quad.Subject) {
+			s.AddNode(newNode)
+			if hasaDir == quad.Subject {
+				s.AddLink(&Link{hasaID, newNode.ID, 0, n.ID})
+			} else {
+				s.AddLink(&Link{newNode.ID, hasaID, 0, n.ID})
+			}
+		} else if lto.primaryIt.Type() == graph.Fixed {
+			s.StealNode(&n, newNode)
+		} else {
+			s.AddNode(newNode)
+		}
+	case graph.Optional:
+		// Unsupported, for the moment
+		fallthrough
+	case graph.All:
+	}
+	return &n
+}
diff --git a/vendor/github.com/google/cayley/graph/iterator/unique_iterator.go b/vendor/github.com/google/cayley/graph/iterator/unique_iterator.go
new file mode 100644
index 00000000..8d031aaf
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/unique_iterator.go
@@ -0,0 +1,155 @@
+package iterator
+
+import (
+	"github.com/google/cayley/graph"
+)
+
+// Unique iterator removes duplicate values from it's subiterator.
+type Unique struct {
+	uid      uint64
+	tags     graph.Tagger
+	subIt    graph.Iterator
+	result   graph.Value
+	runstats graph.IteratorStats
+	err      error
+	seen     map[graph.Value]bool
+}
+
+func NewUnique(subIt graph.Iterator) *Unique {
+	return &Unique{
+		uid:   NextUID(),
+		subIt: subIt,
+		seen:  make(map[graph.Value]bool),
+	}
+}
+
+func (it *Unique) UID() uint64 {
+	return it.uid
+}
+
+// Reset resets the internal iterators and the iterator itself.
+func (it *Unique) Reset() {
+	it.result = nil
+	it.subIt.Reset()
+	it.seen = make(map[graph.Value]bool)
+}
+
+func (it *Unique) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Unique) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	if it.subIt != nil {
+		it.subIt.TagResults(dst)
+	}
+}
+
+func (it *Unique) Clone() graph.Iterator {
+	uniq := NewUnique(it.subIt.Clone())
+	uniq.tags.CopyFrom(it)
+	return uniq
+}
+
+// SubIterators returns a slice of the sub iterators. The first iterator is the
+// primary iterator, for which the complement is generated.
+func (it *Unique) SubIterators() []graph.Iterator {
+	return []graph.Iterator{it.subIt}
+}
+
+// Next advances the subiterator, continuing until it returns a value which it
+// has not previously seen.
+func (it *Unique) Next() bool {
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+
+	for graph.Next(it.subIt) {
+		curr := it.subIt.Result()
+		if ok := it.seen[curr]; !ok {
+			it.result = curr
+			it.seen[curr] = true
+			return graph.NextLogOut(it, it.result, true)
+		}
+	}
+	it.err = it.subIt.Err()
+	return graph.NextLogOut(it, nil, false)
+}
+
+func (it *Unique) Err() error {
+	return it.err
+}
+
+func (it *Unique) Result() graph.Value {
+	return it.result
+}
+
+// Contains checks whether the passed value is part of the primary iterator,
+// which is irrelevant for uniqueness.
+func (it *Unique) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	it.runstats.Contains += 1
+	return graph.ContainsLogOut(it, val, it.subIt.Contains(val))
+}
+
+// NextPath for unique always returns false. If we were to return multiple
+// paths, we'd no longer be a unique result, so we have to choose only the first
+// path that got us here. Unique is serious on this point.
+func (it *Unique) NextPath() bool {
+	return false
+}
+
+// Close closes the primary iterators.
+func (it *Unique) Close() error {
+	it.seen = nil
+	return it.subIt.Close()
+}
+
+func (it *Unique) Type() graph.Type { return graph.Unique }
+
+func (it *Unique) Optimize() (graph.Iterator, bool) {
+	newIt, optimized := it.subIt.Optimize()
+	if optimized {
+		it.subIt = newIt
+	}
+	return it, false
+}
+
+const uniquenessFactor = 2
+
+func (it *Unique) Stats() graph.IteratorStats {
+	subStats := it.subIt.Stats()
+	return graph.IteratorStats{
+		NextCost:     subStats.NextCost * uniquenessFactor,
+		ContainsCost: subStats.ContainsCost,
+		Size:         subStats.Size / uniquenessFactor,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+		ContainsNext: it.runstats.ContainsNext,
+	}
+}
+
+func (it *Unique) Size() (int64, bool) {
+	return it.Stats().Size, false
+}
+
+func (it *Unique) Describe() graph.Description {
+	subIts := []graph.Description{
+		it.subIt.Describe(),
+	}
+
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Iterators: subIts,
+	}
+}
+
+var _ graph.Nexter = &Unique{}
diff --git a/vendor/github.com/google/cayley/graph/iterator/value_comparison_iterator.go b/vendor/github.com/google/cayley/graph/iterator/value_comparison_iterator.go
new file mode 100644
index 00000000..b7e7fbe6
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/iterator/value_comparison_iterator.go
@@ -0,0 +1,242 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iterator
+
+// "Value Comparison" is a unary operator -- a filter across the values in the
+// relevant subiterator.
+//
+// This is hugely useful for things like label, but value ranges in general
+// come up from time to time. At *worst* we're as big as our underlying iterator.
+// At best, we're the null iterator.
+//
+// This is ripe for backend-side optimization. If you can run a value iterator,
+// from a sorted set -- some sort of value index, then go for it.
+//
+// In MQL terms, this is the [{"age>=": 21}] concept.
+
+import (
+	"strconv"
+
+	"github.com/google/cayley/graph"
+)
+
+type Operator int
+
+const (
+	compareLT Operator = iota
+	compareLTE
+	compareGT
+	compareGTE
+	// Why no Equals? Because that's usually an AndIterator.
+)
+
+type Comparison struct {
+	uid    uint64
+	tags   graph.Tagger
+	subIt  graph.Iterator
+	op     Operator
+	val    interface{}
+	qs     graph.QuadStore
+	result graph.Value
+	err    error
+}
+
+func NewComparison(sub graph.Iterator, op Operator, val interface{}, qs graph.QuadStore) *Comparison {
+	return &Comparison{
+		uid:   NextUID(),
+		subIt: sub,
+		op:    op,
+		val:   val,
+		qs:    qs,
+	}
+}
+
+func (it *Comparison) UID() uint64 {
+	return it.uid
+}
+
+// Here's the non-boilerplate part of the ValueComparison iterator. Given a value
+// and our operator, determine whether or not we meet the requirement.
+func (it *Comparison) doComparison(val graph.Value) bool {
+	nodeStr := it.qs.NameOf(val)
+	switch cVal := it.val.(type) {
+	case int:
+		cInt := int64(cVal)
+		intVal, err := strconv.ParseInt(nodeStr, 10, 64)
+		if err != nil {
+			return false
+		}
+		return RunIntOp(intVal, it.op, cInt)
+	case int64:
+		intVal, err := strconv.ParseInt(nodeStr, 10, 64)
+		if err != nil {
+			return false
+		}
+		return RunIntOp(intVal, it.op, cVal)
+	case string:
+		return RunStrOp(nodeStr, it.op, cVal)
+	default:
+		return true
+	}
+}
+
+func (it *Comparison) Close() error {
+	return it.subIt.Close()
+}
+
+func RunIntOp(a int64, op Operator, b int64) bool {
+	switch op {
+	case compareLT:
+		return a < b
+	case compareLTE:
+		return a <= b
+	case compareGT:
+		return a > b
+	case compareGTE:
+		return a >= b
+	default:
+		panic("Unknown operator type")
+	}
+}
+
+func RunStrOp(a string, op Operator, b string) bool {
+	switch op {
+	case compareLT:
+		return a < b
+	case compareLTE:
+		return a <= b
+	case compareGT:
+		return a > b
+	case compareGTE:
+		return a >= b
+	default:
+		panic("Unknown operator type")
+	}
+}
+
+func (it *Comparison) Reset() {
+	it.subIt.Reset()
+}
+
+func (it *Comparison) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Comparison) Clone() graph.Iterator {
+	out := NewComparison(it.subIt.Clone(), it.op, it.val, it.qs)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+func (it *Comparison) Next() bool {
+	for graph.Next(it.subIt) {
+		val := it.subIt.Result()
+		if it.doComparison(val) {
+			it.result = val
+			return true
+		}
+	}
+	it.err = it.subIt.Err()
+	return false
+}
+
+func (it *Comparison) Err() error {
+	return it.err
+}
+
+func (it *Comparison) Result() graph.Value {
+	return it.result
+}
+
+func (it *Comparison) NextPath() bool {
+	for {
+		hasNext := it.subIt.NextPath()
+		if !hasNext {
+			it.err = it.subIt.Err()
+			return false
+		}
+		if it.doComparison(it.subIt.Result()) {
+			break
+		}
+	}
+	it.result = it.subIt.Result()
+	return true
+}
+
+// No subiterators.
+func (it *Comparison) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *Comparison) Contains(val graph.Value) bool {
+	if !it.doComparison(val) {
+		return false
+	}
+	ok := it.subIt.Contains(val)
+	if !ok {
+		it.err = it.subIt.Err()
+	}
+	return ok
+}
+
+// If we failed the check, then the subiterator should not contribute to the result
+// set. Otherwise, go ahead and tag it.
+func (it *Comparison) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	it.subIt.TagResults(dst)
+}
+
+// Registers the value-comparison iterator.
+func (it *Comparison) Type() graph.Type { return graph.Comparison }
+
+func (it *Comparison) Describe() graph.Description {
+	primary := it.subIt.Describe()
+	return graph.Description{
+		UID:      it.UID(),
+		Type:     it.Type(),
+		Iterator: &primary,
+	}
+}
+
+// There's nothing to optimize, locally, for a value-comparison iterator.
+// Replace the underlying iterator if need be.
+// potentially replace it.
+func (it *Comparison) Optimize() (graph.Iterator, bool) {
+	newSub, changed := it.subIt.Optimize()
+	if changed {
+		it.subIt.Close()
+		it.subIt = newSub
+	}
+	return it, false
+}
+
+// We're only as expensive as our subiterator.
+// Again, optimized value comparison iterators should do better.
+func (it *Comparison) Stats() graph.IteratorStats {
+	return it.subIt.Stats()
+}
+
+func (it *Comparison) Size() (int64, bool) {
+	return 0, true
+}
+
+var _ graph.Nexter = &Comparison{}
diff --git a/vendor/github.com/google/cayley/graph/leveldb/all_iterator.go b/vendor/github.com/google/cayley/graph/leveldb/all_iterator.go
new file mode 100644
index 00000000..8de7a094
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/leveldb/all_iterator.go
@@ -0,0 +1,188 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package leveldb
+
+import (
+	"bytes"
+
+	ldbit "github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+type AllIterator struct {
+	uid    uint64
+	tags   graph.Tagger
+	prefix []byte
+	dir    quad.Direction
+	open   bool
+	iter   ldbit.Iterator
+	qs     *QuadStore
+	ro     *opt.ReadOptions
+	result graph.Value
+}
+
+func NewAllIterator(prefix string, d quad.Direction, qs *QuadStore) *AllIterator {
+	opts := &opt.ReadOptions{
+		DontFillCache: true,
+	}
+
+	it := AllIterator{
+		uid:    iterator.NextUID(),
+		ro:     opts,
+		iter:   qs.db.NewIterator(nil, opts),
+		prefix: []byte(prefix),
+		dir:    d,
+		open:   true,
+		qs:     qs,
+	}
+
+	it.iter.Seek(it.prefix)
+	if !it.iter.Valid() {
+		// FIXME(kortschak) What are the semantics here? Is this iterator usable?
+		// If not, we should return nil *Iterator and an error.
+		it.open = false
+		it.iter.Release()
+	}
+
+	return &it
+}
+
+func (it *AllIterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *AllIterator) Reset() {
+	if !it.open {
+		it.iter = it.qs.db.NewIterator(nil, it.ro)
+		it.open = true
+	}
+	it.iter.Seek(it.prefix)
+	if !it.iter.Valid() {
+		it.open = false
+		it.iter.Release()
+	}
+}
+
+func (it *AllIterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *AllIterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *AllIterator) Clone() graph.Iterator {
+	out := NewAllIterator(string(it.prefix), it.dir, it.qs)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+func (it *AllIterator) Next() bool {
+	if !it.open {
+		it.result = nil
+		return false
+	}
+	var out []byte
+	out = make([]byte, len(it.iter.Key()))
+	copy(out, it.iter.Key())
+	it.iter.Next()
+	if !it.iter.Valid() {
+		it.Close()
+	}
+	if !bytes.HasPrefix(out, it.prefix) {
+		it.Close()
+		return false
+	}
+	it.result = Token(out)
+	return true
+}
+
+func (it *AllIterator) Err() error {
+	return it.iter.Error()
+}
+
+func (it *AllIterator) Result() graph.Value {
+	return it.result
+}
+
+func (it *AllIterator) NextPath() bool {
+	return false
+}
+
+// No subiterators.
+func (it *AllIterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *AllIterator) Contains(v graph.Value) bool {
+	it.result = v
+	return true
+}
+
+func (it *AllIterator) Close() error {
+	if it.open {
+		it.iter.Release()
+		it.open = false
+	}
+	return nil
+}
+
+func (it *AllIterator) Size() (int64, bool) {
+	size, err := it.qs.SizeOfPrefix(it.prefix)
+	if err == nil {
+		return size, false
+	}
+	// INT64_MAX
+	return int64(^uint64(0) >> 1), false
+}
+
+func (it *AllIterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Size:      size,
+		Direction: it.dir,
+	}
+}
+
+func (it *AllIterator) Type() graph.Type { return graph.All }
+func (it *AllIterator) Sorted() bool     { return false }
+
+func (it *AllIterator) Optimize() (graph.Iterator, bool) {
+	return it, false
+}
+
+func (it *AllIterator) Stats() graph.IteratorStats {
+	s, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     2,
+		Size:         s,
+	}
+}
+
+var _ graph.Nexter = &AllIterator{}
diff --git a/vendor/github.com/google/cayley/graph/leveldb/iterator.go b/vendor/github.com/google/cayley/graph/leveldb/iterator.go
new file mode 100644
index 00000000..67640b1b
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/leveldb/iterator.go
@@ -0,0 +1,293 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package leveldb
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/barakmich/glog"
+	ldbit "github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+type Iterator struct {
+	uid            uint64
+	tags           graph.Tagger
+	nextPrefix     []byte
+	checkID        []byte
+	dir            quad.Direction
+	open           bool
+	iter           ldbit.Iterator
+	qs             *QuadStore
+	ro             *opt.ReadOptions
+	originalPrefix string
+	result         graph.Value
+}
+
+func NewIterator(prefix string, d quad.Direction, value graph.Value, qs *QuadStore) *Iterator {
+	vb := value.(Token)
+	p := make([]byte, 0, 2+hashSize)
+	p = append(p, []byte(prefix)...)
+	p = append(p, []byte(vb[1:])...)
+
+	opts := &opt.ReadOptions{
+		DontFillCache: true,
+	}
+
+	it := Iterator{
+		uid:            iterator.NextUID(),
+		nextPrefix:     p,
+		checkID:        vb,
+		dir:            d,
+		originalPrefix: prefix,
+		ro:             opts,
+		iter:           qs.db.NewIterator(nil, opts),
+		open:           true,
+		qs:             qs,
+	}
+
+	ok := it.iter.Seek(it.nextPrefix)
+	if !ok {
+		it.open = false
+		it.iter.Release()
+		glog.Error("Opening LevelDB iterator couldn't seek to location ", it.nextPrefix)
+	}
+
+	return &it
+}
+
+func (it *Iterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *Iterator) Reset() {
+	if !it.open {
+		it.iter = it.qs.db.NewIterator(nil, it.ro)
+		it.open = true
+	}
+	ok := it.iter.Seek(it.nextPrefix)
+	if !ok {
+		it.open = false
+		it.iter.Release()
+	}
+}
+
+func (it *Iterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Iterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Iterator) Clone() graph.Iterator {
+	out := NewIterator(it.originalPrefix, it.dir, Token(it.checkID), it.qs)
+	out.tags.CopyFrom(it)
+	return out
+}
+
+func (it *Iterator) Close() error {
+	if it.open {
+		it.iter.Release()
+		it.open = false
+	}
+	return nil
+}
+
+func (it *Iterator) isLiveValue(val []byte) bool {
+	var entry IndexEntry
+	json.Unmarshal(val, &entry)
+	return len(entry.History)%2 != 0
+}
+
+func (it *Iterator) Next() bool {
+	if it.iter == nil {
+		it.result = nil
+		return false
+	}
+	if !it.open {
+		it.result = nil
+		return false
+	}
+	if !it.iter.Valid() {
+		it.result = nil
+		it.Close()
+		return false
+	}
+	if bytes.HasPrefix(it.iter.Key(), it.nextPrefix) {
+		if !it.isLiveValue(it.iter.Value()) {
+			ok := it.iter.Next()
+			if !ok {
+				it.Close()
+				return false
+			}
+			return it.Next()
+		}
+		out := make([]byte, len(it.iter.Key()))
+		copy(out, it.iter.Key())
+		it.result = Token(out)
+		ok := it.iter.Next()
+		if !ok {
+			it.Close()
+		}
+		return true
+	}
+	it.Close()
+	it.result = nil
+	return false
+}
+
+func (it *Iterator) Err() error {
+	return it.iter.Error()
+}
+
+func (it *Iterator) Result() graph.Value {
+	return it.result
+}
+
+func (it *Iterator) NextPath() bool {
+	return false
+}
+
+// No subiterators.
+func (it *Iterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func PositionOf(prefix []byte, d quad.Direction, qs *QuadStore) int {
+	if bytes.Equal(prefix, []byte("sp")) {
+		switch d {
+		case quad.Subject:
+			return 2
+		case quad.Predicate:
+			return hashSize + 2
+		case quad.Object:
+			return 2*hashSize + 2
+		case quad.Label:
+			return 3*hashSize + 2
+		}
+	}
+	if bytes.Equal(prefix, []byte("po")) {
+		switch d {
+		case quad.Subject:
+			return 2*hashSize + 2
+		case quad.Predicate:
+			return 2
+		case quad.Object:
+			return hashSize + 2
+		case quad.Label:
+			return 3*hashSize + 2
+		}
+	}
+	if bytes.Equal(prefix, []byte("os")) {
+		switch d {
+		case quad.Subject:
+			return hashSize + 2
+		case quad.Predicate:
+			return 2*hashSize + 2
+		case quad.Object:
+			return 2
+		case quad.Label:
+			return 3*hashSize + 2
+		}
+	}
+	if bytes.Equal(prefix, []byte("cp")) {
+		switch d {
+		case quad.Subject:
+			return 2*hashSize + 2
+		case quad.Predicate:
+			return hashSize + 2
+		case quad.Object:
+			return 3*hashSize + 2
+		case quad.Label:
+			return 2
+		}
+	}
+	panic("unreachable")
+}
+
+func (it *Iterator) Contains(v graph.Value) bool {
+	val := v.(Token)
+	if val[0] == 'z' {
+		return false
+	}
+	offset := PositionOf(val[0:2], it.dir, it.qs)
+	if bytes.HasPrefix(val[offset:], it.checkID[1:]) {
+		// You may ask, why don't we check to see if it's a valid (not deleted) quad
+		// again?
+		//
+		// We've already done that -- in order to get the graph.Value token in the
+		// first place, we had to have done the check already; it came from a Next().
+		//
+		// However, if it ever starts coming from somewhere else, it'll be more
+		// efficient to change the interface of the graph.Value for LevelDB to a
+		// struct with a flag for isValid, to save another random read.
+		return true
+	}
+	return false
+}
+
+func (it *Iterator) Size() (int64, bool) {
+	return it.qs.SizeOf(Token(it.checkID)), true
+}
+
+func (it *Iterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:       it.UID(),
+		Name:      it.qs.NameOf(Token(it.checkID)),
+		Type:      it.Type(),
+		Tags:      it.tags.Tags(),
+		Size:      size,
+		Direction: it.dir,
+	}
+}
+
+var levelDBType graph.Type
+
+func init() {
+	levelDBType = graph.RegisterIterator("leveldb")
+}
+
+func Type() graph.Type { return levelDBType }
+
+func (it *Iterator) Type() graph.Type { return levelDBType }
+func (it *Iterator) Sorted() bool     { return false }
+
+func (it *Iterator) Optimize() (graph.Iterator, bool) {
+	return it, false
+}
+
+func (it *Iterator) Stats() graph.IteratorStats {
+	s, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     2,
+		Size:         s,
+	}
+}
+
+var _ graph.Nexter = &Iterator{}
diff --git a/vendor/github.com/google/cayley/graph/leveldb/quadstore.go b/vendor/github.com/google/cayley/graph/leveldb/quadstore.go
new file mode 100644
index 00000000..8437ae62
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/leveldb/quadstore.go
@@ -0,0 +1,514 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package leveldb
+
+import (
+	"bytes"
+	"crypto/sha1"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hash"
+	"sync"
+
+	"github.com/barakmich/glog"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/util"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+func init() {
+	graph.RegisterQuadStore(QuadStoreType, graph.QuadStoreRegistration{
+		NewFunc:           newQuadStore,
+		NewForRequestFunc: nil,
+		UpgradeFunc:       nil,
+		InitFunc:          createNewLevelDB,
+		IsPersistent:      true,
+	})
+}
+
+const (
+	DefaultCacheSize       = 2
+	DefaultWriteBufferSize = 20
+	QuadStoreType          = "leveldb"
+)
+
+var (
+	hashPool = sync.Pool{
+		New: func() interface{} { return sha1.New() },
+	}
+	hashSize = sha1.Size
+)
+
+type Token []byte
+
+func (t Token) Key() interface{} {
+	return string(t)
+}
+
+type QuadStore struct {
+	dbOpts    *opt.Options
+	db        *leveldb.DB
+	path      string
+	open      bool
+	size      int64
+	horizon   int64
+	writeopts *opt.WriteOptions
+	readopts  *opt.ReadOptions
+}
+
+func createNewLevelDB(path string, _ graph.Options) error {
+	opts := &opt.Options{}
+	db, err := leveldb.OpenFile(path, opts)
+	if err != nil {
+		glog.Errorf("Error: could not create database: %v", err)
+		return err
+	}
+	defer db.Close()
+	qs := &QuadStore{}
+	qs.db = db
+	qs.writeopts = &opt.WriteOptions{
+		Sync: true,
+	}
+	qs.Close()
+	return nil
+}
+
+func newQuadStore(path string, options graph.Options) (graph.QuadStore, error) {
+	var qs QuadStore
+	var err error
+	qs.path = path
+	cacheSize := DefaultCacheSize
+	val, ok, err := options.IntKey("cache_size_mb")
+	if err != nil {
+		return nil, err
+	} else if ok {
+		cacheSize = val
+	}
+	qs.dbOpts = &opt.Options{
+		BlockCacheCapacity: cacheSize * opt.MiB,
+	}
+	qs.dbOpts.ErrorIfMissing = true
+
+	writeBufferSize := DefaultWriteBufferSize
+	val, ok, err = options.IntKey("writeBufferSize")
+	if err != nil {
+		return nil, err
+	} else if ok {
+		writeBufferSize = val
+	}
+	qs.dbOpts.WriteBuffer = writeBufferSize * opt.MiB
+	qs.writeopts = &opt.WriteOptions{
+		Sync: false,
+	}
+	qs.readopts = &opt.ReadOptions{}
+	db, err := leveldb.OpenFile(qs.path, qs.dbOpts)
+	if err != nil {
+		glog.Errorln("Error, could not open! ", err)
+		return nil, err
+	}
+	qs.db = db
+	glog.Infoln(qs.GetStats())
+	err = qs.getMetadata()
+	if err != nil {
+		return nil, err
+	}
+	return &qs, nil
+}
+
+func (qs *QuadStore) GetStats() string {
+	out := ""
+	stats, err := qs.db.GetProperty("leveldb.stats")
+	if err == nil {
+		out += fmt.Sprintln("Stats: ", stats)
+	}
+	out += fmt.Sprintln("Size: ", qs.size)
+	return out
+}
+
+func (qs *QuadStore) Size() int64 {
+	return qs.size
+}
+
+func (qs *QuadStore) Horizon() graph.PrimaryKey {
+	return graph.NewSequentialKey(qs.horizon)
+}
+
+func hashOf(s string) []byte {
+	h := hashPool.Get().(hash.Hash)
+	h.Reset()
+	defer hashPool.Put(h)
+	key := make([]byte, 0, hashSize)
+	h.Write([]byte(s))
+	key = h.Sum(key)
+	return key
+}
+
+func (qs *QuadStore) createKeyFor(d [4]quad.Direction, q quad.Quad) []byte {
+	key := make([]byte, 0, 2+(hashSize*4))
+	// TODO(kortschak) Remove dependence on String() method.
+	key = append(key, []byte{d[0].Prefix(), d[1].Prefix()}...)
+	key = append(key, hashOf(q.Get(d[0]))...)
+	key = append(key, hashOf(q.Get(d[1]))...)
+	key = append(key, hashOf(q.Get(d[2]))...)
+	key = append(key, hashOf(q.Get(d[3]))...)
+	return key
+}
+
+func (qs *QuadStore) createValueKeyFor(s string) []byte {
+	key := make([]byte, 0, 1+hashSize)
+	key = append(key, []byte("z")...)
+	key = append(key, hashOf(s)...)
+	return key
+}
+
+type IndexEntry struct {
+	quad.Quad
+	History []int64
+}
+
+// Short hand for direction permutations.
+var (
+	spo = [4]quad.Direction{quad.Subject, quad.Predicate, quad.Object, quad.Label}
+	osp = [4]quad.Direction{quad.Object, quad.Subject, quad.Predicate, quad.Label}
+	pos = [4]quad.Direction{quad.Predicate, quad.Object, quad.Subject, quad.Label}
+	cps = [4]quad.Direction{quad.Label, quad.Predicate, quad.Subject, quad.Object}
+)
+
+func (qs *QuadStore) ApplyDeltas(deltas []graph.Delta, ignoreOpts graph.IgnoreOpts) error {
+	batch := &leveldb.Batch{}
+	resizeMap := make(map[string]int64)
+	sizeChange := int64(0)
+	for _, d := range deltas {
+		if d.Action != graph.Add && d.Action != graph.Delete {
+			return errors.New("leveldb: invalid action")
+		}
+		bytes, err := json.Marshal(d)
+		if err != nil {
+			return err
+		}
+		batch.Put(keyFor(d), bytes)
+		err = qs.buildQuadWrite(batch, d.Quad, d.ID.Int(), d.Action == graph.Add)
+		if err != nil {
+			if err == graph.ErrQuadExists && ignoreOpts.IgnoreDup {
+				continue
+			}
+			if err == graph.ErrQuadNotExist && ignoreOpts.IgnoreMissing {
+				continue
+			}
+			return err
+		}
+		delta := int64(1)
+		if d.Action == graph.Delete {
+			delta = int64(-1)
+		}
+		resizeMap[d.Quad.Subject] += delta
+		resizeMap[d.Quad.Predicate] += delta
+		resizeMap[d.Quad.Object] += delta
+		if d.Quad.Label != "" {
+			resizeMap[d.Quad.Label] += delta
+		}
+		sizeChange += delta
+		qs.horizon = d.ID.Int()
+	}
+	for k, v := range resizeMap {
+		if v != 0 {
+			err := qs.UpdateValueKeyBy(k, v, batch)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	err := qs.db.Write(batch, qs.writeopts)
+	if err != nil {
+		glog.Error("could not write to DB for quadset.")
+		return err
+	}
+	qs.size += sizeChange
+	return nil
+}
+
+func keyFor(d graph.Delta) []byte {
+	key := make([]byte, 0, 19)
+	key = append(key, 'd')
+	key = append(key, []byte(fmt.Sprintf("%018x", d.ID.Int()))...)
+	return key
+}
+
+func (qs *QuadStore) buildQuadWrite(batch *leveldb.Batch, q quad.Quad, id int64, isAdd bool) error {
+	var entry IndexEntry
+	data, err := qs.db.Get(qs.createKeyFor(spo, q), qs.readopts)
+	if err != nil && err != leveldb.ErrNotFound {
+		glog.Error("could not access DB to prepare index: ", err)
+		return err
+	}
+	if err == nil {
+		// We got something.
+		err = json.Unmarshal(data, &entry)
+		if err != nil {
+			return err
+		}
+	} else {
+		entry.Quad = q
+	}
+
+	if isAdd && len(entry.History)%2 == 1 {
+		glog.Errorf("attempt to add existing quad %v: %#v", entry, q)
+		return graph.ErrQuadExists
+	}
+	if !isAdd && len(entry.History)%2 == 0 {
+		glog.Error("attempt to delete non-existent quad %v: %#c", entry, q)
+		return graph.ErrQuadNotExist
+	}
+
+	entry.History = append(entry.History, id)
+
+	bytes, err := json.Marshal(entry)
+	if err != nil {
+		glog.Errorf("could not write to buffer for entry %#v: %s", entry, err)
+		return err
+	}
+	batch.Put(qs.createKeyFor(spo, q), bytes)
+	batch.Put(qs.createKeyFor(osp, q), bytes)
+	batch.Put(qs.createKeyFor(pos, q), bytes)
+	if q.Get(quad.Label) != "" {
+		batch.Put(qs.createKeyFor(cps, q), bytes)
+	}
+	return nil
+}
+
+type ValueData struct {
+	Name string
+	Size int64
+}
+
+func (qs *QuadStore) UpdateValueKeyBy(name string, amount int64, batch *leveldb.Batch) error {
+	value := &ValueData{name, amount}
+	key := qs.createValueKeyFor(name)
+	b, err := qs.db.Get(key, qs.readopts)
+
+	// Error getting the node from the database.
+	if err != nil && err != leveldb.ErrNotFound {
+		glog.Errorf("Error reading Value %s from the DB.", name)
+		return err
+	}
+
+	// Node exists in the database -- unmarshal and update.
+	if b != nil && err != leveldb.ErrNotFound {
+		err = json.Unmarshal(b, value)
+		if err != nil {
+			glog.Errorf("Error: could not reconstruct value: %v", err)
+			return err
+		}
+		value.Size += amount
+	}
+
+	// Are we deleting something?
+	if value.Size <= 0 {
+		value.Size = 0
+	}
+
+	// Repackage and rewrite.
+	bytes, err := json.Marshal(&value)
+	if err != nil {
+		glog.Errorf("could not write to buffer for value %s: %s", name, err)
+		return err
+	}
+	if batch == nil {
+		qs.db.Put(key, bytes, qs.writeopts)
+	} else {
+		batch.Put(key, bytes)
+	}
+	return nil
+}
+
+func (qs *QuadStore) Close() {
+	buf := new(bytes.Buffer)
+	err := binary.Write(buf, binary.LittleEndian, qs.size)
+	if err == nil {
+		werr := qs.db.Put([]byte("__size"), buf.Bytes(), qs.writeopts)
+		if werr != nil {
+			glog.Error("could not write size before closing!")
+		}
+	} else {
+		glog.Errorf("could not convert size before closing!")
+	}
+	buf.Reset()
+	err = binary.Write(buf, binary.LittleEndian, qs.horizon)
+	if err == nil {
+		werr := qs.db.Put([]byte("__horizon"), buf.Bytes(), qs.writeopts)
+		if werr != nil {
+			glog.Error("could not write horizon before closing!")
+		}
+	} else {
+		glog.Errorf("could not convert horizon before closing!")
+	}
+	qs.db.Close()
+	qs.open = false
+}
+
+func (qs *QuadStore) Quad(k graph.Value) quad.Quad {
+	var q quad.Quad
+	b, err := qs.db.Get(k.(Token), qs.readopts)
+	if err != nil && err != leveldb.ErrNotFound {
+		glog.Error("Error: could not get quad from DB.")
+		return quad.Quad{}
+	}
+	if err == leveldb.ErrNotFound {
+		// No harm, no foul.
+		return quad.Quad{}
+	}
+	err = json.Unmarshal(b, &q)
+	if err != nil {
+		glog.Error("Error: could not reconstruct quad.")
+		return quad.Quad{}
+	}
+	return q
+}
+
+func (qs *QuadStore) ValueOf(s string) graph.Value {
+	return Token(qs.createValueKeyFor(s))
+}
+
+func (qs *QuadStore) valueData(key []byte) ValueData {
+	var out ValueData
+	if glog.V(3) {
+		glog.V(3).Infof("%c %v", key[0], key)
+	}
+	b, err := qs.db.Get(key, qs.readopts)
+	if err != nil && err != leveldb.ErrNotFound {
+		glog.Errorln("Error: could not get value from DB")
+		return out
+	}
+	if b != nil && err != leveldb.ErrNotFound {
+		err = json.Unmarshal(b, &out)
+		if err != nil {
+			glog.Errorln("Error: could not reconstruct value")
+			return ValueData{}
+		}
+	}
+	return out
+}
+
+func (qs *QuadStore) NameOf(k graph.Value) string {
+	if k == nil {
+		glog.V(2).Info("k was nil")
+		return ""
+	}
+	return qs.valueData(k.(Token)).Name
+}
+
+func (qs *QuadStore) SizeOf(k graph.Value) int64 {
+	if k == nil {
+		return 0
+	}
+	return int64(qs.valueData(k.(Token)).Size)
+}
+
+func (qs *QuadStore) getInt64ForKey(key string, empty int64) (int64, error) {
+	var out int64
+	b, err := qs.db.Get([]byte(key), qs.readopts)
+	if err != nil && err != leveldb.ErrNotFound {
+		glog.Errorln("could not read " + key + ": " + err.Error())
+		return 0, err
+	}
+	if err == leveldb.ErrNotFound {
+		// Must be a new database. Cool
+		return empty, nil
+	}
+	buf := bytes.NewBuffer(b)
+	err = binary.Read(buf, binary.LittleEndian, &out)
+	if err != nil {
+		glog.Errorln("Error: could not parse", key)
+		return 0, err
+	}
+	return out, nil
+}
+
+func (qs *QuadStore) getMetadata() error {
+	var err error
+	qs.size, err = qs.getInt64ForKey("__size", 0)
+	if err != nil {
+		return err
+	}
+	qs.horizon, err = qs.getInt64ForKey("__horizon", 0)
+	return err
+}
+
+func (qs *QuadStore) SizeOfPrefix(pre []byte) (int64, error) {
+	limit := make([]byte, len(pre))
+	copy(limit, pre)
+	end := len(limit) - 1
+	limit[end]++
+	ranges := make([]util.Range, 1)
+	ranges[0].Start = pre
+	ranges[0].Limit = limit
+	sizes, err := qs.db.SizeOf(ranges)
+	if err == nil {
+		return (int64(sizes[0]) >> 6) + 1, nil
+	}
+	return 0, nil
+}
+
+func (qs *QuadStore) QuadIterator(d quad.Direction, val graph.Value) graph.Iterator {
+	var prefix string
+	switch d {
+	case quad.Subject:
+		prefix = "sp"
+	case quad.Predicate:
+		prefix = "po"
+	case quad.Object:
+		prefix = "os"
+	case quad.Label:
+		prefix = "cp"
+	default:
+		panic("unreachable " + d.String())
+	}
+	return NewIterator(prefix, d, val, qs)
+}
+
+func (qs *QuadStore) NodesAllIterator() graph.Iterator {
+	return NewAllIterator("z", quad.Any, qs)
+}
+
+func (qs *QuadStore) QuadsAllIterator() graph.Iterator {
+	return NewAllIterator("po", quad.Predicate, qs)
+}
+
+func (qs *QuadStore) QuadDirection(val graph.Value, d quad.Direction) graph.Value {
+	v := val.(Token)
+	offset := PositionOf(v[0:2], d, qs)
+	if offset != -1 {
+		return Token(append([]byte("z"), v[offset:offset+hashSize]...))
+	}
+	return Token(qs.Quad(val).Get(d))
+}
+
+func compareBytes(a, b graph.Value) bool {
+	return bytes.Equal(a.(Token), b.(Token))
+}
+
+func (qs *QuadStore) FixedIterator() graph.FixedIterator {
+	return iterator.NewFixed(compareBytes)
+}
+
+func (qs *QuadStore) Type() string {
+	return QuadStoreType
+}
diff --git a/vendor/github.com/google/cayley/graph/leveldb/quadstore_iterator_optimize.go b/vendor/github.com/google/cayley/graph/leveldb/quadstore_iterator_optimize.go
new file mode 100644
index 00000000..f792876b
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/leveldb/quadstore_iterator_optimize.go
@@ -0,0 +1,55 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package leveldb
+
+import (
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+)
+
+func (qs *QuadStore) OptimizeIterator(it graph.Iterator) (graph.Iterator, bool) {
+	switch it.Type() {
+	case graph.LinksTo:
+		return qs.optimizeLinksTo(it.(*iterator.LinksTo))
+
+	}
+	return it, false
+}
+
+func (qs *QuadStore) optimizeLinksTo(it *iterator.LinksTo) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	if len(subs) != 1 {
+		return it, false
+	}
+	primary := subs[0]
+	if primary.Type() == graph.Fixed {
+		size, _ := primary.Size()
+		if size == 1 {
+			if !graph.Next(primary) {
+				panic("unexpected size during optimize")
+			}
+			val := primary.Result()
+			newIt := qs.QuadIterator(it.Direction(), val)
+			nt := newIt.Tagger()
+			nt.CopyFrom(it)
+			for _, tag := range primary.Tagger().Tags() {
+				nt.AddFixed(tag, val)
+			}
+			it.Close()
+			return newIt, true
+		}
+	}
+	return it, false
+}
diff --git a/vendor/github.com/google/cayley/graph/memstore/all_iterator.go b/vendor/github.com/google/cayley/graph/memstore/all_iterator.go
new file mode 100644
index 00000000..abfc105c
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/all_iterator.go
@@ -0,0 +1,78 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package memstore
+
+import (
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+)
+
+type AllIterator struct {
+	iterator.Int64
+	qs *QuadStore
+}
+
+type (
+	nodesAllIterator AllIterator
+	quadsAllIterator AllIterator
+)
+
+func newNodesAllIterator(qs *QuadStore) *nodesAllIterator {
+	var out nodesAllIterator
+	out.Int64 = *iterator.NewInt64(1, qs.nextID-1)
+	out.qs = qs
+	return &out
+}
+
+// No subiterators.
+func (it *nodesAllIterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *nodesAllIterator) Next() bool {
+	if !it.Int64.Next() {
+		return false
+	}
+	_, ok := it.qs.revIDMap[it.Int64.Result().(int64)]
+	if !ok {
+		return it.Next()
+	}
+	return true
+}
+
+func (it *nodesAllIterator) Err() error {
+	return nil
+}
+
+func newQuadsAllIterator(qs *QuadStore) *quadsAllIterator {
+	var out quadsAllIterator
+	out.Int64 = *iterator.NewInt64(1, qs.nextQuadID-1)
+	out.qs = qs
+	return &out
+}
+
+func (it *quadsAllIterator) Next() bool {
+	out := it.Int64.Next()
+	if out {
+		i64 := it.Int64.Result().(int64)
+		if it.qs.log[i64].DeletedBy != 0 || it.qs.log[i64].Action == graph.Delete {
+			return it.Next()
+		}
+	}
+	return out
+}
+
+var _ graph.Nexter = &nodesAllIterator{}
+var _ graph.Nexter = &quadsAllIterator{}
diff --git a/vendor/github.com/google/cayley/graph/memstore/b/Makefile b/vendor/github.com/google/cayley/graph/memstore/b/Makefile
new file mode 100644
index 00000000..926b82b9
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/b/Makefile
@@ -0,0 +1,28 @@
+# Copyright 2014 The Cayley Authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+.PHONY: specify 
+
+# Do not commit changes to this line unless you are satisfied
+# that the github.com/cznic/b tests AND the cayley integration
+# tests pass with the new sha.
+pinned=82d9e96a4503a42315b0fdf5201314302beafe06
+
+specify:
+	rm -rf b
+	git clone https://github.com/cznic/b
+	cd b && git checkout $(pinned)
+	go test ./b
+	@sed -e 's|interface{}[^{]*/\*K\*/|int64|g' -e 's|interface{}[^{]*/\*V\*/|struct{}|g' b/btree.go >keys.go
+	rm -rf b
diff --git a/vendor/github.com/google/cayley/graph/memstore/b/gen.go b/vendor/github.com/google/cayley/graph/memstore/b/gen.go
new file mode 100644
index 00000000..cd2ad561
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/b/gen.go
@@ -0,0 +1,17 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:generate make specify
+
+package b
diff --git a/vendor/github.com/google/cayley/graph/memstore/b/keys.go b/vendor/github.com/google/cayley/graph/memstore/b/keys.go
new file mode 100644
index 00000000..4f4e1610
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/b/keys.go
@@ -0,0 +1,972 @@
+// Copyright 2014 The b Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package b implements a B+tree.
+//
+// Changelog
+//
+// 2014-06-26: Lower GC presure by recycling things.
+//
+// 2014-04-18: Added new method Put.
+//
+// Generic types
+//
+// Keys and their associated values are interface{} typed, similar to all of
+// the containers in the standard library.
+//
+// Semiautomatic production of a type specific variant of this package is
+// supported via
+//
+//	$ make generic
+//
+// This command will write to stdout a version of the btree.go file where
+// every key type occurrence is replaced by the word 'key' (written in all
+// CAPS) and every value type occurrence is replaced by the word 'value'
+// (written in all CAPS). Then you have to replace these tokens with your
+// desired type(s), using any technique you're comfortable with.
+//
+// This is how, for example, 'example/int.go' was created:
+//
+//	$ mkdir example
+//	$
+//	$ # Note: the command bellow must be actually written using the words
+//	$ # 'key' and 'value' in all CAPS. The proper form is avoided in this
+//	$ # documentation to not confuse any text replacement mechanism.
+//	$
+//	$ make generic | sed -e 's/key/int/g' -e 's/value/int/g' > example/int.go
+//
+// No other changes to int.go are necessary, it compiles just fine.
+//
+// Running the benchmarks for 1000 keys on a machine with Intel i5-4670 CPU @
+// 3.4GHz, Go release 1.3.
+//
+//	$ go test -bench 1e3 example/all_test.go example/int.go
+//	PASS
+//	BenchmarkSetSeq1e3	   10000	    146740 ns/op
+//	BenchmarkGetSeq1e3	   10000	    108261 ns/op
+//	BenchmarkSetRnd1e3	   10000	    254359 ns/op
+//	BenchmarkGetRnd1e3	   10000	    134621 ns/op
+//	BenchmarkDelRnd1e3	   10000	    211864 ns/op
+//	BenchmarkSeekSeq1e3	   10000	    148628 ns/op
+//	BenchmarkSeekRnd1e3	   10000	    215166 ns/op
+//	BenchmarkNext1e3	  200000	      9211 ns/op
+//	BenchmarkPrev1e3	  200000	      8843 ns/op
+//	ok  	command-line-arguments	25.071s
+//	$
+package b
+
+import (
+	"fmt"
+	"io"
+	"sync"
+)
+
+const (
+	kx = 32 //TODO benchmark tune this number if using custom key/value type(s).
+	kd = 32 //TODO benchmark tune this number if using custom key/value type(s).
+)
+
+func init() {
+	if kd < 1 {
+		panic(fmt.Errorf("kd %d: out of range", kd))
+	}
+
+	if kx < 2 {
+		panic(fmt.Errorf("kx %d: out of range", kx))
+	}
+}
+
+var (
+	btDPool = sync.Pool{New: func() interface{} { return &d{} }}
+	btEPool = btEpool{sync.Pool{New: func() interface{} { return &Enumerator{} }}}
+	btTPool = btTpool{sync.Pool{New: func() interface{} { return &Tree{} }}}
+	btXPool = sync.Pool{New: func() interface{} { return &x{} }}
+)
+
+type btTpool struct{ sync.Pool }
+
+func (p *btTpool) get(cmp Cmp) *Tree {
+	x := p.Get().(*Tree)
+	x.cmp = cmp
+	return x
+}
+
+type btEpool struct{ sync.Pool }
+
+func (p *btEpool) get(err error, hit bool, i int, k int64, q *d, t *Tree, ver int64) *Enumerator {
+	x := p.Get().(*Enumerator)
+	x.err, x.hit, x.i, x.k, x.q, x.t, x.ver = err, hit, i, k, q, t, ver
+	return x
+}
+
+type (
+	// Cmp compares a and b. Return value is:
+	//
+	//	< 0 if a <  b
+	//	  0 if a == b
+	//	> 0 if a >  b
+	//
+	Cmp func(a, b int64) int
+
+	d struct { // data page
+		c int
+		d [2*kd + 1]de
+		n *d
+		p *d
+	}
+
+	de struct { // d element
+		k int64
+		v struct{}
+	}
+
+	// Enumerator captures the state of enumerating a tree. It is returned
+	// from the Seek* methods. The enumerator is aware of any mutations
+	// made to the tree in the process of enumerating it and automatically
+	// resumes the enumeration at the proper key, if possible.
+	//
+	// However, once an Enumerator returns io.EOF to signal "no more
+	// items", it does no more attempt to "resync" on tree mutation(s).  In
+	// other words, io.EOF from an Enumaretor is "sticky" (idempotent).
+	Enumerator struct {
+		err error
+		hit bool
+		i   int
+		k   int64
+		q   *d
+		t   *Tree
+		ver int64
+	}
+
+	// Tree is a B+tree.
+	Tree struct {
+		c     int
+		cmp   Cmp
+		first *d
+		last  *d
+		r     interface{}
+		ver   int64
+	}
+
+	xe struct { // x element
+		ch interface{}
+		k  int64
+	}
+
+	x struct { // index page
+		c int
+		x [2*kx + 2]xe
+	}
+)
+
+var ( // R/O zero values
+	zd  d
+	zde de
+	ze  Enumerator
+	zk  int64
+	zt  Tree
+	zx  x
+	zxe xe
+)
+
+func clr(q interface{}) {
+	switch x := q.(type) {
+	case *x:
+		for i := 0; i <= x.c; i++ { // Ch0 Sep0 ... Chn-1 Sepn-1 Chn
+			clr(x.x[i].ch)
+		}
+		*x = zx
+		btXPool.Put(x)
+	case *d:
+		*x = zd
+		btDPool.Put(x)
+	}
+}
+
+// -------------------------------------------------------------------------- x
+
+func newX(ch0 interface{}) *x {
+	r := btXPool.Get().(*x)
+	r.x[0].ch = ch0
+	return r
+}
+
+func (q *x) extract(i int) {
+	q.c--
+	if i < q.c {
+		copy(q.x[i:], q.x[i+1:q.c+1])
+		q.x[q.c].ch = q.x[q.c+1].ch
+		q.x[q.c].k = zk  // GC
+		q.x[q.c+1] = zxe // GC
+	}
+}
+
+func (q *x) insert(i int, k int64, ch interface{}) *x {
+	c := q.c
+	if i < c {
+		q.x[c+1].ch = q.x[c].ch
+		copy(q.x[i+2:], q.x[i+1:c])
+		q.x[i+1].k = q.x[i].k
+	}
+	c++
+	q.c = c
+	q.x[i].k = k
+	q.x[i+1].ch = ch
+	return q
+}
+
+func (q *x) siblings(i int) (l, r *d) {
+	if i >= 0 {
+		if i > 0 {
+			l = q.x[i-1].ch.(*d)
+		}
+		if i < q.c {
+			r = q.x[i+1].ch.(*d)
+		}
+	}
+	return
+}
+
+// -------------------------------------------------------------------------- d
+
+func (l *d) mvL(r *d, c int) {
+	copy(l.d[l.c:], r.d[:c])
+	copy(r.d[:], r.d[c:r.c])
+	l.c += c
+	r.c -= c
+}
+
+func (l *d) mvR(r *d, c int) {
+	copy(r.d[c:], r.d[:r.c])
+	copy(r.d[:c], l.d[l.c-c:])
+	r.c += c
+	l.c -= c
+}
+
+// ----------------------------------------------------------------------- Tree
+
+// TreeNew returns a newly created, empty Tree. The compare function is used
+// for key collation.
+func TreeNew(cmp Cmp) *Tree {
+	return btTPool.get(cmp)
+}
+
+// Clear removes all K/V pairs from the tree.
+func (t *Tree) Clear() {
+	if t.r == nil {
+		return
+	}
+
+	clr(t.r)
+	t.c, t.first, t.last, t.r = 0, nil, nil, nil
+	t.ver++
+}
+
+// Close performs Clear and recycles t to a pool for possible later reuse. No
+// references to t should exist or such references must not be used afterwards.
+func (t *Tree) Close() {
+	t.Clear()
+	*t = zt
+	btTPool.Put(t)
+}
+
+func (t *Tree) cat(p *x, q, r *d, pi int) {
+	t.ver++
+	q.mvL(r, r.c)
+	if r.n != nil {
+		r.n.p = q
+	} else {
+		t.last = q
+	}
+	q.n = r.n
+	*r = zd
+	btDPool.Put(r)
+	if p.c > 1 {
+		p.extract(pi)
+		p.x[pi].ch = q
+	} else {
+		switch x := t.r.(type) {
+		case *x:
+			*x = zx
+			btXPool.Put(x)
+		case *d:
+			*x = zd
+			btDPool.Put(x)
+		}
+		t.r = q
+	}
+}
+
+func (t *Tree) catX(p, q, r *x, pi int) {
+	t.ver++
+	q.x[q.c].k = p.x[pi].k
+	copy(q.x[q.c+1:], r.x[:r.c])
+	q.c += r.c + 1
+	q.x[q.c].ch = r.x[r.c].ch
+	*r = zx
+	btXPool.Put(r)
+	if p.c > 1 {
+		p.c--
+		pc := p.c
+		if pi < pc {
+			p.x[pi].k = p.x[pi+1].k
+			copy(p.x[pi+1:], p.x[pi+2:pc+1])
+			p.x[pc].ch = p.x[pc+1].ch
+			p.x[pc].k = zk     // GC
+			p.x[pc+1].ch = nil // GC
+		}
+		return
+	}
+
+	switch x := t.r.(type) {
+	case *x:
+		*x = zx
+		btXPool.Put(x)
+	case *d:
+		*x = zd
+		btDPool.Put(x)
+	}
+	t.r = q
+}
+
+// Delete removes the k's KV pair, if it exists, in which case Delete returns
+// true.
+func (t *Tree) Delete(k int64) (ok bool) {
+	pi := -1
+	var p *x
+	q := t.r
+	if q == nil {
+		return false
+	}
+
+	for {
+		var i int
+		i, ok = t.find(q, k)
+		if ok {
+			switch x := q.(type) {
+			case *x:
+				if x.c < kx && q != t.r {
+					x, i = t.underflowX(p, x, pi, i)
+				}
+				pi = i + 1
+				p = x
+				q = x.x[pi].ch
+				ok = false
+				continue
+			case *d:
+				t.extract(x, i)
+				if x.c >= kd {
+					return true
+				}
+
+				if q != t.r {
+					t.underflow(p, x, pi)
+				} else if t.c == 0 {
+					t.Clear()
+				}
+				return true
+			}
+		}
+
+		switch x := q.(type) {
+		case *x:
+			if x.c < kx && q != t.r {
+				x, i = t.underflowX(p, x, pi, i)
+			}
+			pi = i
+			p = x
+			q = x.x[i].ch
+		case *d:
+			return false
+		}
+	}
+}
+
+func (t *Tree) extract(q *d, i int) { // (r struct{}) {
+	t.ver++
+	//r = q.d[i].v // prepared for Extract
+	q.c--
+	if i < q.c {
+		copy(q.d[i:], q.d[i+1:q.c+1])
+	}
+	q.d[q.c] = zde // GC
+	t.c--
+	return
+}
+
+func (t *Tree) find(q interface{}, k int64) (i int, ok bool) {
+	var mk int64
+	l := 0
+	switch x := q.(type) {
+	case *x:
+		h := x.c - 1
+		for l <= h {
+			m := (l + h) >> 1
+			mk = x.x[m].k
+			switch cmp := t.cmp(k, mk); {
+			case cmp > 0:
+				l = m + 1
+			case cmp == 0:
+				return m, true
+			default:
+				h = m - 1
+			}
+		}
+	case *d:
+		h := x.c - 1
+		for l <= h {
+			m := (l + h) >> 1
+			mk = x.d[m].k
+			switch cmp := t.cmp(k, mk); {
+			case cmp > 0:
+				l = m + 1
+			case cmp == 0:
+				return m, true
+			default:
+				h = m - 1
+			}
+		}
+	}
+	return l, false
+}
+
+// First returns the first item of the tree in the key collating order, or
+// (zero-value, zero-value) if the tree is empty.
+func (t *Tree) First() (k int64, v struct{}) {
+	if q := t.first; q != nil {
+		q := &q.d[0]
+		k, v = q.k, q.v
+	}
+	return
+}
+
+// Get returns the value associated with k and true if it exists. Otherwise Get
+// returns (zero-value, false).
+func (t *Tree) Get(k int64) (v struct{}, ok bool) {
+	q := t.r
+	if q == nil {
+		return
+	}
+
+	for {
+		var i int
+		if i, ok = t.find(q, k); ok {
+			switch x := q.(type) {
+			case *x:
+				q = x.x[i+1].ch
+				continue
+			case *d:
+				return x.d[i].v, true
+			}
+		}
+		switch x := q.(type) {
+		case *x:
+			q = x.x[i].ch
+		default:
+			return
+		}
+	}
+}
+
+func (t *Tree) insert(q *d, i int, k int64, v struct{}) *d {
+	t.ver++
+	c := q.c
+	if i < c {
+		copy(q.d[i+1:], q.d[i:c])
+	}
+	c++
+	q.c = c
+	q.d[i].k, q.d[i].v = k, v
+	t.c++
+	return q
+}
+
+// Last returns the last item of the tree in the key collating order, or
+// (zero-value, zero-value) if the tree is empty.
+func (t *Tree) Last() (k int64, v struct{}) {
+	if q := t.last; q != nil {
+		q := &q.d[q.c-1]
+		k, v = q.k, q.v
+	}
+	return
+}
+
+// Len returns the number of items in the tree.
+func (t *Tree) Len() int {
+	return t.c
+}
+
+func (t *Tree) overflow(p *x, q *d, pi, i int, k int64, v struct{}) {
+	t.ver++
+	l, r := p.siblings(pi)
+
+	if l != nil && l.c < 2*kd {
+		l.mvL(q, 1)
+		t.insert(q, i-1, k, v)
+		p.x[pi-1].k = q.d[0].k
+		return
+	}
+
+	if r != nil && r.c < 2*kd {
+		if i < 2*kd {
+			q.mvR(r, 1)
+			t.insert(q, i, k, v)
+			p.x[pi].k = r.d[0].k
+		} else {
+			t.insert(r, 0, k, v)
+			p.x[pi].k = k
+		}
+		return
+	}
+
+	t.split(p, q, pi, i, k, v)
+}
+
+// Seek returns an Enumerator positioned on a an item such that k >= item's
+// key. ok reports if k == item.key The Enumerator's position is possibly
+// after the last item in the tree.
+func (t *Tree) Seek(k int64) (e *Enumerator, ok bool) {
+	q := t.r
+	if q == nil {
+		e = btEPool.get(nil, false, 0, k, nil, t, t.ver)
+		return
+	}
+
+	for {
+		var i int
+		if i, ok = t.find(q, k); ok {
+			switch x := q.(type) {
+			case *x:
+				q = x.x[i+1].ch
+				continue
+			case *d:
+				return btEPool.get(nil, ok, i, k, x, t, t.ver), true
+			}
+		}
+
+		switch x := q.(type) {
+		case *x:
+			q = x.x[i].ch
+		case *d:
+			return btEPool.get(nil, ok, i, k, x, t, t.ver), false
+		}
+	}
+}
+
+// SeekFirst returns an enumerator positioned on the first KV pair in the tree,
+// if any. For an empty tree, err == io.EOF is returned and e will be nil.
+func (t *Tree) SeekFirst() (e *Enumerator, err error) {
+	q := t.first
+	if q == nil {
+		return nil, io.EOF
+	}
+
+	return btEPool.get(nil, true, 0, q.d[0].k, q, t, t.ver), nil
+}
+
+// SeekLast returns an enumerator positioned on the last KV pair in the tree,
+// if any. For an empty tree, err == io.EOF is returned and e will be nil.
+func (t *Tree) SeekLast() (e *Enumerator, err error) {
+	q := t.last
+	if q == nil {
+		return nil, io.EOF
+	}
+
+	return btEPool.get(nil, true, q.c-1, q.d[q.c-1].k, q, t, t.ver), nil
+}
+
+// Set sets the value associated with k.
+func (t *Tree) Set(k int64, v struct{}) {
+	//dbg("--- PRE Set(%v, %v)\n%s", k, v, t.dump())
+	//defer func() {
+	//	dbg("--- POST\n%s\n====\n", t.dump())
+	//}()
+
+	pi := -1
+	var p *x
+	q := t.r
+	if q == nil {
+		z := t.insert(btDPool.Get().(*d), 0, k, v)
+		t.r, t.first, t.last = z, z, z
+		return
+	}
+
+	for {
+		i, ok := t.find(q, k)
+		if ok {
+			switch x := q.(type) {
+			case *x:
+				if x.c > 2*kx {
+					x, i = t.splitX(p, x, pi, i)
+				}
+				pi = i + 1
+				p = x
+				q = x.x[i+1].ch
+				continue
+			case *d:
+				x.d[i].v = v
+			}
+			return
+		}
+
+		switch x := q.(type) {
+		case *x:
+			if x.c > 2*kx {
+				x, i = t.splitX(p, x, pi, i)
+			}
+			pi = i
+			p = x
+			q = x.x[i].ch
+		case *d:
+			switch {
+			case x.c < 2*kd:
+				t.insert(x, i, k, v)
+			default:
+				t.overflow(p, x, pi, i, k, v)
+			}
+			return
+		}
+	}
+}
+
+// Put combines Get and Set in a more efficient way where the tree is walked
+// only once. The upd(ater) receives (old-value, true) if a KV pair for k
+// exists or (zero-value, false) otherwise. It can then return a (new-value,
+// true) to create or overwrite the existing value in the KV pair, or
+// (whatever, false) if it decides not to create or not to update the value of
+// the KV pair.
+//
+// 	tree.Set(k, v) call conceptually equals calling
+//
+// 	tree.Put(k, func(int64, bool){ return v, true })
+//
+// modulo the differing return values.
+func (t *Tree) Put(k int64, upd func(oldV struct{}, exists bool) (newV struct{}, write bool)) (oldV struct{}, written bool) {
+	pi := -1
+	var p *x
+	q := t.r
+	var newV struct{}
+	if q == nil {
+		// new KV pair in empty tree
+		newV, written = upd(newV, false)
+		if !written {
+			return
+		}
+
+		z := t.insert(btDPool.Get().(*d), 0, k, newV)
+		t.r, t.first, t.last = z, z, z
+		return
+	}
+
+	for {
+		i, ok := t.find(q, k)
+		if ok {
+			switch x := q.(type) {
+			case *x:
+				if x.c > 2*kx {
+					x, i = t.splitX(p, x, pi, i)
+				}
+				pi = i + 1
+				p = x
+				q = x.x[i+1].ch
+				continue
+			case *d:
+				oldV = x.d[i].v
+				newV, written = upd(oldV, true)
+				if !written {
+					return
+				}
+
+				x.d[i].v = newV
+			}
+			return
+		}
+
+		switch x := q.(type) {
+		case *x:
+			if x.c > 2*kx {
+				x, i = t.splitX(p, x, pi, i)
+			}
+			pi = i
+			p = x
+			q = x.x[i].ch
+		case *d: // new KV pair
+			newV, written = upd(newV, false)
+			if !written {
+				return
+			}
+
+			switch {
+			case x.c < 2*kd:
+				t.insert(x, i, k, newV)
+			default:
+				t.overflow(p, x, pi, i, k, newV)
+			}
+			return
+		}
+	}
+}
+
+func (t *Tree) split(p *x, q *d, pi, i int, k int64, v struct{}) {
+	t.ver++
+	r := btDPool.Get().(*d)
+	if q.n != nil {
+		r.n = q.n
+		r.n.p = r
+	} else {
+		t.last = r
+	}
+	q.n = r
+	r.p = q
+
+	copy(r.d[:], q.d[kd:2*kd])
+	for i := range q.d[kd:] {
+		q.d[kd+i] = zde
+	}
+	q.c = kd
+	r.c = kd
+	var done bool
+	if i > kd {
+		done = true
+		t.insert(r, i-kd, k, v)
+	}
+	if pi >= 0 {
+		p.insert(pi, r.d[0].k, r)
+	} else {
+		t.r = newX(q).insert(0, r.d[0].k, r)
+	}
+	if done {
+		return
+	}
+
+	t.insert(q, i, k, v)
+}
+
+func (t *Tree) splitX(p *x, q *x, pi int, i int) (*x, int) {
+	t.ver++
+	r := btXPool.Get().(*x)
+	copy(r.x[:], q.x[kx+1:])
+	q.c = kx
+	r.c = kx
+	if pi >= 0 {
+		p.insert(pi, q.x[kx].k, r)
+		q.x[kx].k = zk
+		for i := range q.x[kx+1:] {
+			q.x[kx+i+1] = zxe
+		}
+
+		switch {
+		case i < kx:
+			return q, i
+		case i == kx:
+			return p, pi
+		default: // i > kx
+			return r, i - kx - 1
+		}
+	}
+
+	nr := newX(q).insert(0, q.x[kx].k, r)
+	t.r = nr
+	q.x[kx].k = zk
+	for i := range q.x[kx+1:] {
+		q.x[kx+i+1] = zxe
+	}
+
+	switch {
+	case i < kx:
+		return q, i
+	case i == kx:
+		return nr, 0
+	default: // i > kx
+		return r, i - kx - 1
+	}
+}
+
+func (t *Tree) underflow(p *x, q *d, pi int) {
+	t.ver++
+	l, r := p.siblings(pi)
+
+	if l != nil && l.c+q.c >= 2*kd {
+		l.mvR(q, 1)
+		p.x[pi-1].k = q.d[0].k
+	} else if r != nil && q.c+r.c >= 2*kd {
+		q.mvL(r, 1)
+		p.x[pi].k = r.d[0].k
+		r.d[r.c] = zde // GC
+	} else if l != nil {
+		t.cat(p, l, q, pi-1)
+	} else {
+		t.cat(p, q, r, pi)
+	}
+}
+
+func (t *Tree) underflowX(p *x, q *x, pi int, i int) (*x, int) {
+	t.ver++
+	var l, r *x
+
+	if pi >= 0 {
+		if pi > 0 {
+			l = p.x[pi-1].ch.(*x)
+		}
+		if pi < p.c {
+			r = p.x[pi+1].ch.(*x)
+		}
+	}
+
+	if l != nil && l.c > kx {
+		q.x[q.c+1].ch = q.x[q.c].ch
+		copy(q.x[1:], q.x[:q.c])
+		q.x[0].ch = l.x[l.c].ch
+		q.x[0].k = p.x[pi-1].k
+		q.c++
+		i++
+		l.c--
+		p.x[pi-1].k = l.x[l.c].k
+		return q, i
+	}
+
+	if r != nil && r.c > kx {
+		q.x[q.c].k = p.x[pi].k
+		q.c++
+		q.x[q.c].ch = r.x[0].ch
+		p.x[pi].k = r.x[0].k
+		copy(r.x[:], r.x[1:r.c])
+		r.c--
+		rc := r.c
+		r.x[rc].ch = r.x[rc+1].ch
+		r.x[rc].k = zk
+		r.x[rc+1].ch = nil
+		return q, i
+	}
+
+	if l != nil {
+		i += l.c + 1
+		t.catX(p, l, q, pi-1)
+		q = l
+		return q, i
+	}
+
+	t.catX(p, q, r, pi)
+	return q, i
+}
+
+// ----------------------------------------------------------------- Enumerator
+
+// Close recycles e to a pool for possible later reuse. No references to e
+// should exist or such references must not be used afterwards.
+func (e *Enumerator) Close() {
+	*e = ze
+	btEPool.Put(e)
+}
+
+// Next returns the currently enumerated item, if it exists and moves to the
+// next item in the key collation order. If there is no item to return, err ==
+// io.EOF is returned.
+func (e *Enumerator) Next() (k int64, v struct{}, err error) {
+	if err = e.err; err != nil {
+		return
+	}
+
+	if e.ver != e.t.ver {
+		f, hit := e.t.Seek(e.k)
+		if !e.hit && hit {
+			if err = f.next(); err != nil {
+				return
+			}
+		}
+
+		*e = *f
+		f.Close()
+	}
+	if e.q == nil {
+		e.err, err = io.EOF, io.EOF
+		return
+	}
+
+	if e.i >= e.q.c {
+		if err = e.next(); err != nil {
+			return
+		}
+	}
+
+	i := e.q.d[e.i]
+	k, v = i.k, i.v
+	e.k, e.hit = k, false
+	e.next()
+	return
+}
+
+func (e *Enumerator) next() error {
+	if e.q == nil {
+		e.err = io.EOF
+		return io.EOF
+	}
+
+	switch {
+	case e.i < e.q.c-1:
+		e.i++
+	default:
+		if e.q, e.i = e.q.n, 0; e.q == nil {
+			e.err = io.EOF
+		}
+	}
+	return e.err
+}
+
+// Prev returns the currently enumerated item, if it exists and moves to the
+// previous item in the key collation order. If there is no item to return, err
+// == io.EOF is returned.
+func (e *Enumerator) Prev() (k int64, v struct{}, err error) {
+	if err = e.err; err != nil {
+		return
+	}
+
+	if e.ver != e.t.ver {
+		f, hit := e.t.Seek(e.k)
+		if !e.hit && hit {
+			if err = f.prev(); err != nil {
+				return
+			}
+		}
+
+		*e = *f
+		f.Close()
+	}
+	if e.q == nil {
+		e.err, err = io.EOF, io.EOF
+		return
+	}
+
+	if e.i >= e.q.c {
+		if err = e.next(); err != nil {
+			return
+		}
+	}
+
+	i := e.q.d[e.i]
+	k, v = i.k, i.v
+	e.k, e.hit = k, false
+	e.prev()
+	return
+}
+
+func (e *Enumerator) prev() error {
+	if e.q == nil {
+		e.err = io.EOF
+		return io.EOF
+	}
+
+	switch {
+	case e.i > 0:
+		e.i--
+	default:
+		if e.q = e.q.p; e.q == nil {
+			e.err = io.EOF
+			break
+		}
+
+		e.i = e.q.c - 1
+	}
+	return e.err
+}
diff --git a/vendor/github.com/google/cayley/graph/memstore/iterator.go b/vendor/github.com/google/cayley/graph/memstore/iterator.go
new file mode 100644
index 00000000..68f47bb5
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/iterator.go
@@ -0,0 +1,198 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package memstore
+
+import (
+	"io"
+	"math"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/graph/memstore/b"
+)
+
+type Iterator struct {
+	uid    uint64
+	qs     *QuadStore
+	tags   graph.Tagger
+	tree   *b.Tree
+	iter   *b.Enumerator
+	data   string
+	result graph.Value
+	err    error
+}
+
+func NewIterator(tree *b.Tree, data string, qs *QuadStore) *Iterator {
+	iter, err := tree.SeekFirst()
+	if err != nil {
+		iter = nil
+	}
+	return &Iterator{
+		uid:  iterator.NextUID(),
+		qs:   qs,
+		tree: tree,
+		iter: iter,
+		data: data,
+	}
+}
+
+func (it *Iterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *Iterator) Reset() {
+	var err error
+	it.iter, err = it.tree.SeekFirst()
+	if err != nil {
+		it.iter = nil
+	}
+}
+
+func (it *Iterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Iterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Iterator) Clone() graph.Iterator {
+	var iter *b.Enumerator
+	if it.result != nil {
+		var ok bool
+		iter, ok = it.tree.Seek(it.result.(int64))
+		if !ok {
+			panic("value unexpectedly missing")
+		}
+	} else {
+		var err error
+		iter, err = it.tree.SeekFirst()
+		if err != nil {
+			iter = nil
+		}
+	}
+
+	m := &Iterator{
+		uid:  iterator.NextUID(),
+		qs:   it.qs,
+		tree: it.tree,
+		iter: iter,
+		data: it.data,
+	}
+	m.tags.CopyFrom(it)
+
+	return m
+}
+
+func (it *Iterator) Close() error {
+	return nil
+}
+
+func (it *Iterator) checkValid(index int64) bool {
+	return it.qs.log[index].DeletedBy == 0
+}
+
+func (it *Iterator) Next() bool {
+	graph.NextLogIn(it)
+
+	if it.iter == nil {
+		return graph.NextLogOut(it, nil, false)
+	}
+	result, _, err := it.iter.Next()
+	if err != nil {
+		if err != io.EOF {
+			it.err = err
+		}
+		return graph.NextLogOut(it, nil, false)
+	}
+	if !it.checkValid(result) {
+		return it.Next()
+	}
+	it.result = result
+	return graph.NextLogOut(it, it.result, true)
+}
+
+func (it *Iterator) Err() error {
+	return it.err
+}
+
+func (it *Iterator) Result() graph.Value {
+	return it.result
+}
+
+func (it *Iterator) NextPath() bool {
+	return false
+}
+
+// No subiterators.
+func (it *Iterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *Iterator) Size() (int64, bool) {
+	return int64(it.tree.Len()), true
+}
+
+func (it *Iterator) Contains(v graph.Value) bool {
+	graph.ContainsLogIn(it, v)
+	if _, ok := it.tree.Get(v.(int64)); ok {
+		it.result = v
+		return graph.ContainsLogOut(it, v, true)
+	}
+	return graph.ContainsLogOut(it, v, false)
+}
+
+func (it *Iterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:  it.UID(),
+		Name: it.data,
+		Type: it.Type(),
+		Tags: it.tags.Tags(),
+		Size: size,
+	}
+}
+
+var memType graph.Type
+
+func init() {
+	memType = graph.RegisterIterator("b+tree")
+}
+
+func Type() graph.Type { return memType }
+
+func (it *Iterator) Type() graph.Type { return memType }
+
+func (it *Iterator) Sorted() bool { return true }
+
+func (it *Iterator) Optimize() (graph.Iterator, bool) {
+	return it, false
+}
+
+func (it *Iterator) Stats() graph.IteratorStats {
+	return graph.IteratorStats{
+		ContainsCost: int64(math.Log(float64(it.tree.Len()))) + 1,
+		NextCost:     1,
+		Size:         int64(it.tree.Len()),
+	}
+}
+
+var _ graph.Nexter = &Iterator{}
diff --git a/vendor/github.com/google/cayley/graph/memstore/quadstore.go b/vendor/github.com/google/cayley/graph/memstore/quadstore.go
new file mode 100644
index 00000000..7e94e7fc
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/quadstore.go
@@ -0,0 +1,305 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package memstore
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/graph/memstore/b"
+	"github.com/google/cayley/quad"
+)
+
+const QuadStoreType = "memstore"
+
+func init() {
+	graph.RegisterQuadStore(QuadStoreType, graph.QuadStoreRegistration{
+		NewFunc: func(string, graph.Options) (graph.QuadStore, error) {
+			return newQuadStore(), nil
+		},
+		NewForRequestFunc: nil,
+		UpgradeFunc:       nil,
+		InitFunc:          nil,
+		IsPersistent:      false,
+	})
+}
+
+func cmp(a, b int64) int {
+	return int(a - b)
+}
+
+type QuadDirectionIndex struct {
+	index [4]map[int64]*b.Tree
+}
+
+func NewQuadDirectionIndex() QuadDirectionIndex {
+	return QuadDirectionIndex{[...]map[int64]*b.Tree{
+		quad.Subject - 1:   make(map[int64]*b.Tree),
+		quad.Predicate - 1: make(map[int64]*b.Tree),
+		quad.Object - 1:    make(map[int64]*b.Tree),
+		quad.Label - 1:     make(map[int64]*b.Tree),
+	}}
+}
+
+func (qdi QuadDirectionIndex) Tree(d quad.Direction, id int64) *b.Tree {
+	if d < quad.Subject || d > quad.Label {
+		panic("illegal direction")
+	}
+	tree, ok := qdi.index[d-1][id]
+	if !ok {
+		tree = b.TreeNew(cmp)
+		qdi.index[d-1][id] = tree
+	}
+	return tree
+}
+
+func (qdi QuadDirectionIndex) Get(d quad.Direction, id int64) (*b.Tree, bool) {
+	if d < quad.Subject || d > quad.Label {
+		panic("illegal direction")
+	}
+	tree, ok := qdi.index[d-1][id]
+	return tree, ok
+}
+
+type LogEntry struct {
+	ID        int64
+	Quad      quad.Quad
+	Action    graph.Procedure
+	Timestamp time.Time
+	DeletedBy int64
+}
+
+type QuadStore struct {
+	nextID     int64
+	nextQuadID int64
+	idMap      map[string]int64
+	revIDMap   map[int64]string
+	log        []LogEntry
+	size       int64
+	index      QuadDirectionIndex
+	// vip_index map[string]map[int64]map[string]map[int64]*b.Tree
+}
+
+func newQuadStore() *QuadStore {
+	return &QuadStore{
+		idMap:    make(map[string]int64),
+		revIDMap: make(map[int64]string),
+
+		// Sentinel null entry so indices start at 1
+		log: make([]LogEntry, 1, 200),
+
+		index:      NewQuadDirectionIndex(),
+		nextID:     1,
+		nextQuadID: 1,
+	}
+}
+
+func (qs *QuadStore) ApplyDeltas(deltas []graph.Delta, ignoreOpts graph.IgnoreOpts) error {
+	// Precheck the whole transaction
+	for _, d := range deltas {
+		switch d.Action {
+		case graph.Add:
+			if !ignoreOpts.IgnoreDup {
+				if _, exists := qs.indexOf(d.Quad); exists {
+					return graph.ErrQuadExists
+				}
+			}
+		case graph.Delete:
+			if !ignoreOpts.IgnoreMissing {
+				if _, exists := qs.indexOf(d.Quad); !exists {
+					return graph.ErrQuadNotExist
+				}
+			}
+		default:
+			return errors.New("memstore: invalid action")
+		}
+	}
+
+	for _, d := range deltas {
+		var err error
+		switch d.Action {
+		case graph.Add:
+			err = qs.AddDelta(d)
+			if err != nil && ignoreOpts.IgnoreDup {
+				err = nil
+			}
+		case graph.Delete:
+			err = qs.RemoveDelta(d)
+			if err != nil && ignoreOpts.IgnoreMissing {
+				err = nil
+			}
+		default:
+			panic("memstore: unexpected invalid action")
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+const maxInt = int(^uint(0) >> 1)
+
+func (qs *QuadStore) indexOf(t quad.Quad) (int64, bool) {
+	min := maxInt
+	var tree *b.Tree
+	for d := quad.Subject; d <= quad.Label; d++ {
+		sid := t.Get(d)
+		if d == quad.Label && sid == "" {
+			continue
+		}
+		id, ok := qs.idMap[sid]
+		// If we've never heard about a node, it must not exist
+		if !ok {
+			return 0, false
+		}
+		index, ok := qs.index.Get(d, id)
+		if !ok {
+			// If it's never been indexed in this direction, it can't exist.
+			return 0, false
+		}
+		if l := index.Len(); l < min {
+			min, tree = l, index
+		}
+	}
+	it := NewIterator(tree, "", qs)
+
+	for it.Next() {
+		val := it.Result()
+		if t == qs.log[val.(int64)].Quad {
+			return val.(int64), true
+		}
+	}
+	return 0, false
+}
+
+func (qs *QuadStore) AddDelta(d graph.Delta) error {
+	if _, exists := qs.indexOf(d.Quad); exists {
+		return graph.ErrQuadExists
+	}
+	qid := qs.nextQuadID
+	qs.log = append(qs.log, LogEntry{
+		ID:        d.ID.Int(),
+		Quad:      d.Quad,
+		Action:    d.Action,
+		Timestamp: d.Timestamp})
+	qs.size++
+	qs.nextQuadID++
+
+	for dir := quad.Subject; dir <= quad.Label; dir++ {
+		sid := d.Quad.Get(dir)
+		if dir == quad.Label && sid == "" {
+			continue
+		}
+		if _, ok := qs.idMap[sid]; !ok {
+			qs.idMap[sid] = qs.nextID
+			qs.revIDMap[qs.nextID] = sid
+			qs.nextID++
+		}
+		id := qs.idMap[sid]
+		tree := qs.index.Tree(dir, id)
+		tree.Set(qid, struct{}{})
+	}
+
+	// TODO(barakmich): Add VIP indexing
+	return nil
+}
+
+func (qs *QuadStore) RemoveDelta(d graph.Delta) error {
+	prevQuadID, exists := qs.indexOf(d.Quad)
+	if !exists {
+		return graph.ErrQuadNotExist
+	}
+
+	quadID := qs.nextQuadID
+	qs.log = append(qs.log, LogEntry{
+		ID:        d.ID.Int(),
+		Quad:      d.Quad,
+		Action:    d.Action,
+		Timestamp: d.Timestamp})
+	qs.log[prevQuadID].DeletedBy = quadID
+	qs.size--
+	qs.nextQuadID++
+	return nil
+}
+
+func (qs *QuadStore) Quad(index graph.Value) quad.Quad {
+	return qs.log[index.(int64)].Quad
+}
+
+func (qs *QuadStore) QuadIterator(d quad.Direction, value graph.Value) graph.Iterator {
+	index, ok := qs.index.Get(d, value.(int64))
+	data := fmt.Sprintf("dir:%s val:%d", d, value.(int64))
+	if ok {
+		return NewIterator(index, data, qs)
+	}
+	return &iterator.Null{}
+}
+
+func (qs *QuadStore) Horizon() graph.PrimaryKey {
+	return graph.NewSequentialKey(qs.log[len(qs.log)-1].ID)
+}
+
+func (qs *QuadStore) Size() int64 {
+	return qs.size
+}
+
+func (qs *QuadStore) DebugPrint() {
+	for i, l := range qs.log {
+		if i == 0 {
+			continue
+		}
+		glog.V(2).Infof("%d: %#v", i, l)
+	}
+}
+
+func (qs *QuadStore) ValueOf(name string) graph.Value {
+	return qs.idMap[name]
+}
+
+func (qs *QuadStore) NameOf(id graph.Value) string {
+	if id == nil {
+		return ""
+	}
+	return qs.revIDMap[id.(int64)]
+}
+
+func (qs *QuadStore) QuadsAllIterator() graph.Iterator {
+	return newQuadsAllIterator(qs)
+}
+
+func (qs *QuadStore) FixedIterator() graph.FixedIterator {
+	return iterator.NewFixed(iterator.Identity)
+}
+
+func (qs *QuadStore) QuadDirection(val graph.Value, d quad.Direction) graph.Value {
+	name := qs.Quad(val).Get(d)
+	return qs.ValueOf(name)
+}
+
+func (qs *QuadStore) NodesAllIterator() graph.Iterator {
+	return newNodesAllIterator(qs)
+}
+
+func (qs *QuadStore) Close() {}
+
+func (qs *QuadStore) Type() string {
+	return QuadStoreType
+}
diff --git a/vendor/github.com/google/cayley/graph/memstore/quadstore_iterator_optimize.go b/vendor/github.com/google/cayley/graph/memstore/quadstore_iterator_optimize.go
new file mode 100644
index 00000000..fdc41b48
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/memstore/quadstore_iterator_optimize.go
@@ -0,0 +1,55 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package memstore
+
+import (
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+)
+
+func (qs *QuadStore) OptimizeIterator(it graph.Iterator) (graph.Iterator, bool) {
+	switch it.Type() {
+	case graph.LinksTo:
+		return qs.optimizeLinksTo(it.(*iterator.LinksTo))
+
+	}
+	return it, false
+}
+
+func (qs *QuadStore) optimizeLinksTo(it *iterator.LinksTo) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	if len(subs) != 1 {
+		return it, false
+	}
+	primary := subs[0]
+	if primary.Type() == graph.Fixed {
+		size, _ := primary.Size()
+		if size == 1 {
+			if !graph.Next(primary) {
+				panic("unexpected size during optimize")
+			}
+			val := primary.Result()
+			newIt := qs.QuadIterator(it.Direction(), val)
+			nt := newIt.Tagger()
+			nt.CopyFrom(it)
+			for _, tag := range primary.Tagger().Tags() {
+				nt.AddFixed(tag, val)
+			}
+			return newIt, true
+		}
+	}
+	it.Close()
+	return it, false
+}
diff --git a/vendor/github.com/google/cayley/graph/mongo/indexed_linksto.go b/vendor/github.com/google/cayley/graph/mongo/indexed_linksto.go
new file mode 100644
index 00000000..522cb6b5
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/mongo/indexed_linksto.go
@@ -0,0 +1,263 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongo
+
+import (
+	"gopkg.in/mgo.v2"
+	"gopkg.in/mgo.v2/bson"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+var _ graph.Nexter = &LinksTo{}
+
+var linksToType graph.Type
+
+func init() {
+	linksToType = graph.RegisterIterator("mongo-linksto")
+}
+
+// LinksTo is a MongoDB-dependent version of a LinksTo iterator. Like the normal
+// LinksTo, it represents a set of links to a set of nodes, represented by its
+// subiterator. However, this iterator may often be faster than the generic
+// LinksTo, as it can use the secondary indices in Mongo as features within the
+// Mongo query, reducing the size of the result set and speeding up iteration.
+type LinksTo struct {
+	uid        uint64
+	collection string
+	tags       graph.Tagger
+	qs         *QuadStore
+	primaryIt  graph.Iterator
+	dir        quad.Direction
+	nextIt     *mgo.Iter
+	result     graph.Value
+	runstats   graph.IteratorStats
+	lset       []graph.Linkage
+	err        error
+}
+
+// NewLinksTo constructs a new indexed LinksTo iterator for Mongo around a direction
+// and a subiterator of nodes.
+func NewLinksTo(qs *QuadStore, it graph.Iterator, collection string, d quad.Direction, lset []graph.Linkage) *LinksTo {
+	return &LinksTo{
+		uid:        iterator.NextUID(),
+		qs:         qs,
+		primaryIt:  it,
+		dir:        d,
+		nextIt:     nil,
+		lset:       lset,
+		collection: collection,
+	}
+}
+
+func (it *LinksTo) buildConstraint() bson.M {
+	constraint := bson.M{}
+	// TODO(barakmich): Currently this only works for an individual linkage in any direction.
+	for _, link := range it.lset {
+		constraint[link.Dir.String()] = link.Value
+	}
+	return constraint
+}
+
+func (it *LinksTo) buildIteratorFor(d quad.Direction, val graph.Value) *mgo.Iter {
+	name := it.qs.NameOf(val)
+	constraint := it.buildConstraint()
+	constraint[d.String()] = name
+	return it.qs.db.C(it.collection).Find(constraint).Iter()
+}
+
+func (it *LinksTo) UID() uint64 {
+	return it.uid
+}
+
+func (it *LinksTo) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+// Return the direction under consideration.
+func (it *LinksTo) Direction() quad.Direction { return it.dir }
+
+// Tag these results, and our subiterator's results.
+func (it *LinksTo) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+
+	it.primaryIt.TagResults(dst)
+}
+
+// Optimize the LinksTo, by replacing it if it can be.
+func (it *LinksTo) Optimize() (graph.Iterator, bool) {
+	return it, false
+}
+
+func (it *LinksTo) Next() bool {
+	var result struct {
+		ID      string  `bson:"_id"`
+		Added   []int64 `bson:"Added"`
+		Deleted []int64 `bson:"Deleted"`
+	}
+	graph.NextLogIn(it)
+	it.runstats.Next += 1
+	if it.nextIt != nil && it.nextIt.Next(&result) {
+		it.runstats.ContainsNext += 1
+		if it.collection == "quads" && len(result.Added) <= len(result.Deleted) {
+			return it.Next()
+		}
+		it.result = result.ID
+		return graph.NextLogOut(it, it.result, true)
+	}
+
+	if it.nextIt != nil {
+		// If there's an error in the 'next' iterator, we save it and we're done.
+		it.err = it.nextIt.Err()
+		if it.err != nil {
+			return false
+		}
+
+	}
+	// Subiterator is empty, get another one
+	if !graph.Next(it.primaryIt) {
+		// Possibly save error
+		it.err = it.primaryIt.Err()
+
+		// We're out of nodes in our subiterator, so we're done as well.
+		return graph.NextLogOut(it, 0, false)
+	}
+	if it.nextIt != nil {
+		it.nextIt.Close()
+	}
+	it.nextIt = it.buildIteratorFor(it.dir, it.primaryIt.Result())
+
+	// Recurse -- return the first in the next set.
+	return it.Next()
+}
+
+func (it *LinksTo) Err() error {
+	return it.err
+}
+
+func (it *LinksTo) Result() graph.Value {
+	return it.result
+}
+
+func (it *LinksTo) Close() error {
+	var err error
+	if it.nextIt != nil {
+		err = it.nextIt.Close()
+	}
+
+	_err := it.primaryIt.Close()
+	if _err != nil && err == nil {
+		err = _err
+	}
+
+	return err
+}
+
+func (it *LinksTo) NextPath() bool {
+	ok := it.primaryIt.NextPath()
+	if !ok {
+		it.err = it.primaryIt.Err()
+	}
+	return ok
+}
+
+func (it *LinksTo) Type() graph.Type {
+	return linksToType
+}
+
+func (it *LinksTo) Clone() graph.Iterator {
+	m := NewLinksTo(it.qs, it.primaryIt.Clone(), it.collection, it.dir, it.lset)
+	m.tags.CopyFrom(it)
+	return m
+}
+
+func (it *LinksTo) Contains(val graph.Value) bool {
+	graph.ContainsLogIn(it, val)
+	it.runstats.Contains += 1
+
+	for _, link := range it.lset {
+		dval := it.qs.QuadDirection(val, link.Dir)
+		if dval != link.Value {
+			return graph.ContainsLogOut(it, val, false)
+		}
+	}
+
+	node := it.qs.QuadDirection(val, it.dir)
+	if it.primaryIt.Contains(node) {
+		it.result = val
+		return graph.ContainsLogOut(it, val, true)
+	}
+	it.err = it.primaryIt.Err()
+	return graph.ContainsLogOut(it, val, false)
+}
+
+func (it *LinksTo) Describe() graph.Description {
+	primary := it.primaryIt.Describe()
+	return graph.Description{
+		UID:       it.UID(),
+		Type:      it.Type(),
+		Direction: it.dir,
+		Iterator:  &primary,
+	}
+}
+
+func (it *LinksTo) Reset() {
+	it.primaryIt.Reset()
+	if it.nextIt != nil {
+		it.nextIt.Close()
+	}
+	it.nextIt = nil
+}
+
+// Return a guess as to how big or costly it is to next the iterator.
+func (it *LinksTo) Stats() graph.IteratorStats {
+	subitStats := it.primaryIt.Stats()
+	// TODO(barakmich): These should really come from the quadstore itself
+	fanoutFactor := int64(20)
+	checkConstant := int64(1)
+	nextConstant := int64(2)
+
+	size := fanoutFactor * subitStats.Size
+	csize, _ := it.qs.getSize(it.collection, it.buildConstraint())
+	if size > csize {
+		size = csize
+	}
+
+	return graph.IteratorStats{
+		NextCost:     nextConstant + subitStats.NextCost,
+		ContainsCost: checkConstant + subitStats.ContainsCost,
+		Size:         size,
+		Next:         it.runstats.Next,
+		Contains:     it.runstats.Contains,
+		ContainsNext: it.runstats.ContainsNext,
+	}
+}
+
+func (it *LinksTo) Size() (int64, bool) {
+	return it.Stats().Size, false
+}
+
+// Return a list containing only our subiterator.
+func (it *LinksTo) SubIterators() []graph.Iterator {
+	return []graph.Iterator{it.primaryIt}
+}
diff --git a/vendor/github.com/google/cayley/graph/mongo/iterator.go b/vendor/github.com/google/cayley/graph/mongo/iterator.go
new file mode 100644
index 00000000..a4769931
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/mongo/iterator.go
@@ -0,0 +1,242 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongo
+
+import (
+	"fmt"
+
+	"github.com/barakmich/glog"
+	"gopkg.in/mgo.v2"
+	"gopkg.in/mgo.v2/bson"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+type Iterator struct {
+	uid        uint64
+	tags       graph.Tagger
+	qs         *QuadStore
+	dir        quad.Direction
+	iter       *mgo.Iter
+	hash       string
+	name       string
+	size       int64
+	isAll      bool
+	constraint bson.M
+	collection string
+	result     graph.Value
+	err        error
+}
+
+func NewIterator(qs *QuadStore, collection string, d quad.Direction, val graph.Value) *Iterator {
+	name := qs.NameOf(val)
+
+	constraint := bson.M{d.String(): name}
+
+	return &Iterator{
+		uid:        iterator.NextUID(),
+		name:       name,
+		constraint: constraint,
+		collection: collection,
+		qs:         qs,
+		dir:        d,
+		iter:       nil,
+		size:       -1,
+		hash:       val.(string),
+		isAll:      false,
+	}
+}
+
+func (it *Iterator) makeMongoIterator() *mgo.Iter {
+	if it.isAll {
+		return it.qs.db.C(it.collection).Find(nil).Iter()
+	}
+	return it.qs.db.C(it.collection).Find(it.constraint).Iter()
+}
+
+func NewAllIterator(qs *QuadStore, collection string) *Iterator {
+	return &Iterator{
+		uid:        iterator.NextUID(),
+		qs:         qs,
+		dir:        quad.Any,
+		constraint: nil,
+		collection: collection,
+		iter:       nil,
+		size:       -1,
+		hash:       "",
+		isAll:      true,
+	}
+}
+
+func (it *Iterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *Iterator) Reset() {
+	it.Close()
+	it.iter = it.qs.db.C(it.collection).Find(it.constraint).Iter()
+
+}
+
+func (it *Iterator) Close() error {
+	if it.iter != nil {
+		return it.iter.Close()
+	}
+	return nil
+}
+
+func (it *Iterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *Iterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *Iterator) Clone() graph.Iterator {
+	var m *Iterator
+	if it.isAll {
+		m = NewAllIterator(it.qs, it.collection)
+	} else {
+		m = NewIterator(it.qs, it.collection, it.dir, it.hash)
+	}
+	m.tags.CopyFrom(it)
+	return m
+}
+
+func (it *Iterator) Next() bool {
+	var result struct {
+		ID      string  `bson:"_id"`
+		Added   []int64 `bson:"Added"`
+		Deleted []int64 `bson:"Deleted"`
+	}
+	if it.iter == nil {
+		it.iter = it.makeMongoIterator()
+	}
+	found := it.iter.Next(&result)
+	if !found {
+		err := it.iter.Err()
+		if err != nil {
+			it.err = err
+			glog.Errorln("Error Nexting Iterator: ", err)
+		}
+		return false
+	}
+	if it.collection == "quads" && len(result.Added) <= len(result.Deleted) {
+		return it.Next()
+	}
+	it.result = result.ID
+	return true
+}
+
+func (it *Iterator) Err() error {
+	return it.err
+}
+
+func (it *Iterator) Result() graph.Value {
+	return it.result
+}
+
+func (it *Iterator) NextPath() bool {
+	return false
+}
+
+// SubIterators returns no subiterators for a Mongo iterator.
+func (it *Iterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *Iterator) Contains(v graph.Value) bool {
+	graph.ContainsLogIn(it, v)
+	if it.isAll {
+		it.result = v
+		return graph.ContainsLogOut(it, v, true)
+	}
+	var offset int
+	switch it.dir {
+	case quad.Subject:
+		offset = 0
+	case quad.Predicate:
+		offset = (hashSize * 2)
+	case quad.Object:
+		offset = (hashSize * 2) * 2
+	case quad.Label:
+		offset = (hashSize * 2) * 3
+	}
+	val := v.(string)[offset : hashSize*2+offset]
+	if val == it.hash {
+		it.result = v
+		return graph.ContainsLogOut(it, v, true)
+	}
+	return graph.ContainsLogOut(it, v, false)
+}
+
+func (it *Iterator) Size() (int64, bool) {
+	if it.size == -1 {
+		var err error
+		it.size, err = it.qs.getSize(it.collection, it.constraint)
+		if err != nil {
+			it.err = err
+		}
+	}
+	return it.size, true
+}
+
+var mongoType graph.Type
+
+func init() {
+	mongoType = graph.RegisterIterator("mongo")
+}
+
+func Type() graph.Type { return mongoType }
+
+func (it *Iterator) Type() graph.Type {
+	if it.isAll {
+		return graph.All
+	}
+	return mongoType
+}
+
+func (it *Iterator) Sorted() bool                     { return true }
+func (it *Iterator) Optimize() (graph.Iterator, bool) { return it, false }
+
+func (it *Iterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:  it.UID(),
+		Name: fmt.Sprintf("%s/%s", it.name, it.hash),
+		Type: it.Type(),
+		Size: size,
+	}
+}
+
+func (it *Iterator) Stats() graph.IteratorStats {
+	size, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     5,
+		Size:         size,
+	}
+}
+
+var _ graph.Nexter = &Iterator{}
diff --git a/vendor/github.com/google/cayley/graph/mongo/lru.go b/vendor/github.com/google/cayley/graph/mongo/lru.go
new file mode 100644
index 00000000..34f9db71
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/mongo/lru.go
@@ -0,0 +1,65 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongo
+
+import (
+	"container/list"
+)
+
+// TODO(kortschak) Reimplement without container/list.
+
+// cache implements an LRU cache.
+type cache struct {
+	cache    map[string]*list.Element
+	priority *list.List
+	maxSize  int
+}
+
+type kv struct {
+	key   string
+	value interface{}
+}
+
+func newCache(size int) *cache {
+	var lru cache
+	lru.maxSize = size
+	lru.priority = list.New()
+	lru.cache = make(map[string]*list.Element)
+	return &lru
+}
+
+func (lru *cache) Put(key string, value interface{}) {
+	if _, ok := lru.Get(key); ok {
+		return
+	}
+	if len(lru.cache) == lru.maxSize {
+		lru.removeOldest()
+	}
+	lru.priority.PushFront(kv{key: key, value: value})
+	lru.cache[key] = lru.priority.Front()
+}
+
+func (lru *cache) Get(key string) (interface{}, bool) {
+	if element, ok := lru.cache[key]; ok {
+		lru.priority.MoveToFront(element)
+		return element.Value.(kv).value, true
+	}
+	return nil, false
+}
+
+func (lru *cache) removeOldest() {
+	last := lru.priority.Remove(lru.priority.Back())
+	delete(lru.cache, last.(kv).key)
+}
diff --git a/vendor/github.com/google/cayley/graph/mongo/quadstore.go b/vendor/github.com/google/cayley/graph/mongo/quadstore.go
new file mode 100644
index 00000000..06cce2b1
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/mongo/quadstore.go
@@ -0,0 +1,411 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongo
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"errors"
+	"hash"
+	"sync"
+
+	"gopkg.in/mgo.v2"
+	"gopkg.in/mgo.v2/bson"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+const DefaultDBName = "cayley"
+const QuadStoreType = "mongo"
+
+func init() {
+	graph.RegisterQuadStore(QuadStoreType, graph.QuadStoreRegistration{
+		NewFunc:           newQuadStore,
+		NewForRequestFunc: nil,
+		UpgradeFunc:       nil,
+		InitFunc:          createNewMongoGraph,
+		IsPersistent:      true,
+	})
+}
+
+var (
+	hashPool = sync.Pool{
+		New: func() interface{} { return sha1.New() },
+	}
+	hashSize = sha1.Size
+)
+
+type QuadStore struct {
+	session *mgo.Session
+	db      *mgo.Database
+	ids     *cache
+	sizes   *cache
+}
+
+func createNewMongoGraph(addr string, options graph.Options) error {
+	conn, err := mgo.Dial(addr)
+	if err != nil {
+		return err
+	}
+	conn.SetSafe(&mgo.Safe{})
+	dbName := DefaultDBName
+	val, ok, err := options.StringKey("database_name")
+	if err != nil {
+		return err
+	} else if ok {
+		dbName = val
+	}
+	db := conn.DB(dbName)
+	indexOpts := mgo.Index{
+		Key:        []string{"subject"},
+		Unique:     false,
+		DropDups:   false,
+		Background: true,
+		Sparse:     true,
+	}
+	db.C("quads").EnsureIndex(indexOpts)
+	indexOpts.Key = []string{"predicate"}
+	db.C("quads").EnsureIndex(indexOpts)
+	indexOpts.Key = []string{"object"}
+	db.C("quads").EnsureIndex(indexOpts)
+	indexOpts.Key = []string{"label"}
+	db.C("quads").EnsureIndex(indexOpts)
+	logOpts := mgo.Index{
+		Key:        []string{"LogID"},
+		Unique:     true,
+		DropDups:   false,
+		Background: true,
+		Sparse:     true,
+	}
+	db.C("log").EnsureIndex(logOpts)
+	return nil
+}
+
+func newQuadStore(addr string, options graph.Options) (graph.QuadStore, error) {
+	var qs QuadStore
+	conn, err := mgo.Dial(addr)
+	if err != nil {
+		return nil, err
+	}
+	conn.SetSafe(&mgo.Safe{})
+	dbName := DefaultDBName
+	val, ok, err := options.StringKey("database_name")
+	if err != nil {
+		return nil, err
+	} else if ok {
+		dbName = val
+	}
+	qs.db = conn.DB(dbName)
+	qs.session = conn
+	qs.ids = newCache(1 << 16)
+	qs.sizes = newCache(1 << 16)
+	return &qs, nil
+}
+
+func (qs *QuadStore) getIDForQuad(t quad.Quad) string {
+	id := hashOf(t.Subject)
+	id += hashOf(t.Predicate)
+	id += hashOf(t.Object)
+	id += hashOf(t.Label)
+	return id
+}
+
+func hashOf(s string) string {
+	h := hashPool.Get().(hash.Hash)
+	h.Reset()
+	defer hashPool.Put(h)
+
+	key := make([]byte, 0, hashSize)
+	h.Write([]byte(s))
+	key = h.Sum(key)
+	return hex.EncodeToString(key)
+}
+
+type MongoNode struct {
+	ID   string `bson:"_id"`
+	Name string `bson:"Name"`
+	Size int    `bson:"Size"`
+}
+
+type MongoLogEntry struct {
+	LogID     int64  `bson:"LogID"`
+	Action    string `bson:"Action"`
+	Key       string `bson:"Key"`
+	Timestamp int64
+}
+
+func (qs *QuadStore) updateNodeBy(name string, inc int) error {
+	node := qs.ValueOf(name)
+	doc := bson.M{
+		"_id":  node.(string),
+		"Name": name,
+	}
+	upsert := bson.M{
+		"$setOnInsert": doc,
+		"$inc": bson.M{
+			"Size": inc,
+		},
+	}
+
+	_, err := qs.db.C("nodes").UpsertId(node, upsert)
+	if err != nil {
+		glog.Errorf("Error updating node: %v", err)
+	}
+	return err
+}
+
+func (qs *QuadStore) updateQuad(q quad.Quad, id int64, proc graph.Procedure) error {
+	var setname string
+	if proc == graph.Add {
+		setname = "Added"
+	} else if proc == graph.Delete {
+		setname = "Deleted"
+	}
+	upsert := bson.M{
+		"$setOnInsert": q,
+		"$push": bson.M{
+			setname: id,
+		},
+	}
+	_, err := qs.db.C("quads").UpsertId(qs.getIDForQuad(q), upsert)
+	if err != nil {
+		glog.Errorf("Error: %v", err)
+	}
+	return err
+}
+
+func (qs *QuadStore) checkValid(key string) bool {
+	var indexEntry struct {
+		Added   []int64 `bson:"Added"`
+		Deleted []int64 `bson:"Deleted"`
+	}
+	err := qs.db.C("quads").FindId(key).One(&indexEntry)
+	if err == mgo.ErrNotFound {
+		return false
+	}
+	if err != nil {
+		glog.Errorln("Other error checking valid quad: %s %v.", key, err)
+		return false
+	}
+	if len(indexEntry.Added) <= len(indexEntry.Deleted) {
+		return false
+	}
+	return true
+}
+
+func (qs *QuadStore) updateLog(d graph.Delta) error {
+	var action string
+	if d.Action == graph.Add {
+		action = "Add"
+	} else {
+		action = "Delete"
+	}
+	entry := MongoLogEntry{
+		LogID:     d.ID.Int(),
+		Action:    action,
+		Key:       qs.getIDForQuad(d.Quad),
+		Timestamp: d.Timestamp.UnixNano(),
+	}
+	err := qs.db.C("log").Insert(entry)
+	if err != nil {
+		glog.Errorf("Error updating log: %v", err)
+	}
+	return err
+}
+
+func (qs *QuadStore) ApplyDeltas(in []graph.Delta, ignoreOpts graph.IgnoreOpts) error {
+	qs.session.SetSafe(nil)
+	ids := make(map[string]int)
+	// Pre-check the existence condition.
+	for _, d := range in {
+		if d.Action != graph.Add && d.Action != graph.Delete {
+			return errors.New("mongo: invalid action")
+		}
+		key := qs.getIDForQuad(d.Quad)
+		switch d.Action {
+		case graph.Add:
+			if qs.checkValid(key) {
+				if ignoreOpts.IgnoreDup {
+					continue
+				} else {
+					return graph.ErrQuadExists
+				}
+			}
+		case graph.Delete:
+			if !qs.checkValid(key) {
+				if ignoreOpts.IgnoreMissing {
+					continue
+				} else {
+					return graph.ErrQuadNotExist
+				}
+			}
+		}
+	}
+	if glog.V(2) {
+		glog.Infoln("Existence verified. Proceeding.")
+	}
+	for _, d := range in {
+		err := qs.updateLog(d)
+		if err != nil {
+			return err
+		}
+	}
+	for _, d := range in {
+		err := qs.updateQuad(d.Quad, d.ID.Int(), d.Action)
+		if err != nil {
+			return err
+		}
+		var countdelta int
+		if d.Action == graph.Add {
+			countdelta = 1
+		} else {
+			countdelta = -1
+		}
+		ids[d.Quad.Subject] += countdelta
+		ids[d.Quad.Object] += countdelta
+		ids[d.Quad.Predicate] += countdelta
+		if d.Quad.Label != "" {
+			ids[d.Quad.Label] += countdelta
+		}
+	}
+	for k, v := range ids {
+		err := qs.updateNodeBy(k, v)
+		if err != nil {
+			return err
+		}
+	}
+	qs.session.SetSafe(&mgo.Safe{})
+	return nil
+}
+
+func (qs *QuadStore) Quad(val graph.Value) quad.Quad {
+	var q quad.Quad
+	err := qs.db.C("quads").FindId(val.(string)).One(&q)
+	if err != nil {
+		glog.Errorf("Error: Couldn't retrieve quad %s %v", val, err)
+	}
+	return q
+}
+
+func (qs *QuadStore) QuadIterator(d quad.Direction, val graph.Value) graph.Iterator {
+	return NewIterator(qs, "quads", d, val)
+}
+
+func (qs *QuadStore) NodesAllIterator() graph.Iterator {
+	return NewAllIterator(qs, "nodes")
+}
+
+func (qs *QuadStore) QuadsAllIterator() graph.Iterator {
+	return NewAllIterator(qs, "quads")
+}
+
+func (qs *QuadStore) ValueOf(s string) graph.Value {
+	return hashOf(s)
+}
+
+func (qs *QuadStore) NameOf(v graph.Value) string {
+	val, ok := qs.ids.Get(v.(string))
+	if ok {
+		return val.(string)
+	}
+	var node MongoNode
+	err := qs.db.C("nodes").FindId(v.(string)).One(&node)
+	if err != nil {
+		glog.Errorf("Error: Couldn't retrieve node %s %v", v, err)
+	} else if node.ID != "" && node.Name != "" {
+		qs.ids.Put(v.(string), node.Name)
+	}
+	return node.Name
+}
+
+func (qs *QuadStore) Size() int64 {
+	// TODO(barakmich): Make size real; store it in the log, and retrieve it.
+	count, err := qs.db.C("quads").Count()
+	if err != nil {
+		glog.Errorf("Error: %v", err)
+		return 0
+	}
+	return int64(count)
+}
+
+func (qs *QuadStore) Horizon() graph.PrimaryKey {
+	var log MongoLogEntry
+	err := qs.db.C("log").Find(nil).Sort("-LogID").One(&log)
+	if err != nil {
+		if err == mgo.ErrNotFound {
+			return graph.NewSequentialKey(0)
+		}
+		glog.Errorf("Could not get Horizon from Mongo: %v", err)
+	}
+	return graph.NewSequentialKey(log.LogID)
+}
+
+func (qs *QuadStore) FixedIterator() graph.FixedIterator {
+	return iterator.NewFixed(iterator.Identity)
+}
+
+func (qs *QuadStore) Close() {
+	qs.db.Session.Close()
+}
+
+func (qs *QuadStore) QuadDirection(in graph.Value, d quad.Direction) graph.Value {
+	// Maybe do the trick here
+	var offset int
+	switch d {
+	case quad.Subject:
+		offset = 0
+	case quad.Predicate:
+		offset = (hashSize * 2)
+	case quad.Object:
+		offset = (hashSize * 2) * 2
+	case quad.Label:
+		offset = (hashSize * 2) * 3
+	}
+	val := in.(string)[offset : hashSize*2+offset]
+	return val
+}
+
+// TODO(barakmich): Rewrite bulk loader. For now, iterating around blocks is the way we'll go about it.
+
+func (qs *QuadStore) Type() string {
+	return QuadStoreType
+}
+
+func (qs *QuadStore) getSize(collection string, constraint bson.M) (int64, error) {
+	var size int
+	bytes, err := bson.Marshal(constraint)
+	if err != nil {
+		glog.Errorf("Couldn't marshal internal constraint")
+		return -1, err
+	}
+	key := collection + string(bytes)
+	if val, ok := qs.sizes.Get(key); ok {
+		return val.(int64), nil
+	}
+	if constraint == nil {
+		size, err = qs.db.C(collection).Count()
+	} else {
+		size, err = qs.db.C(collection).Find(constraint).Count()
+	}
+	if err != nil {
+		glog.Errorln("Trouble getting size for iterator! ", err)
+		return -1, err
+	}
+	qs.sizes.Put(key, int64(size))
+	return int64(size), nil
+}
diff --git a/vendor/github.com/google/cayley/graph/mongo/quadstore_iterator_optimize.go b/vendor/github.com/google/cayley/graph/mongo/quadstore_iterator_optimize.go
new file mode 100644
index 00000000..bb7d21ec
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/mongo/quadstore_iterator_optimize.go
@@ -0,0 +1,120 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mongo
+
+import (
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+)
+
+func (qs *QuadStore) OptimizeIterator(it graph.Iterator) (graph.Iterator, bool) {
+	switch it.Type() {
+	case graph.LinksTo:
+		return qs.optimizeLinksTo(it.(*iterator.LinksTo))
+	case graph.And:
+		return qs.optimizeAndIterator(it.(*iterator.And))
+
+	}
+	return it, false
+}
+
+func (qs *QuadStore) optimizeAndIterator(it *iterator.And) (graph.Iterator, bool) {
+	// Fail fast if nothing can happen
+	glog.V(4).Infoln("Entering optimizeAndIterator", it.UID())
+	found := false
+	for _, it := range it.SubIterators() {
+		glog.V(4).Infoln(it.Type())
+		if it.Type() == mongoType {
+			found = true
+		}
+	}
+	if !found {
+		glog.V(4).Infoln("Aborting optimizeAndIterator")
+		return it, false
+	}
+
+	newAnd := iterator.NewAnd(qs)
+	var mongoIt *Iterator
+	for _, it := range it.SubIterators() {
+		switch it.Type() {
+		case mongoType:
+			if mongoIt == nil {
+				mongoIt = it.(*Iterator)
+			} else {
+				newAnd.AddSubIterator(it)
+			}
+		case graph.LinksTo:
+			continue
+		default:
+			newAnd.AddSubIterator(it)
+		}
+	}
+	stats := mongoIt.Stats()
+
+	lset := []graph.Linkage{
+		{
+			Dir:    mongoIt.dir,
+			Value: qs.ValueOf(mongoIt.name),
+		},
+	}
+
+	n := 0
+	for _, it := range it.SubIterators() {
+		if it.Type() == graph.LinksTo {
+			lto := it.(*iterator.LinksTo)
+			// Is it more effective to do the replacement, or let the mongo check the linksto?
+			ltostats := lto.Stats()
+			if (ltostats.ContainsCost+stats.NextCost)*stats.Size > (ltostats.NextCost+stats.ContainsCost)*ltostats.Size {
+				continue
+			}
+			newLto := NewLinksTo(qs, lto.SubIterators()[0], "quads", lto.Direction(), lset)
+			newAnd.AddSubIterator(newLto)
+			n++
+		}
+	}
+	if n == 0 {
+		return it, false
+	}
+
+	return newAnd.Optimize()
+}
+
+func (qs *QuadStore) optimizeLinksTo(it *iterator.LinksTo) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	if len(subs) != 1 {
+		return it, false
+	}
+	primary := subs[0]
+	if primary.Type() == graph.Fixed {
+		size, _ := primary.Size()
+		if size == 1 {
+			if !graph.Next(primary) {
+				panic("unexpected size during optimize")
+			}
+			val := primary.Result()
+			newIt := qs.QuadIterator(it.Direction(), val)
+			nt := newIt.Tagger()
+			nt.CopyFrom(it)
+			for _, tag := range primary.Tagger().Tags() {
+				nt.AddFixed(tag, val)
+			}
+			it.Close()
+			return newIt, true
+		}
+	}
+	return it, false
+}
diff --git a/vendor/github.com/google/cayley/graph/path/morphism_apply_functions.go b/vendor/github.com/google/cayley/graph/path/morphism_apply_functions.go
new file mode 100644
index 00000000..7444c20b
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/path/morphism_apply_functions.go
@@ -0,0 +1,345 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package path
+
+import (
+	"fmt"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+// join puts two iterators together by intersecting their result sets with an AND
+// Since we're using an and iterator, it's a good idea to put the smallest result
+// set first so that Next() produces fewer values to check Contains().
+func join(qs graph.QuadStore, itL, itR graph.Iterator) graph.Iterator {
+	and := iterator.NewAnd(qs)
+	and.AddSubIterator(itL)
+	and.AddSubIterator(itR)
+
+	return and
+}
+
+// isMorphism represents all nodes passed in-- if there are none, this function
+// acts as a passthrough for the previous iterator.
+func isMorphism(nodes ...string) morphism {
+	return morphism{
+		Name:     "is",
+		Reversal: func(ctx *context) (morphism, *context) { return isMorphism(nodes...), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			if len(nodes) == 0 {
+				// Acting as a passthrough here is equivalent to
+				// building a NodesAllIterator to Next() or Contains()
+				// from here as in previous versions.
+				return in, ctx
+			}
+
+			isNodes := qs.FixedIterator()
+			for _, n := range nodes {
+				isNodes.Add(qs.ValueOf(n))
+			}
+
+			// Anything with fixedIterators will usually have a much
+			// smaller result set, so join isNodes first here.
+			return join(qs, isNodes, in), ctx
+		},
+	}
+}
+
+// hasMorphism is the set of nodes that is reachable via either a *Path, a
+// single node.(string) or a list of nodes.([]string).
+func hasMorphism(via interface{}, nodes ...string) morphism {
+	return morphism{
+		Name:     "has",
+		Reversal: func(ctx *context) (morphism, *context) { return hasMorphism(via, nodes...), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			viaIter := buildViaPath(qs, via).
+				BuildIterator()
+			ends := func() graph.Iterator {
+				if len(nodes) == 0 {
+					return qs.NodesAllIterator()
+				}
+
+				fixed := qs.FixedIterator()
+				for _, n := range nodes {
+					fixed.Add(qs.ValueOf(n))
+				}
+				return fixed
+			}()
+
+			trail := iterator.NewLinksTo(qs, viaIter, quad.Predicate)
+			dest := iterator.NewLinksTo(qs, ends, quad.Object)
+
+			// If we were given nodes, intersecting with them first will
+			// be extremely cheap-- otherwise, it will be the most expensive
+			// (requiring iteration over all nodes). We have enough info to
+			// make this optimization now since intersections are commutative
+			if len(nodes) == 0 { // Where dest involves an All iterator.
+				route := join(qs, trail, dest)
+				has := iterator.NewHasA(qs, route, quad.Subject)
+				return join(qs, in, has), ctx
+			}
+
+			// This looks backwards. That's OK-- see the note above.
+			route := join(qs, dest, trail)
+			has := iterator.NewHasA(qs, route, quad.Subject)
+			return join(qs, has, in), ctx
+		},
+	}
+}
+
+func tagMorphism(tags ...string) morphism {
+	return morphism{
+		Name:     "tag",
+		Reversal: func(ctx *context) (morphism, *context) { return tagMorphism(tags...), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			for _, t := range tags {
+				in.Tagger().Add(t)
+			}
+			return in, ctx
+		},
+		tags: tags,
+	}
+}
+
+// outMorphism iterates forward one RDF triple or via an entire path.
+func outMorphism(tags []string, via ...interface{}) morphism {
+	return morphism{
+		Name:     "out",
+		Reversal: func(ctx *context) (morphism, *context) { return inMorphism(tags, via...), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			path := buildViaPath(qs, via...)
+			return inOutIterator(path, in, false, tags), ctx
+		},
+	}
+}
+
+// inMorphism iterates backwards one RDF triple or via an entire path.
+func inMorphism(tags []string, via ...interface{}) morphism {
+	return morphism{
+		Name:     "in",
+		Reversal: func(ctx *context) (morphism, *context) { return outMorphism(tags, via...), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			path := buildViaPath(qs, via...)
+			return inOutIterator(path, in, true, tags), ctx
+		},
+	}
+}
+
+func bothMorphism(tags []string, via ...interface{}) morphism {
+	return morphism{
+		Name:     "in",
+		Reversal: func(ctx *context) (morphism, *context) { return bothMorphism(tags, via...), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			path := buildViaPath(qs, via...)
+			inSide := inOutIterator(path, in, true, tags)
+			outSide := inOutIterator(path, in.Clone(), false, tags)
+			or := iterator.NewOr()
+			or.AddSubIterator(inSide)
+			or.AddSubIterator(outSide)
+			return or, ctx
+		},
+	}
+}
+
+// predicatesMorphism iterates to the uniqified set of predicates from
+// the given set of nodes in the path.
+func predicatesMorphism(isIn bool) morphism {
+	m := morphism{
+		Name: "out_predicates",
+		Reversal: func(ctx *context) (morphism, *context) {
+			panic("not implemented: need a function from predicates to their associated edges")
+		},
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			dir := quad.Subject
+			if isIn {
+				dir = quad.Object
+			}
+			lto := iterator.NewLinksTo(qs, in, dir)
+			hasa := iterator.NewHasA(qs, lto, quad.Predicate)
+			return iterator.NewUnique(hasa), ctx
+		},
+	}
+	if isIn {
+		m.Name = "in_predicates"
+	}
+	return m
+}
+
+// iteratorMorphism simply tacks the input iterator onto the chain.
+func iteratorMorphism(it graph.Iterator) morphism {
+	return morphism{
+		Name:     "iterator",
+		Reversal: func(ctx *context) (morphism, *context) { return iteratorMorphism(it), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			return join(qs, it, in), ctx
+		},
+	}
+}
+
+// andMorphism sticks a path onto the current iterator chain.
+func andMorphism(p *Path) morphism {
+	return morphism{
+		Name:     "and",
+		Reversal: func(ctx *context) (morphism, *context) { return andMorphism(p), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			itR := p.BuildIteratorOn(qs)
+
+			return join(qs, in, itR), ctx
+		},
+	}
+}
+
+// orMorphism is the union, vice intersection, of a path and the current iterator.
+func orMorphism(p *Path) morphism {
+	return morphism{
+		Name:     "or",
+		Reversal: func(ctx *context) (morphism, *context) { return orMorphism(p), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			itR := p.BuildIteratorOn(qs)
+
+			or := iterator.NewOr()
+			or.AddSubIterator(in)
+			or.AddSubIterator(itR)
+			return or, ctx
+		},
+	}
+}
+
+func followMorphism(p *Path) morphism {
+	return morphism{
+		Name:     "follow",
+		Reversal: func(ctx *context) (morphism, *context) { return followMorphism(p.Reverse()), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			return p.Morphism()(qs, in), ctx
+		},
+	}
+}
+
+// exceptMorphism removes all results on p.(*Path) from the current iterators.
+func exceptMorphism(p *Path) morphism {
+	return morphism{
+		Name:     "except",
+		Reversal: func(ctx *context) (morphism, *context) { return exceptMorphism(p), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			subIt := p.BuildIteratorOn(qs)
+			allNodes := qs.NodesAllIterator()
+			notIn := iterator.NewNot(subIt, allNodes)
+
+			return join(qs, in, notIn), ctx
+		},
+	}
+}
+
+func saveMorphism(via interface{}, tag string) morphism {
+	return morphism{
+		Name:     "save",
+		Reversal: func(ctx *context) (morphism, *context) { return saveMorphism(via, tag), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			return buildSave(qs, via, tag, in, false), ctx
+		},
+		tags: []string{tag},
+	}
+}
+
+func saveReverseMorphism(via interface{}, tag string) morphism {
+	return morphism{
+		Name:     "saver",
+		Reversal: func(ctx *context) (morphism, *context) { return saveReverseMorphism(via, tag), ctx },
+		Apply: func(qs graph.QuadStore, in graph.Iterator, ctx *context) (graph.Iterator, *context) {
+			return buildSave(qs, via, tag, in, true), ctx
+		},
+		tags: []string{tag},
+	}
+}
+
+func buildSave(
+	qs graph.QuadStore, via interface{},
+	tag string, from graph.Iterator, reverse bool,
+) graph.Iterator {
+
+	allNodes := qs.NodesAllIterator()
+	allNodes.Tagger().Add(tag)
+
+	start, goal := quad.Subject, quad.Object
+	if reverse {
+		start, goal = goal, start
+	}
+	viaIter := buildViaPath(qs, via).
+		BuildIterator()
+
+	dest := iterator.NewLinksTo(qs, allNodes, goal)
+	trail := iterator.NewLinksTo(qs, viaIter, quad.Predicate)
+
+	route := join(qs, trail, dest)
+	save := iterator.NewHasA(qs, route, start)
+
+	return join(qs, from, save)
+}
+
+func inOutIterator(viaPath *Path, from graph.Iterator, inIterator bool, tags []string) graph.Iterator {
+	start, goal := quad.Subject, quad.Object
+	if inIterator {
+		start, goal = goal, start
+	}
+
+	viaIter := viaPath.BuildIterator()
+	for _, tag := range tags {
+		viaIter.Tagger().Add(tag)
+	}
+
+	source := iterator.NewLinksTo(viaPath.qs, from, start)
+	trail := iterator.NewLinksTo(viaPath.qs, viaIter, quad.Predicate)
+
+	route := join(viaPath.qs, source, trail)
+
+	return iterator.NewHasA(viaPath.qs, route, goal)
+}
+
+func buildViaPath(qs graph.QuadStore, via ...interface{}) *Path {
+	if len(via) == 0 {
+		return PathFromIterator(qs, qs.NodesAllIterator())
+	} else if len(via) == 1 {
+		v := via[0]
+		switch p := v.(type) {
+		case nil:
+			return PathFromIterator(qs, qs.NodesAllIterator())
+		case *Path:
+			if p.qs != qs {
+				newp := &Path{
+					qs:          qs,
+					baseContext: p.baseContext,
+					stack:       p.stack[:],
+				}
+				return newp
+			}
+			return p
+		case string:
+			return StartPath(qs, p)
+		default:
+			panic(fmt.Sprint("Invalid type passed to buildViaPath. ", p))
+		}
+	}
+	var strings []string
+	for _, s := range via {
+		if str, ok := s.(string); ok {
+			strings = append(strings, str)
+		} else {
+			panic("Non-string type passed to long Via path")
+		}
+	}
+	return StartPath(qs, strings...)
+}
diff --git a/vendor/github.com/google/cayley/graph/path/path.go b/vendor/github.com/google/cayley/graph/path/path.go
new file mode 100644
index 00000000..7e364efd
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/path/path.go
@@ -0,0 +1,327 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package path
+
+import "github.com/google/cayley/graph"
+
+type applyMorphism func(graph.QuadStore, graph.Iterator, *context) (graph.Iterator, *context)
+
+type morphism struct {
+	Name     string
+	Reversal func(*context) (morphism, *context)
+	Apply    applyMorphism
+	tags     []string
+	context  context
+}
+
+// context allows a high-level change to the way paths are constructed. Some
+// functions may change the context, causing following chained calls to act
+// cdifferently.
+//
+// In a sense, this is a global state which can be changed as the path
+// continues. And as with dealing with any global state, care should be taken:
+//
+// When modifying the context in Apply(), please copy the passed struct,
+// modifying the relevant fields if need be (or pass the given context onward).
+//
+// Under Reversal(), any functions that wish to change the context should
+// appropriately change the passed context (that is, the context that came after
+// them will now be what the application of the function would have been) and
+// then yield a pointer to their own member context as the return value.
+//
+// For more examples, look at the morphisms which claim the individual fields.
+type context struct {
+	// Represents the path to the limiting set of labels that should be considered under traversal.
+	// inMorphism, outMorphism, et al should constrain edges by this set.
+	// A nil in this field represents all labels.
+	//
+	// Claimed by the withLabel morphism
+	labelSet *Path
+}
+
+// Path represents either a morphism (a pre-defined path stored for later use),
+// or a concrete path, consisting of a morphism and an underlying QuadStore.
+type Path struct {
+	stack       []morphism
+	qs          graph.QuadStore // Optionally. A nil qs is equivalent to a morphism.
+	baseContext context
+}
+
+// IsMorphism returns whether this Path is a morphism.
+func (p *Path) IsMorphism() bool { return p.qs == nil }
+
+// StartMorphism creates a new Path with no underlying QuadStore.
+func StartMorphism(nodes ...string) *Path {
+	return StartPath(nil, nodes...)
+}
+
+// StartPath creates a new Path from a set of nodes and an underlying QuadStore.
+func StartPath(qs graph.QuadStore, nodes ...string) *Path {
+	return &Path{
+		stack: []morphism{
+			isMorphism(nodes...),
+		},
+		qs: qs,
+	}
+}
+
+func PathFromIterator(qs graph.QuadStore, it graph.Iterator) *Path {
+	return &Path{
+		stack: []morphism{
+			iteratorMorphism(it),
+		},
+		qs: qs,
+	}
+}
+
+// NewPath creates a new, empty Path.
+func NewPath(qs graph.QuadStore) *Path {
+	return &Path{
+		qs: qs,
+	}
+}
+
+// Reverse returns a new Path that is the reverse of the current one.
+func (p *Path) Reverse() *Path {
+	newPath := NewPath(p.qs)
+	ctx := &newPath.baseContext
+	for i := len(p.stack) - 1; i >= 0; i-- {
+		var revMorphism morphism
+		revMorphism, ctx = p.stack[i].Reversal(ctx)
+		newPath.stack = append(newPath.stack, revMorphism)
+	}
+	return newPath
+}
+
+// Is declares that the current nodes in this path are only the nodes
+// passed as arguments.
+func (p *Path) Is(nodes ...string) *Path {
+	p.stack = append(p.stack, isMorphism(nodes...))
+	return p
+}
+
+// Tag adds tag strings to the nodes at this point in the path for each result
+// path in the set.
+func (p *Path) Tag(tags ...string) *Path {
+	p.stack = append(p.stack, tagMorphism(tags...))
+	return p
+}
+
+// Out updates this Path to represent the nodes that are adjacent to the
+// current nodes, via the given outbound predicate.
+//
+// For example:
+//  // Returns the list of nodes that "B" follows.
+//  //
+//  // Will return []string{"F"} if there is a predicate (edge) from "B"
+//  // to "F" labelled "follows".
+//  StartPath(qs, "A").Out("follows")
+func (p *Path) Out(via ...interface{}) *Path {
+	p.stack = append(p.stack, outMorphism(nil, via...))
+	return p
+}
+
+// In updates this Path to represent the nodes that are adjacent to the
+// current nodes, via the given inbound predicate.
+//
+// For example:
+//  // Return the list of nodes that follow "B".
+//  //
+//  // Will return []string{"A", "C", "D"} if there are the appropriate
+//  // edges from those nodes to "B" labelled "follows".
+//  StartPath(qs, "B").In("follows")
+func (p *Path) In(via ...interface{}) *Path {
+	p.stack = append(p.stack, inMorphism(nil, via...))
+	return p
+}
+
+// InWithTags is exactly like In, except it tags the value of the predicate
+// traversed with the tags provided.
+func (p *Path) InWithTags(tags []string, via ...interface{}) *Path {
+	p.stack = append(p.stack, inMorphism(tags, via...))
+	return p
+}
+
+// OutWithTags is exactly like In, except it tags the value of the predicate
+// traversed with the tags provided.
+func (p *Path) OutWithTags(tags []string, via ...interface{}) *Path {
+	p.stack = append(p.stack, outMorphism(tags, via...))
+	return p
+}
+
+// Both updates this path following both inbound and outbound predicates.
+//
+// For example:
+//  // Return the list of nodes that follow or are followed by "B".
+//  //
+//  // Will return []string{"A", "C", "D", "F} if there are the appropriate
+//  // edges from those nodes to "B" labelled "follows", in either direction.
+//  StartPath(qs, "B").Both("follows")
+func (p *Path) Both(via ...interface{}) *Path {
+	p.stack = append(p.stack, bothMorphism(nil, via...))
+	return p
+}
+
+// InPredicates updates this path to represent the nodes of the valid inbound
+// predicates from the current nodes.
+//
+// For example:
+//  // Returns a list of predicates valid from "bob"
+//  //
+//  // Will return []string{"follows"} if there are any things that "follow" Bob
+//  StartPath(qs, "bob").InPredicates()
+func (p *Path) InPredicates() *Path {
+	p.stack = append(p.stack, predicatesMorphism(true))
+	return p
+}
+
+// OutPredicates updates this path to represent the nodes of the valid inbound
+// predicates from the current nodes.
+//
+// For example:
+//  // Returns a list of predicates valid from "bob"
+//  //
+//  // Will return []string{"follows", "status"} if there are edges from "bob"
+//  // labelled "follows", and edges from "bob" that describe his "status".
+//  StartPath(qs, "bob").OutPredicates()
+func (p *Path) OutPredicates() *Path {
+	p.stack = append(p.stack, predicatesMorphism(false))
+	return p
+}
+
+// And updates the current Path to represent the nodes that match both the
+// current Path so far, and the given Path.
+func (p *Path) And(path *Path) *Path {
+	p.stack = append(p.stack, andMorphism(path))
+	return p
+}
+
+// Or updates the current Path to represent the nodes that match either the
+// current Path so far, or the given Path.
+func (p *Path) Or(path *Path) *Path {
+	p.stack = append(p.stack, orMorphism(path))
+	return p
+}
+
+// Except updates the current Path to represent the all of the current nodes
+// except those in the supplied Path.
+//
+// For example:
+//  // Will return []string{"B"}
+//  StartPath(qs, "A", "B").Except(StartPath(qs, "A"))
+func (p *Path) Except(path *Path) *Path {
+	p.stack = append(p.stack, exceptMorphism(path))
+	return p
+}
+
+// Follow allows you to stitch two paths together. The resulting path will start
+// from where the first path left off and continue iterating down the path given.
+func (p *Path) Follow(path *Path) *Path {
+	p.stack = append(p.stack, followMorphism(path))
+	return p
+}
+
+// FollowReverse is the same as follow, except it will iterate backwards up the
+// path given as argument.
+func (p *Path) FollowReverse(path *Path) *Path {
+	p.stack = append(p.stack, followMorphism(path.Reverse()))
+	return p
+}
+
+// Save will, from the current nodes in the path, retrieve the node
+// one linkage away (given by either a path or a predicate), add the given
+// tag, and propagate that to the result set.
+//
+// For example:
+//  // Will return []map[string]string{{"social_status: "cool"}}
+//  StartPath(qs, "B").Save("status", "social_status"
+func (p *Path) Save(via interface{}, tag string) *Path {
+	p.stack = append(p.stack, saveMorphism(via, tag))
+	return p
+}
+
+// SaveReverse is the same as Save, only in the reverse direction
+// (the subject of the linkage should be tagged, instead of the object).
+func (p *Path) SaveReverse(via interface{}, tag string) *Path {
+	p.stack = append(p.stack, saveReverseMorphism(via, tag))
+	return p
+}
+
+// Has limits the paths to be ones where the current nodes have some linkage
+// to some known node.
+func (p *Path) Has(via interface{}, nodes ...string) *Path {
+	p.stack = append(p.stack, hasMorphism(via, nodes...))
+	return p
+}
+
+// Back returns to a previously tagged place in the path. Any constraints applied after the Tag will remain in effect, but traversal continues from the tagged point instead, not from the end of the chain.
+//
+// For example:
+//  // Will return "bob" iff "bob" is cool
+//  StartPath(qs, "bob").Tag("person_tag").Out("status").Is("cool").Back("person_tag")
+func (p *Path) Back(tag string) *Path {
+	newPath := NewPath(p.qs)
+	i := len(p.stack) - 1
+	ctx := &newPath.baseContext
+	for {
+		if i < 0 {
+			return p.Reverse()
+		}
+		if p.stack[i].Name == "tag" {
+			for _, x := range p.stack[i].tags {
+				if x == tag {
+					// Found what we're looking for.
+					p.stack = p.stack[:i+1]
+					return p.And(newPath)
+				}
+			}
+		}
+		var revMorphism morphism
+		revMorphism, ctx = p.stack[i].Reversal(ctx)
+		newPath.stack = append(newPath.stack, revMorphism)
+		i--
+	}
+}
+
+// BuildIterator returns an iterator from this given Path.  Note that you must
+// call this with a full path (not a morphism), since a morphism does not have
+// the ability to fetch the underlying quads.  This function will panic if
+// called with a morphism (i.e. if p.IsMorphism() is true).
+func (p *Path) BuildIterator() graph.Iterator {
+	if p.IsMorphism() {
+		panic("Building an iterator from a morphism. Bind a QuadStore with BuildIteratorOn(qs)")
+	}
+	return p.BuildIteratorOn(p.qs)
+}
+
+// BuildIteratorOn will return an iterator for this path on the given QuadStore.
+func (p *Path) BuildIteratorOn(qs graph.QuadStore) graph.Iterator {
+	return p.Morphism()(qs, qs.NodesAllIterator())
+}
+
+// Morphism returns the morphism of this path.  The returned value is a
+// function that, when given a QuadStore and an existing Iterator, will
+// return a new Iterator that yields the subset of values from the existing
+// iterator matched by the current Path.
+func (p *Path) Morphism() graph.ApplyMorphism {
+	return func(qs graph.QuadStore, it graph.Iterator) graph.Iterator {
+		i := it.Clone()
+		ctx := &p.baseContext
+		for _, m := range p.stack {
+			i, ctx = m.Apply(qs, i, ctx)
+		}
+		return i
+	}
+}
diff --git a/vendor/github.com/google/cayley/graph/primarykey.go b/vendor/github.com/google/cayley/graph/primarykey.go
new file mode 100644
index 00000000..30159948
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/primarykey.go
@@ -0,0 +1,133 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package graph
+
+import (
+	"encoding/json"
+	"errors"
+	"strconv"
+	"sync"
+
+	"github.com/barakmich/glog"
+	"github.com/pborman/uuid"
+)
+
+type primaryKeyType uint8
+
+const (
+	none primaryKeyType = iota
+	sequential
+	unique
+)
+
+type PrimaryKey struct {
+	keyType      primaryKeyType
+	mut          sync.Mutex
+	sequentialID int64
+	uniqueID     string
+}
+
+func NewSequentialKey(horizon int64) PrimaryKey {
+	return PrimaryKey{
+		keyType:      sequential,
+		sequentialID: horizon,
+	}
+}
+
+func NewUniqueKey(horizon string) PrimaryKey {
+	id := uuid.Parse(horizon)
+	if id == nil {
+		id = uuid.NewUUID()
+	}
+	return PrimaryKey{
+		keyType:  unique,
+		uniqueID: id.String(),
+	}
+}
+
+func (p *PrimaryKey) Next() PrimaryKey {
+	switch p.keyType {
+	case sequential:
+		p.mut.Lock()
+		defer p.mut.Unlock()
+		p.sequentialID++
+		if p.sequentialID <= 0 {
+			p.sequentialID = 1
+		}
+		return PrimaryKey{
+			keyType:      sequential,
+			sequentialID: p.sequentialID,
+		}
+	case unique:
+		id := uuid.NewUUID()
+		p.uniqueID = id.String()
+		return *p
+	case none:
+		panic("Calling next() on a none PrimaryKey")
+	}
+	return PrimaryKey{}
+}
+
+func (p *PrimaryKey) Int() int64 {
+	switch p.keyType {
+	case sequential:
+		return p.sequentialID
+	case unique:
+		msg := "UUID cannot be converted to an int64"
+		glog.Errorln(msg)
+		panic(msg)
+	}
+	return -1
+}
+
+func (p *PrimaryKey) String() string {
+	switch p.keyType {
+	case sequential:
+		return strconv.FormatInt(p.sequentialID, 10)
+	case unique:
+		return p.uniqueID
+	case none:
+		panic("Calling String() on a none PrimaryKey")
+	}
+	return ""
+}
+
+func (p PrimaryKey) MarshalJSON() ([]byte, error) {
+	switch p.keyType {
+	case none:
+		return nil, errors.New("Cannot marshal PrimaryKey with KeyType of 'none'")
+	case sequential:
+		return json.Marshal(p.sequentialID)
+	case unique:
+		return []byte("\"u" + p.uniqueID + "\""), nil
+	default:
+		return nil, errors.New("Unknown PrimaryKey type")
+	}
+}
+
+func (p *PrimaryKey) UnmarshalJSON(bytes []byte) error {
+	if bytes[0] == '"' {
+		switch bytes[1] {
+		case 'u':
+			p.keyType = unique
+			p.uniqueID = string(bytes[2 : len(bytes)-1])
+			return nil
+		default:
+			return errors.New("Unknown string-like PrimaryKey type")
+		}
+	}
+	p.keyType = sequential
+	return json.Unmarshal(bytes, &p.sequentialID)
+}
diff --git a/vendor/github.com/google/cayley/graph/proto/serializations.pb.go b/vendor/github.com/google/cayley/graph/proto/serializations.pb.go
new file mode 100644
index 00000000..30b24d4f
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/proto/serializations.pb.go
@@ -0,0 +1,780 @@
+// Code generated by protoc-gen-gogo.
+// source: serializations.proto
+// DO NOT EDIT!
+
+/*
+	Package proto is a generated protocol buffer package.
+
+	It is generated from these files:
+		serializations.proto
+
+	It has these top-level messages:
+		LogDelta
+		HistoryEntry
+		NodeData
+		Quad
+*/
+package proto
+
+import proto1 "github.com/gogo/protobuf/proto"
+
+import io "io"
+import fmt "fmt"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+
+type LogDelta struct {
+	ID        uint64 `protobuf:"varint,1,opt,proto3" json:"ID,omitempty"`
+	Quad      *Quad  `protobuf:"bytes,2,opt" json:"Quad,omitempty"`
+	Action    int32  `protobuf:"varint,3,opt,proto3" json:"Action,omitempty"`
+	Timestamp int64  `protobuf:"varint,4,opt,proto3" json:"Timestamp,omitempty"`
+}
+
+func (m *LogDelta) Reset()         { *m = LogDelta{} }
+func (m *LogDelta) String() string { return proto1.CompactTextString(m) }
+func (*LogDelta) ProtoMessage()    {}
+
+func (m *LogDelta) GetQuad() *Quad {
+	if m != nil {
+		return m.Quad
+	}
+	return nil
+}
+
+type HistoryEntry struct {
+	History []uint64 `protobuf:"varint,1,rep" json:"History,omitempty"`
+}
+
+func (m *HistoryEntry) Reset()         { *m = HistoryEntry{} }
+func (m *HistoryEntry) String() string { return proto1.CompactTextString(m) }
+func (*HistoryEntry) ProtoMessage()    {}
+
+type NodeData struct {
+	Name  string `protobuf:"bytes,1,opt,proto3" json:"Name,omitempty"`
+	Size_ int64  `protobuf:"varint,2,opt,proto3" json:"Size,omitempty"`
+}
+
+func (m *NodeData) Reset()         { *m = NodeData{} }
+func (m *NodeData) String() string { return proto1.CompactTextString(m) }
+func (*NodeData) ProtoMessage()    {}
+
+type Quad struct {
+	Subject   string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
+	Predicate string `protobuf:"bytes,2,opt,name=predicate,proto3" json:"predicate,omitempty"`
+	Object    string `protobuf:"bytes,3,opt,name=object,proto3" json:"object,omitempty"`
+	Label     string `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"`
+}
+
+func (m *Quad) Reset()         { *m = Quad{} }
+func (m *Quad) String() string { return proto1.CompactTextString(m) }
+func (*Quad) ProtoMessage()    {}
+
+func init() {
+}
+func (m *LogDelta) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Quad", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Quad == nil {
+				m.Quad = &Quad{}
+			}
+			if err := m.Quad.Unmarshal(data[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
+			}
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				m.Action |= (int32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+			}
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				m.Timestamp |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			var sizeOfWire int
+			for {
+				sizeOfWire++
+				wire >>= 7
+				if wire == 0 {
+					break
+				}
+			}
+			iNdEx -= sizeOfWire
+			skippy, err := skipSerializations(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	return nil
+}
+func (m *HistoryEntry) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field History", wireType)
+			}
+			var v uint64
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				v |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.History = append(m.History, v)
+		default:
+			var sizeOfWire int
+			for {
+				sizeOfWire++
+				wire >>= 7
+				if wire == 0 {
+					break
+				}
+			}
+			iNdEx -= sizeOfWire
+			skippy, err := skipSerializations(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	return nil
+}
+func (m *NodeData) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			postIndex := iNdEx + int(stringLen)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(data[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
+			}
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				m.Size_ |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			var sizeOfWire int
+			for {
+				sizeOfWire++
+				wire >>= 7
+				if wire == 0 {
+					break
+				}
+			}
+			iNdEx -= sizeOfWire
+			skippy, err := skipSerializations(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	return nil
+}
+func (m *Quad) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			postIndex := iNdEx + int(stringLen)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Subject = string(data[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			postIndex := iNdEx + int(stringLen)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Predicate = string(data[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			postIndex := iNdEx + int(stringLen)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Object = string(data[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			postIndex := iNdEx + int(stringLen)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Label = string(data[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			var sizeOfWire int
+			for {
+				sizeOfWire++
+				wire >>= 7
+				if wire == 0 {
+					break
+				}
+			}
+			iNdEx -= sizeOfWire
+			skippy, err := skipSerializations(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	return nil
+}
+func skipSerializations(data []byte) (n int, err error) {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for {
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if data[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			return iNdEx, nil
+		case 3:
+			for {
+				var wire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := data[iNdEx]
+					iNdEx++
+					wire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				wireType := int(wire & 0x7)
+				if wireType == 4 {
+					break
+				}
+				next, err := skipSerializations(data[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+func (m *LogDelta) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovSerializations(uint64(m.ID))
+	}
+	l = m.Quad.Size()
+	n += 1 + l + sovSerializations(uint64(l))
+	if m.Action != 0 {
+		n += 1 + sovSerializations(uint64(m.Action))
+	}
+	if m.Timestamp != 0 {
+		n += 1 + sovSerializations(uint64(m.Timestamp))
+	}
+	return n
+}
+
+func (m *HistoryEntry) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.History) > 0 {
+		for _, e := range m.History {
+			n += 1 + sovSerializations(uint64(e))
+		}
+	}
+	return n
+}
+
+func (m *NodeData) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovSerializations(uint64(l))
+	}
+	if m.Size_ != 0 {
+		n += 1 + sovSerializations(uint64(m.Size_))
+	}
+	return n
+}
+
+func (m *Quad) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Subject)
+	if l > 0 {
+		n += 1 + l + sovSerializations(uint64(l))
+	}
+	l = len(m.Predicate)
+	if l > 0 {
+		n += 1 + l + sovSerializations(uint64(l))
+	}
+	l = len(m.Object)
+	if l > 0 {
+		n += 1 + l + sovSerializations(uint64(l))
+	}
+	l = len(m.Label)
+	if l > 0 {
+		n += 1 + l + sovSerializations(uint64(l))
+	}
+	return n
+}
+
+func sovSerializations(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozSerializations(x uint64) (n int) {
+	return sovSerializations(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *LogDelta) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *LogDelta) MarshalTo(data []byte) (n int, err error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		data[i] = 0x8
+		i++
+		i = encodeVarintSerializations(data, i, uint64(m.ID))
+	}
+	data[i] = 0x12
+	i++
+	i = encodeVarintSerializations(data, i, uint64(m.Quad.Size()))
+	n1, err := m.Quad.MarshalTo(data[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n1
+	if m.Action != 0 {
+		data[i] = 0x18
+		i++
+		i = encodeVarintSerializations(data, i, uint64(m.Action))
+	}
+	if m.Timestamp != 0 {
+		data[i] = 0x20
+		i++
+		i = encodeVarintSerializations(data, i, uint64(m.Timestamp))
+	}
+	return i, nil
+}
+
+func (m *HistoryEntry) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *HistoryEntry) MarshalTo(data []byte) (n int, err error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.History) > 0 {
+		for _, num := range m.History {
+			data[i] = 0x8
+			i++
+			i = encodeVarintSerializations(data, i, uint64(num))
+		}
+	}
+	return i, nil
+}
+
+func (m *NodeData) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *NodeData) MarshalTo(data []byte) (n int, err error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		data[i] = 0xa
+		i++
+		i = encodeVarintSerializations(data, i, uint64(len(m.Name)))
+		i += copy(data[i:], m.Name)
+	}
+	if m.Size_ != 0 {
+		data[i] = 0x10
+		i++
+		i = encodeVarintSerializations(data, i, uint64(m.Size_))
+	}
+	return i, nil
+}
+
+func (m *Quad) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *Quad) MarshalTo(data []byte) (n int, err error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Subject) > 0 {
+		data[i] = 0xa
+		i++
+		i = encodeVarintSerializations(data, i, uint64(len(m.Subject)))
+		i += copy(data[i:], m.Subject)
+	}
+	if len(m.Predicate) > 0 {
+		data[i] = 0x12
+		i++
+		i = encodeVarintSerializations(data, i, uint64(len(m.Predicate)))
+		i += copy(data[i:], m.Predicate)
+	}
+	if len(m.Object) > 0 {
+		data[i] = 0x1a
+		i++
+		i = encodeVarintSerializations(data, i, uint64(len(m.Object)))
+		i += copy(data[i:], m.Object)
+	}
+	if len(m.Label) > 0 {
+		data[i] = 0x22
+		i++
+		i = encodeVarintSerializations(data, i, uint64(len(m.Label)))
+		i += copy(data[i:], m.Label)
+	}
+	return i, nil
+}
+
+func encodeFixed64Serializations(data []byte, offset int, v uint64) int {
+	data[offset] = uint8(v)
+	data[offset+1] = uint8(v >> 8)
+	data[offset+2] = uint8(v >> 16)
+	data[offset+3] = uint8(v >> 24)
+	data[offset+4] = uint8(v >> 32)
+	data[offset+5] = uint8(v >> 40)
+	data[offset+6] = uint8(v >> 48)
+	data[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Serializations(data []byte, offset int, v uint32) int {
+	data[offset] = uint8(v)
+	data[offset+1] = uint8(v >> 8)
+	data[offset+2] = uint8(v >> 16)
+	data[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintSerializations(data []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		data[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	data[offset] = uint8(v)
+	return offset + 1
+}
diff --git a/vendor/github.com/google/cayley/graph/proto/serializations.proto b/vendor/github.com/google/cayley/graph/proto/serializations.proto
new file mode 100644
index 00000000..ee8295d3
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/proto/serializations.proto
@@ -0,0 +1,43 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package proto;
+
+message LogDelta {
+  uint64 ID = 1;
+  Quad Quad = 2;
+  int32 Action = 3;
+  int64 Timestamp = 4;
+}
+
+message HistoryEntry {
+  repeated uint64 History = 1;
+}
+
+message NodeData {
+  string Name = 1;
+  int64 Size = 2;
+}
+
+message Quad {
+  string subject = 1;
+  string predicate = 2;
+  string object = 3;
+  string label = 4;
+}
+
+
+
diff --git a/vendor/github.com/google/cayley/graph/quadstore.go b/vendor/github.com/google/cayley/graph/quadstore.go
new file mode 100644
index 00000000..04b5c375
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/quadstore.go
@@ -0,0 +1,220 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package graph
+
+// Defines the QuadStore interface. Every backing store must implement at
+// least this interface.
+//
+// Most of these are pretty straightforward. As long as we can surface this
+// interface, the rest of the stack will "just work" and we can connect to any
+// quad backing store we prefer.
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/google/cayley/quad"
+)
+
+// Value defines an opaque "quad store value" type. However the backend wishes
+// to implement it, a Value is merely a token to a quad or a node that the
+// backing store itself understands, and the base iterators pass around.
+//
+// For example, in a very traditional, graphd-style graph, these are int64s
+// (guids of the primitives). In a very direct sort of graph, these could be
+// pointers to structs, or merely quads, or whatever works best for the
+// backing store.
+//
+// These must be comparable, or implement a `Key() interface{}` function
+// so that they may be stored in maps.
+type Value interface{}
+
+type QuadStore interface {
+	// The only way in is through building a transaction, which
+	// is done by a replication strategy.
+	ApplyDeltas([]Delta, IgnoreOpts) error
+
+	// Given an opaque token, returns the quad for that token from the store.
+	Quad(Value) quad.Quad
+
+	// Given a direction and a token, creates an iterator of links which have
+	// that node token in that directional field.
+	QuadIterator(quad.Direction, Value) Iterator
+
+	// Returns an iterator enumerating all nodes in the graph.
+	NodesAllIterator() Iterator
+
+	// Returns an iterator enumerating all links in the graph.
+	QuadsAllIterator() Iterator
+
+	// Given a node ID, return the opaque token used by the QuadStore
+	// to represent that id.
+	ValueOf(string) Value
+
+	// Given an opaque token, return the node that it represents.
+	NameOf(Value) string
+
+	// Returns the number of quads currently stored.
+	Size() int64
+
+	// The last replicated transaction ID that this quadstore has verified.
+	Horizon() PrimaryKey
+
+	// Creates a fixed iterator which can compare Values
+	FixedIterator() FixedIterator
+
+	// Optimize an iterator in the context of the quad store.
+	// Suppose we have a better index for the passed tree; this
+	// gives the QuadStore the opportunity to replace it
+	// with a more efficient iterator.
+	OptimizeIterator(it Iterator) (Iterator, bool)
+
+	// Close the quad store and clean up. (Flush to disk, cleanly
+	// sever connections, etc)
+	Close()
+
+	// Convenience function for speed. Given a quad token and a direction
+	// return the node token for that direction. Sometimes, a QuadStore
+	// can do this without going all the way to the backing store, and
+	// gives the QuadStore the opportunity to make this optimization.
+	//
+	// Iterators will call this. At worst, a valid implementation is
+	//
+	//  qs.ValueOf(qs.Quad(id).Get(dir))
+	//
+	QuadDirection(id Value, d quad.Direction) Value
+
+	// Get the type of QuadStore
+	//TODO replace this using reflection
+	Type() string
+}
+
+type Options map[string]interface{}
+
+func (d Options) IntKey(key string) (int, bool, error) {
+	if val, ok := d[key]; ok {
+		switch vv := val.(type) {
+		case float64:
+			return int(vv), true, nil
+		default:
+			return 0, false, fmt.Errorf("Invalid %s parameter type from config: %T", key, val)
+		}
+	}
+	return 0, false, nil
+}
+
+func (d Options) StringKey(key string) (string, bool, error) {
+	if val, ok := d[key]; ok {
+		switch vv := val.(type) {
+		case string:
+			return vv, true, nil
+		default:
+			return "", false, fmt.Errorf("Invalid %s parameter type from config: %T", key, val)
+		}
+	}
+	return "", false, nil
+}
+
+func (d Options) BoolKey(key string) (bool, bool, error) {
+	if val, ok := d[key]; ok {
+		switch vv := val.(type) {
+		case bool:
+			return vv, true, nil
+		default:
+			return false, false, fmt.Errorf("Invalid %s parameter type from config: %T", key, val)
+		}
+	}
+	return false, false, nil
+}
+
+var ErrCannotBulkLoad = errors.New("quadstore: cannot bulk load")
+
+type BulkLoader interface {
+	// BulkLoad loads Quads from a quad.Unmarshaler in bulk to the QuadStore.
+	// It returns ErrCannotBulkLoad if bulk loading is not possible. For example if
+	// you cannot load in bulk to a non-empty database, and the db is non-empty.
+	BulkLoad(quad.Unmarshaler) error
+}
+
+type NewStoreFunc func(string, Options) (QuadStore, error)
+type InitStoreFunc func(string, Options) error
+type UpgradeStoreFunc func(string, Options) error
+type NewStoreForRequestFunc func(QuadStore, Options) (QuadStore, error)
+
+type QuadStoreRegistration struct {
+	NewFunc           NewStoreFunc
+	NewForRequestFunc NewStoreForRequestFunc
+	UpgradeFunc       UpgradeStoreFunc
+	InitFunc          InitStoreFunc
+	IsPersistent      bool
+}
+
+var storeRegistry = make(map[string]QuadStoreRegistration)
+
+func RegisterQuadStore(name string, register QuadStoreRegistration) {
+	if _, found := storeRegistry[name]; found {
+		panic("already registered QuadStore " + name)
+	}
+	storeRegistry[name] = register
+}
+
+func NewQuadStore(name, dbpath string, opts Options) (QuadStore, error) {
+	r, registered := storeRegistry[name]
+	if !registered {
+		return nil, errors.New("quadstore: name '" + name + "' is not registered")
+	}
+	return r.NewFunc(dbpath, opts)
+}
+
+func InitQuadStore(name, dbpath string, opts Options) error {
+	r, registered := storeRegistry[name]
+	if registered {
+		return r.InitFunc(dbpath, opts)
+	}
+	return errors.New("quadstore: name '" + name + "' is not registered")
+}
+
+func NewQuadStoreForRequest(qs QuadStore, opts Options) (QuadStore, error) {
+	r, registered := storeRegistry[qs.Type()]
+	if registered {
+		return r.NewForRequestFunc(qs, opts)
+	}
+	return nil, errors.New("QuadStore does not support Per Request construction, check config")
+}
+
+func UpgradeQuadStore(name, dbpath string, opts Options) error {
+	r, registered := storeRegistry[name]
+	if registered {
+		if r.UpgradeFunc != nil {
+			return r.UpgradeFunc(dbpath, opts)
+		} else {
+			return nil
+		}
+	}
+	return errors.New("quadstore: name '" + name + "' is not registered")
+
+}
+
+func IsPersistent(name string) bool {
+	return storeRegistry[name].IsPersistent
+}
+
+func QuadStores() []string {
+	t := make([]string, 0, len(storeRegistry))
+	for n := range storeRegistry {
+		t = append(t, n)
+	}
+	return t
+}
diff --git a/vendor/github.com/google/cayley/graph/quadwriter.go b/vendor/github.com/google/cayley/graph/quadwriter.go
new file mode 100644
index 00000000..9c4d3810
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/quadwriter.go
@@ -0,0 +1,115 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package graph
+
+// Defines the interface for consistent replication of a graph instance.
+//
+// Separate from the backend, this dictates how individual quads get
+// identified and replicated consistently across (potentially) multiple
+// instances. The simplest case is to keep an append-only log of quad
+// changes.
+
+import (
+	"errors"
+	"flag"
+	"time"
+
+	"github.com/google/cayley/quad"
+)
+
+type Procedure int8
+
+// The different types of actions a transaction can do.
+const (
+	Add    Procedure = +1
+	Delete Procedure = -1
+)
+
+type Delta struct {
+	ID        PrimaryKey
+	Quad      quad.Quad
+	Action    Procedure
+	Timestamp time.Time
+}
+
+type Handle struct {
+	QuadStore
+	QuadWriter
+}
+
+type IgnoreOpts struct {
+	IgnoreDup, IgnoreMissing bool
+}
+
+func (h *Handle) Close() {
+	h.QuadStore.Close()
+	h.QuadWriter.Close()
+}
+
+var (
+	ErrQuadExists   = errors.New("quad exists")
+	ErrQuadNotExist = errors.New("quad does not exist")
+)
+
+var (
+	IgnoreDup     = flag.Bool("ignoredup", false, "Don't stop loading on duplicated key on add")
+	IgnoreMissing = flag.Bool("ignoremissing", false, "Don't stop loading on missing key on delete")
+)
+
+type QuadWriter interface {
+	// Add a quad to the store.
+	AddQuad(quad.Quad) error
+
+	// TODO(barakmich): Deprecate in favor of transaction.
+	// Add a set of quads to the store, atomically if possible.
+	AddQuadSet([]quad.Quad) error
+
+	// Removes a quad matching the given one  from the database,
+	// if it exists. Does nothing otherwise.
+	RemoveQuad(quad.Quad) error
+
+	// Apply a set of quad changes
+	ApplyTransaction(*Transaction) error
+
+	// Cleans up replication and closes the writing aspect of the database.
+	Close() error
+}
+
+type NewQuadWriterFunc func(QuadStore, Options) (QuadWriter, error)
+
+var writerRegistry = make(map[string]NewQuadWriterFunc)
+
+func RegisterWriter(name string, newFunc NewQuadWriterFunc) {
+	if _, found := writerRegistry[name]; found {
+		panic("already registered QuadWriter " + name)
+	}
+	writerRegistry[name] = newFunc
+}
+
+func NewQuadWriter(name string, qs QuadStore, opts Options) (QuadWriter, error) {
+	newFunc, hasNew := writerRegistry[name]
+	if !hasNew {
+		return nil, errors.New("replication: name '" + name + "' is not registered")
+	}
+	return newFunc(qs, opts)
+}
+
+func WriterMethods() []string {
+	t := make([]string, 0, len(writerRegistry))
+	for n := range writerRegistry {
+		t = append(t, n)
+	}
+	return t
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/all_iterator.go b/vendor/github.com/google/cayley/graph/sql/all_iterator.go
new file mode 100644
index 00000000..c91c65d7
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/all_iterator.go
@@ -0,0 +1,215 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"database/sql"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+type AllIterator struct {
+	uid    uint64
+	tags   graph.Tagger
+	qs     *QuadStore
+	dir    quad.Direction
+	val    graph.Value
+	table  string
+	cursor *sql.Rows
+	result graph.Value
+	err    error
+}
+
+func (it *AllIterator) makeCursor() {
+	var cursor *sql.Rows
+	var err error
+	if it.cursor != nil {
+		it.cursor.Close()
+	}
+	if it.table == "quads" {
+		cursor, err = it.qs.db.Query(`SELECT subject, predicate, object, label FROM quads;`)
+		if err != nil {
+			glog.Errorln("Couldn't get cursor from SQL database: %v", err)
+			cursor = nil
+		}
+	} else {
+		glog.V(4).Infoln("sql: getting node query")
+		cursor, err = it.qs.db.Query(`SELECT node FROM
+			(
+				SELECT subject FROM quads
+				UNION
+				SELECT predicate FROM quads
+				UNION
+				SELECT object FROM quads
+				UNION
+				SELECT label FROM quads
+			) AS DistinctNodes (node) WHERE node IS NOT NULL;`)
+		if err != nil {
+			glog.Errorln("Couldn't get cursor from SQL database: %v", err)
+			cursor = nil
+		}
+		glog.V(4).Infoln("sql: got node query")
+	}
+	it.cursor = cursor
+}
+
+func NewAllIterator(qs *QuadStore, table string) *AllIterator {
+	it := &AllIterator{
+		uid:   iterator.NextUID(),
+		qs:    qs,
+		table: table,
+	}
+	return it
+}
+
+func (it *AllIterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *AllIterator) Reset() {
+	it.err = nil
+	it.Close()
+}
+
+func (it *AllIterator) Err() error {
+	return it.err
+}
+
+func (it *AllIterator) Close() error {
+	if it.cursor != nil {
+		err := it.cursor.Close()
+		if err != nil {
+			return err
+		}
+		it.cursor = nil
+	}
+	return nil
+}
+
+func (it *AllIterator) Tagger() *graph.Tagger {
+	return &it.tags
+}
+
+func (it *AllIterator) TagResults(dst map[string]graph.Value) {
+	for _, tag := range it.tags.Tags() {
+		dst[tag] = it.Result()
+	}
+
+	for tag, value := range it.tags.Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *AllIterator) Clone() graph.Iterator {
+	var m *AllIterator
+	m = NewAllIterator(it.qs, it.table)
+	m.tags.CopyFrom(it)
+	return m
+}
+
+func (it *AllIterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *AllIterator) Next() bool {
+	graph.NextLogIn(it)
+	if it.cursor == nil {
+		it.makeCursor()
+		if it.cursor == nil {
+			return false
+		}
+	}
+	if !it.cursor.Next() {
+		glog.V(4).Infoln("sql: No next")
+		err := it.cursor.Err()
+		if err != nil {
+			glog.Errorf("Cursor error in SQL: %v", err)
+			it.err = err
+		}
+		it.cursor.Close()
+		return false
+	}
+	if it.table == "nodes" {
+		var node string
+		err := it.cursor.Scan(&node)
+		if err != nil {
+			glog.Errorf("Error nexting node iterator: %v", err)
+			it.err = err
+			return false
+		}
+		it.result = node
+		return true
+	}
+	var q quad.Quad
+	err := it.cursor.Scan(&q.Subject, &q.Predicate, &q.Object, &q.Label)
+	if err != nil {
+		glog.Errorf("Error scanning sql iterator: %v", err)
+		it.err = err
+		return false
+	}
+	it.result = q
+	return graph.NextLogOut(it, it.result, true)
+}
+
+func (it *AllIterator) Contains(v graph.Value) bool {
+	graph.ContainsLogIn(it, v)
+	it.result = v
+	return graph.ContainsLogOut(it, v, true)
+}
+
+func (it *AllIterator) Size() (int64, bool) {
+	return it.qs.Size(), true
+}
+
+func (it *AllIterator) Result() graph.Value {
+	if it.result == nil {
+		glog.Fatalln("result was nil", it)
+	}
+	return it.result
+}
+
+func (it *AllIterator) NextPath() bool {
+	return false
+}
+
+func (it *AllIterator) Type() graph.Type {
+	return graph.All
+}
+
+func (it *AllIterator) Sorted() bool                     { return false }
+func (it *AllIterator) Optimize() (graph.Iterator, bool) { return it, false }
+
+func (it *AllIterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:  it.UID(),
+		Name: "sql/all",
+		Type: it.Type(),
+		Size: size,
+	}
+}
+
+func (it *AllIterator) Stats() graph.IteratorStats {
+	size, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     9999,
+		Size:         size,
+	}
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/lru.go b/vendor/github.com/google/cayley/graph/sql/lru.go
new file mode 100644
index 00000000..e3aca7f0
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/lru.go
@@ -0,0 +1,63 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"container/list"
+)
+
+// cache implements an LRU cache.
+type cache struct {
+	cache    map[string]*list.Element
+	priority *list.List
+	maxSize  int
+}
+
+type kv struct {
+	key   string
+	value int64
+}
+
+func newCache(size int) *cache {
+	var lru cache
+	lru.maxSize = size
+	lru.priority = list.New()
+	lru.cache = make(map[string]*list.Element)
+	return &lru
+}
+
+func (lru *cache) Put(key string, value int64) {
+	if _, ok := lru.Get(key); ok {
+		return
+	}
+	if len(lru.cache) == lru.maxSize {
+		lru.removeOldest()
+	}
+	lru.priority.PushFront(kv{key: key, value: value})
+	lru.cache[key] = lru.priority.Front()
+}
+
+func (lru *cache) Get(key string) (int64, bool) {
+	if element, ok := lru.cache[key]; ok {
+		lru.priority.MoveToFront(element)
+		return element.Value.(kv).value, true
+	}
+	return 0, false
+}
+
+func (lru *cache) removeOldest() {
+	last := lru.priority.Remove(lru.priority.Back())
+	delete(lru.cache, last.(kv).key)
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/optimizers.go b/vendor/github.com/google/cayley/graph/sql/optimizers.go
new file mode 100644
index 00000000..4a10c820
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/optimizers.go
@@ -0,0 +1,325 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"errors"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+func intersect(a sqlIterator, b sqlIterator, qs *QuadStore) (*SQLIterator, error) {
+	if anew, ok := a.(*SQLNodeIterator); ok {
+		if bnew, ok := b.(*SQLNodeIterator); ok {
+			return intersectNode(anew, bnew, qs)
+		}
+		if bnew, ok := b.(*SQLNodeIntersection); ok {
+			return appendNodeIntersection(bnew, anew, qs)
+		}
+	} else if anew, ok := a.(*SQLNodeIntersection); ok {
+		if bnew, ok := b.(*SQLNodeIterator); ok {
+			return appendNodeIntersection(anew, bnew, qs)
+		}
+		if bnew, ok := b.(*SQLNodeIntersection); ok {
+			return combineNodeIntersection(anew, bnew, qs)
+		}
+	} else if anew, ok := a.(*SQLLinkIterator); ok {
+		if bnew, ok := b.(*SQLLinkIterator); ok {
+			return intersectLink(anew, bnew, qs)
+		}
+
+	} else {
+		return nil, errors.New("Unknown iterator types")
+	}
+	return nil, errors.New("Cannot combine SQL iterators of two different types")
+}
+
+func intersectNode(a *SQLNodeIterator, b *SQLNodeIterator, qs *QuadStore) (*SQLIterator, error) {
+	m := &SQLNodeIntersection{
+		tableName: newTableName(),
+		nodeIts:   []sqlIterator{a, b},
+	}
+	m.Tagger().CopyFromTagger(a.Tagger())
+	m.Tagger().CopyFromTagger(b.Tagger())
+	it := NewSQLIterator(qs, m)
+	return it, nil
+}
+
+func appendNodeIntersection(a *SQLNodeIntersection, b *SQLNodeIterator, qs *QuadStore) (*SQLIterator, error) {
+	m := &SQLNodeIntersection{
+		tableName: newTableName(),
+		nodeIts:   append(a.nodeIts, b),
+	}
+	m.Tagger().CopyFromTagger(a.Tagger())
+	m.Tagger().CopyFromTagger(b.Tagger())
+	it := NewSQLIterator(qs, m)
+	return it, nil
+}
+
+func combineNodeIntersection(a *SQLNodeIntersection, b *SQLNodeIntersection, qs *QuadStore) (*SQLIterator, error) {
+	m := &SQLNodeIntersection{
+		tableName: newTableName(),
+		nodeIts:   append(a.nodeIts, b.nodeIts...),
+	}
+	m.Tagger().CopyFromTagger(a.Tagger())
+	m.Tagger().CopyFromTagger(b.Tagger())
+	it := NewSQLIterator(qs, m)
+	return it, nil
+}
+
+func intersectLink(a *SQLLinkIterator, b *SQLLinkIterator, qs *QuadStore) (*SQLIterator, error) {
+	m := &SQLLinkIterator{
+		tableName:   newTableName(),
+		nodeIts:     append(a.nodeIts, b.nodeIts...),
+		constraints: append(a.constraints, b.constraints...),
+		tagdirs:     append(a.tagdirs, b.tagdirs...),
+	}
+	m.Tagger().CopyFromTagger(a.Tagger())
+	m.Tagger().CopyFromTagger(b.Tagger())
+	it := NewSQLIterator(qs, m)
+	return it, nil
+}
+
+func hasa(aIn sqlIterator, d quad.Direction, qs *QuadStore) (*SQLIterator, error) {
+	a, ok := aIn.(*SQLLinkIterator)
+	if !ok {
+		return nil, errors.New("Can't take the HASA of a link SQL iterator")
+	}
+
+	out := &SQLNodeIterator{
+		tableName: newTableName(),
+		linkIt: sqlItDir{
+			it:  a,
+			dir: d,
+		},
+	}
+	it := NewSQLIterator(qs, out)
+	return it, nil
+}
+
+func linksto(aIn sqlIterator, d quad.Direction, qs *QuadStore) (*SQLIterator, error) {
+	var a sqlIterator
+	a, ok := aIn.(*SQLNodeIterator)
+	if !ok {
+		a, ok = aIn.(*SQLNodeIntersection)
+		if !ok {
+			return nil, errors.New("Can't take the LINKSTO of a node SQL iterator")
+		}
+	}
+
+	out := &SQLLinkIterator{
+		tableName: newTableName(),
+		nodeIts: []sqlItDir{
+			sqlItDir{
+				it:  a,
+				dir: d,
+			},
+		},
+	}
+	it := NewSQLIterator(qs, out)
+	return it, nil
+}
+
+func (qs *QuadStore) OptimizeIterator(it graph.Iterator) (graph.Iterator, bool) {
+	switch it.Type() {
+	case graph.LinksTo:
+		return qs.optimizeLinksTo(it.(*iterator.LinksTo))
+	case graph.HasA:
+		return qs.optimizeHasA(it.(*iterator.HasA))
+	case graph.And:
+		return qs.optimizeAnd(it.(*iterator.And))
+	}
+	return it, false
+}
+
+func (qs *QuadStore) optimizeLinksTo(it *iterator.LinksTo) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	if len(subs) != 1 {
+		return it, false
+	}
+	primary := subs[0]
+	switch primary.Type() {
+	case graph.Fixed:
+		size, _ := primary.Size()
+		if size == 0 {
+			return iterator.NewNull(), true
+		}
+		if size == 1 {
+			if !graph.Next(primary) {
+				panic("sql: unexpected size during optimize")
+			}
+			val := primary.Result()
+			newIt := qs.QuadIterator(it.Direction(), val)
+			nt := newIt.Tagger()
+			nt.CopyFrom(it)
+			for _, tag := range primary.Tagger().Tags() {
+				nt.AddFixed(tag, val)
+			}
+			it.Close()
+			return newIt, true
+		} else if size > 1 {
+			var vals []string
+			for graph.Next(primary) {
+				vals = append(vals, qs.NameOf(primary.Result()))
+			}
+			lsql := &SQLLinkIterator{
+				constraints: []constraint{
+					constraint{
+						dir:  it.Direction(),
+						vals: vals,
+					},
+				},
+				tableName: newTableName(),
+				size:      0,
+			}
+			l := &SQLIterator{
+				uid: iterator.NextUID(),
+				qs:  qs,
+				sql: lsql,
+			}
+			nt := l.Tagger()
+			nt.CopyFrom(it)
+			for _, t := range primary.Tagger().Tags() {
+				lsql.tagdirs = append(lsql.tagdirs, tagDir{
+					dir: it.Direction(),
+					tag: t,
+				})
+			}
+			it.Close()
+			return l, true
+		}
+	case sqlType:
+		p := primary.(*SQLIterator)
+		newit, err := linksto(p.sql, it.Direction(), qs)
+		if err != nil {
+			glog.Errorln(err)
+			return it, false
+		}
+		newit.Tagger().CopyFrom(it)
+		return newit, true
+	case graph.All:
+		linkit := &SQLLinkIterator{
+			tableName: newTableName(),
+			size:      qs.Size(),
+		}
+		for _, t := range primary.Tagger().Tags() {
+			linkit.tagdirs = append(linkit.tagdirs, tagDir{
+				dir: it.Direction(),
+				tag: t,
+			})
+		}
+		for k, v := range primary.Tagger().Fixed() {
+			linkit.tagger.AddFixed(k, v)
+		}
+		linkit.tagger.CopyFrom(it)
+		newit := NewSQLIterator(qs, linkit)
+		return newit, true
+	}
+	return it, false
+}
+
+func (qs *QuadStore) optimizeAnd(it *iterator.And) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	var unusedIts []graph.Iterator
+	var newit *SQLIterator
+	newit = nil
+	changed := false
+	var err error
+
+	// Combine SQL iterators
+	glog.V(4).Infof("Combining SQL %#v", subs)
+	for _, subit := range subs {
+		if subit.Type() == sqlType {
+			if newit == nil {
+				newit = subit.(*SQLIterator)
+			} else {
+				changed = true
+				newit, err = intersect(newit.sql, subit.(*SQLIterator).sql, qs)
+				if err != nil {
+					glog.Error(err)
+					return it, false
+				}
+			}
+		} else {
+			unusedIts = append(unusedIts, subit)
+		}
+	}
+
+	if newit == nil {
+		return it, false
+	}
+
+	// Combine fixed iterators into the SQL iterators.
+	glog.V(4).Infof("Combining fixed %#v", unusedIts)
+	var nodeit *SQLNodeIterator
+	if n, ok := newit.sql.(*SQLNodeIterator); ok {
+		nodeit = n
+	} else if n, ok := newit.sql.(*SQLNodeIntersection); ok {
+		nodeit = n.nodeIts[0].(*SQLNodeIterator)
+	}
+	if nodeit != nil {
+		passOneIts := unusedIts
+		unusedIts = nil
+		for _, subit := range passOneIts {
+			if subit.Type() != graph.Fixed {
+				unusedIts = append(unusedIts, subit)
+				continue
+			}
+			changed = true
+			for graph.Next(subit) {
+				nodeit.fixedSet = append(nodeit.fixedSet, qs.NameOf(subit.Result()))
+			}
+		}
+	}
+
+	if !changed {
+		return it, false
+	}
+
+	// Clean up if we're done.
+	if len(unusedIts) == 0 {
+		newit.Tagger().CopyFrom(it)
+		return newit, true
+	}
+	newAnd := iterator.NewAnd(qs)
+	newAnd.Tagger().CopyFrom(it)
+	newAnd.AddSubIterator(newit)
+	for _, i := range unusedIts {
+		newAnd.AddSubIterator(i)
+	}
+	return newAnd.Optimize()
+}
+
+func (qs *QuadStore) optimizeHasA(it *iterator.HasA) (graph.Iterator, bool) {
+	subs := it.SubIterators()
+	if len(subs) != 1 {
+		return it, false
+	}
+	primary := subs[0]
+	if primary.Type() == sqlType {
+		p := primary.(*SQLIterator)
+		newit, err := hasa(p.sql, it.Direction(), qs)
+		if err != nil {
+			glog.Errorln(err)
+			return it, false
+		}
+		newit.Tagger().CopyFrom(it)
+		return newit, true
+	}
+	return it, false
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/quadstore.go b/vendor/github.com/google/cayley/graph/sql/quadstore.go
new file mode 100644
index 00000000..a24d48e5
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/quadstore.go
@@ -0,0 +1,349 @@
+package sql
+
+import (
+	"crypto/sha1"
+	"database/sql"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"hash"
+	"sync"
+
+	"github.com/lib/pq"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+const QuadStoreType = "sql"
+
+func init() {
+	graph.RegisterQuadStore(QuadStoreType, graph.QuadStoreRegistration{
+		NewFunc:           newQuadStore,
+		NewForRequestFunc: nil,
+		UpgradeFunc:       nil,
+		InitFunc:          createSQLTables,
+		IsPersistent:      true,
+	})
+}
+
+var (
+	hashPool = sync.Pool{
+		New: func() interface{} { return sha1.New() },
+	}
+	hashSize = sha1.Size
+)
+
+type QuadStore struct {
+	db        *sql.DB
+	sqlFlavor string
+	size      int64
+	lru       *cache
+	noSizes   bool
+}
+
+func connectSQLTables(addr string, _ graph.Options) (*sql.DB, error) {
+	// TODO(barakmich): Parse options for more friendly addr, other SQLs.
+	conn, err := sql.Open("postgres", addr)
+	if err != nil {
+		glog.Errorf("Couldn't open database at %s: %#v", addr, err)
+		return nil, err
+	}
+	// "Open may just validate its arguments without creating a connection to the database."
+	// "To verify that the data source name is valid, call Ping."
+	// Source: http://golang.org/pkg/database/sql/#Open
+	if err := conn.Ping(); err != nil {
+		glog.Errorf("Couldn't open database at %s: %#v", addr, err)
+		return nil, err
+	}
+	return conn, nil
+}
+
+func createSQLTables(addr string, options graph.Options) error {
+	conn, err := connectSQLTables(addr, options)
+	if err != nil {
+		return err
+	}
+	tx, err := conn.Begin()
+	if err != nil {
+		glog.Errorf("Couldn't begin creation transaction: %s", err)
+		return err
+	}
+
+	quadTable, err := tx.Exec(`
+	CREATE TABLE quads (
+		subject TEXT NOT NULL,
+		predicate TEXT NOT NULL,
+		object TEXT NOT NULL,
+		label TEXT,
+		horizon BIGSERIAL PRIMARY KEY,
+		id BIGINT,
+		ts timestamp,
+		subject_hash TEXT NOT NULL,
+		predicate_hash TEXT NOT NULL,
+		object_hash TEXT NOT NULL,
+		label_hash TEXT,
+		UNIQUE(subject_hash, predicate_hash, object_hash, label_hash)
+	);`)
+	if err != nil {
+		glog.Errorf("Cannot create quad table: %v", quadTable)
+		return err
+	}
+	factor, factorOk, err := options.IntKey("db_fill_factor")
+	if !factorOk {
+		factor = 50
+	}
+	var index sql.Result
+
+	index, err = tx.Exec(fmt.Sprintf(`
+	CREATE INDEX spo_index ON quads (subject_hash) WITH (FILLFACTOR = %d);
+	CREATE INDEX pos_index ON quads (predicate_hash) WITH (FILLFACTOR = %d);
+	CREATE INDEX osp_index ON quads (object_hash) WITH (FILLFACTOR = %d);
+	`, factor, factor, factor))
+	if err != nil {
+		glog.Errorf("Cannot create indices: %v", index)
+		return err
+	}
+	tx.Commit()
+	return nil
+}
+
+func newQuadStore(addr string, options graph.Options) (graph.QuadStore, error) {
+	var qs QuadStore
+	conn, err := connectSQLTables(addr, options)
+	if err != nil {
+		return nil, err
+	}
+	localOpt, localOptOk, err := options.BoolKey("local_optimize")
+	if err != nil {
+		return nil, err
+	}
+	qs.db = conn
+	qs.sqlFlavor = "postgres"
+	qs.size = -1
+	qs.lru = newCache(1024)
+
+	// Skip size checking by default.
+	qs.noSizes = true
+	if localOptOk {
+		if localOpt {
+			qs.noSizes = false
+		}
+	}
+	return &qs, nil
+}
+
+func hashOf(s string) string {
+	h := hashPool.Get().(hash.Hash)
+	h.Reset()
+	defer hashPool.Put(h)
+	key := make([]byte, 0, hashSize)
+	h.Write([]byte(s))
+	key = h.Sum(key)
+	return hex.EncodeToString(key)
+}
+
+func (qs *QuadStore) copyFrom(tx *sql.Tx, in []graph.Delta) error {
+	stmt, err := tx.Prepare(pq.CopyIn("quads", "subject", "predicate", "object", "label", "id", "ts", "subject_hash", "predicate_hash", "object_hash", "label_hash"))
+	if err != nil {
+		return err
+	}
+	for _, d := range in {
+		_, err := stmt.Exec(
+			d.Quad.Subject,
+			d.Quad.Predicate,
+			d.Quad.Object,
+			d.Quad.Label,
+			d.ID.Int(),
+			d.Timestamp,
+			hashOf(d.Quad.Subject),
+			hashOf(d.Quad.Predicate),
+			hashOf(d.Quad.Object),
+			hashOf(d.Quad.Label),
+		)
+		if err != nil {
+			glog.Errorf("couldn't prepare COPY statement: %v", err)
+			return err
+		}
+	}
+	_, err = stmt.Exec()
+	if err != nil {
+		return err
+	}
+	return stmt.Close()
+}
+
+func (qs *QuadStore) runTxPostgres(tx *sql.Tx, in []graph.Delta, opts graph.IgnoreOpts) error {
+	allAdds := true
+	for _, d := range in {
+		if d.Action != graph.Add {
+			allAdds = false
+		}
+	}
+	if allAdds {
+		return qs.copyFrom(tx, in)
+	}
+
+	insert, err := tx.Prepare(`INSERT INTO quads(subject, predicate, object, label, id, ts, subject_hash, predicate_hash, object_hash, label_hash) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`)
+	defer insert.Close()
+	if err != nil {
+		glog.Errorf("Cannot prepare insert statement: %v", err)
+		return err
+	}
+	for _, d := range in {
+		switch d.Action {
+		case graph.Add:
+			_, err := insert.Exec(
+				d.Quad.Subject,
+				d.Quad.Predicate,
+				d.Quad.Object,
+				d.Quad.Label,
+				d.ID.Int(),
+				d.Timestamp,
+				hashOf(d.Quad.Subject),
+				hashOf(d.Quad.Predicate),
+				hashOf(d.Quad.Object),
+				hashOf(d.Quad.Label),
+			)
+			if err != nil {
+				glog.Errorf("couldn't prepare INSERT statement: %v", err)
+				return err
+			}
+		case graph.Delete:
+			result, err := tx.Exec(`DELETE FROM quads WHERE subject=$1 and predicate=$2 and object=$3 and label=$4;`,
+				d.Quad.Subject, d.Quad.Predicate, d.Quad.Object, d.Quad.Label)
+			if err != nil {
+				glog.Errorf("couldn't exec DELETE statement: %v", err)
+				return err
+			}
+			affected, err := result.RowsAffected()
+			if err != nil {
+				glog.Errorf("couldn't get DELETE RowsAffected: %v", err)
+				return err
+			}
+			if affected != 1 && !opts.IgnoreMissing {
+				return errors.New("deleting non-existent triple; rolling back")
+			}
+		default:
+			panic("unknown action")
+		}
+	}
+	return nil
+}
+
+func (qs *QuadStore) ApplyDeltas(in []graph.Delta, opts graph.IgnoreOpts) error {
+	// TODO(barakmich): Support more ignoreOpts? "ON CONFLICT IGNORE"
+	tx, err := qs.db.Begin()
+	if err != nil {
+		glog.Errorf("couldn't begin write transaction: %v", err)
+		return err
+	}
+	switch qs.sqlFlavor {
+	case "postgres":
+		err = qs.runTxPostgres(tx, in, opts)
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+	default:
+		panic("no support for flavor: " + qs.sqlFlavor)
+	}
+	return tx.Commit()
+}
+
+func (qs *QuadStore) Quad(val graph.Value) quad.Quad {
+	return val.(quad.Quad)
+}
+
+func (qs *QuadStore) QuadIterator(d quad.Direction, val graph.Value) graph.Iterator {
+	return NewSQLLinkIterator(qs, d, val.(string))
+}
+
+func (qs *QuadStore) NodesAllIterator() graph.Iterator {
+	return NewAllIterator(qs, "nodes")
+}
+
+func (qs *QuadStore) QuadsAllIterator() graph.Iterator {
+	return NewAllIterator(qs, "quads")
+}
+
+func (qs *QuadStore) ValueOf(s string) graph.Value {
+	return s
+}
+
+func (qs *QuadStore) NameOf(v graph.Value) string {
+	if v == nil {
+		glog.V(2).Info("NameOf was nil")
+		return ""
+	}
+	return v.(string)
+}
+
+func (qs *QuadStore) Size() int64 {
+	// TODO(barakmich): Sync size with writes.
+	if qs.size != -1 {
+		return qs.size
+	}
+	c := qs.db.QueryRow("SELECT COUNT(*) FROM quads;")
+	err := c.Scan(&qs.size)
+	if err != nil {
+		glog.Errorf("Couldn't execute COUNT: %v", err)
+		return 0
+	}
+	return qs.size
+}
+
+func (qs *QuadStore) Horizon() graph.PrimaryKey {
+	var horizon int64
+	err := qs.db.QueryRow("SELECT horizon FROM quads ORDER BY horizon DESC LIMIT 1;").Scan(&horizon)
+	if err != nil {
+		glog.Errorf("Couldn't execute horizon: %v", err)
+		return graph.NewSequentialKey(0)
+	}
+	return graph.NewSequentialKey(horizon)
+}
+
+func (qs *QuadStore) FixedIterator() graph.FixedIterator {
+	return iterator.NewFixed(iterator.Identity)
+}
+
+func (qs *QuadStore) Close() {
+	qs.db.Close()
+}
+
+func (qs *QuadStore) QuadDirection(in graph.Value, d quad.Direction) graph.Value {
+	q := in.(quad.Quad)
+	return q.Get(d)
+}
+
+func (qs *QuadStore) Type() string {
+	return QuadStoreType
+}
+
+func (qs *QuadStore) sizeForIterator(isAll bool, dir quad.Direction, val string) int64 {
+	var err error
+	if isAll {
+		return qs.Size()
+	}
+	if qs.noSizes {
+		if dir == quad.Predicate {
+			return (qs.Size() / 100) + 1
+		}
+		return (qs.Size() / 1000) + 1
+	}
+	if val, ok := qs.lru.Get(val + string(dir.Prefix())); ok {
+		return val
+	}
+	var size int64
+	glog.V(4).Infoln("sql: getting size for select %s, %s", dir.String(), val)
+	err = qs.db.QueryRow(
+		fmt.Sprintf("SELECT count(*) FROM quads WHERE %s_hash = $1;", dir.String()), hashOf(val)).Scan(&size)
+	if err != nil {
+		glog.Errorln("Error getting size from SQL database: %v", err)
+		return 0
+	}
+	qs.lru.Put(val+string(dir.Prefix()), size)
+	return size
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/sql_iterator.go b/vendor/github.com/google/cayley/graph/sql/sql_iterator.go
new file mode 100644
index 00000000..79df5490
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/sql_iterator.go
@@ -0,0 +1,348 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+var sqlType graph.Type
+
+func init() {
+	sqlType = graph.RegisterIterator("sql")
+}
+
+type SQLIterator struct {
+	uid    uint64
+	qs     *QuadStore
+	cursor *sql.Rows
+	err    error
+
+	sql sqlIterator
+
+	result      map[string]string
+	resultIndex int
+	resultList  [][]string
+	resultNext  [][]string
+	cols        []string
+}
+
+func (it *SQLIterator) Clone() graph.Iterator {
+	m := &SQLIterator{
+		uid: iterator.NextUID(),
+		qs:  it.qs,
+		sql: it.sql.sqlClone(),
+	}
+	return m
+}
+
+func (it *SQLIterator) UID() uint64 {
+	return it.uid
+}
+
+func (it *SQLIterator) Reset() {
+	it.err = nil
+	it.Close()
+}
+
+func (it *SQLIterator) Err() error {
+	return it.err
+}
+
+func (it *SQLIterator) Close() error {
+	if it.cursor != nil {
+		err := it.cursor.Close()
+		if err != nil {
+			return err
+		}
+		it.cursor = nil
+	}
+	return nil
+}
+
+func (it *SQLIterator) Tagger() *graph.Tagger {
+	return it.sql.Tagger()
+}
+
+func (it *SQLIterator) Result() graph.Value {
+	return it.sql.Result()
+}
+
+func (it *SQLIterator) TagResults(dst map[string]graph.Value) {
+	for tag, value := range it.result {
+		if tag == "__execd" {
+			for _, tag := range it.Tagger().Tags() {
+				dst[tag] = value
+			}
+			continue
+		}
+		dst[tag] = value
+	}
+
+	for tag, value := range it.Tagger().Fixed() {
+		dst[tag] = value
+	}
+}
+
+func (it *SQLIterator) Type() graph.Type {
+	return sqlType
+}
+
+func (it *SQLIterator) SubIterators() []graph.Iterator {
+	return nil
+}
+
+func (it *SQLIterator) Sorted() bool                     { return false }
+func (it *SQLIterator) Optimize() (graph.Iterator, bool) { return it, false }
+
+func (it *SQLIterator) Size() (int64, bool) {
+	return it.sql.Size(it.qs)
+}
+
+func (it *SQLIterator) Describe() graph.Description {
+	size, _ := it.Size()
+	return graph.Description{
+		UID:  it.UID(),
+		Name: it.sql.Describe(),
+		Type: it.Type(),
+		Size: size,
+	}
+}
+
+func (it *SQLIterator) Stats() graph.IteratorStats {
+	size, _ := it.Size()
+	return graph.IteratorStats{
+		ContainsCost: 1,
+		NextCost:     5,
+		Size:         size,
+	}
+}
+
+func (it *SQLIterator) NextPath() bool {
+	it.resultIndex += 1
+	if it.resultIndex >= len(it.resultList) {
+		return false
+	}
+	it.buildResult(it.resultIndex)
+	return true
+}
+
+func (it *SQLIterator) Next() bool {
+	var err error
+	graph.NextLogIn(it)
+	if it.cursor == nil {
+		err = it.makeCursor(true, nil)
+		if err != nil {
+			glog.Errorf("Couldn't make query: %v", err)
+			it.err = err
+			return false
+		}
+		it.cols, err = it.cursor.Columns()
+		if err != nil {
+			glog.Errorf("Couldn't get columns")
+			it.err = err
+			it.cursor.Close()
+			return false
+		}
+		// iterate the first one
+		if !it.cursor.Next() {
+			glog.V(4).Infoln("sql: No next")
+			err := it.cursor.Err()
+			if err != nil {
+				glog.Errorf("Cursor error in SQL: %v", err)
+				it.err = err
+			}
+			it.cursor.Close()
+			return false
+		}
+		s, err := scan(it.cursor, len(it.cols))
+		if err != nil {
+			it.err = err
+			it.cursor.Close()
+			return false
+		}
+		it.resultNext = append(it.resultNext, s)
+	}
+	if it.resultList != nil && it.resultNext == nil {
+		// We're on something and there's no next
+		return false
+	}
+	it.resultList = it.resultNext
+	it.resultNext = nil
+	it.resultIndex = 0
+	for {
+		if !it.cursor.Next() {
+			glog.V(4).Infoln("sql: No next")
+			err := it.cursor.Err()
+			if err != nil {
+				glog.Errorf("Cursor error in SQL: %v", err)
+				it.err = err
+			}
+			it.cursor.Close()
+			break
+		}
+		s, err := scan(it.cursor, len(it.cols))
+		if err != nil {
+			it.err = err
+			it.cursor.Close()
+			return false
+		}
+
+		if it.sql.sameTopResult(it.resultList[0], s) {
+			it.resultList = append(it.resultList, s)
+		} else {
+			it.resultNext = append(it.resultNext, s)
+			break
+		}
+	}
+
+	if len(it.resultList) == 0 {
+		return graph.NextLogOut(it, nil, false)
+	}
+	it.buildResult(0)
+	return graph.NextLogOut(it, it.Result(), true)
+}
+
+func (it *SQLIterator) Contains(v graph.Value) bool {
+	var err error
+	if ok, res := it.sql.quickContains(v); ok {
+		return res
+	}
+	err = it.makeCursor(false, v)
+	if err != nil {
+		glog.Errorf("Couldn't make query: %v", err)
+		it.err = err
+		if it.cursor != nil {
+			it.cursor.Close()
+		}
+		return false
+	}
+	it.cols, err = it.cursor.Columns()
+	if err != nil {
+		glog.Errorf("Couldn't get columns")
+		it.err = err
+		it.cursor.Close()
+		return false
+	}
+	it.resultList = nil
+	for {
+		if !it.cursor.Next() {
+			glog.V(4).Infoln("sql: No next")
+			err := it.cursor.Err()
+			if err != nil {
+				glog.Errorf("Cursor error in SQL: %v", err)
+				it.err = err
+			}
+			it.cursor.Close()
+			break
+		}
+		s, err := scan(it.cursor, len(it.cols))
+		if err != nil {
+			it.err = err
+			it.cursor.Close()
+			return false
+		}
+		it.resultList = append(it.resultList, s)
+	}
+	it.cursor.Close()
+	it.cursor = nil
+	if len(it.resultList) != 0 {
+		it.resultIndex = 0
+		it.buildResult(0)
+		return true
+	}
+	return false
+}
+
+func scan(cursor *sql.Rows, nCols int) ([]string, error) {
+	pointers := make([]interface{}, nCols)
+	container := make([]string, nCols)
+	for i, _ := range pointers {
+		pointers[i] = &container[i]
+	}
+	err := cursor.Scan(pointers...)
+	if err != nil {
+		glog.Errorf("Error scanning iterator: %v", err)
+		return nil, err
+	}
+	return container, nil
+}
+
+func (it *SQLIterator) buildResult(i int) {
+	it.result = it.sql.buildResult(it.resultList[i], it.cols)
+}
+
+func (it *SQLIterator) makeCursor(next bool, value graph.Value) error {
+	if it.cursor != nil {
+		it.cursor.Close()
+	}
+	var q string
+	var values []string
+	q, values = it.sql.buildSQL(next, value)
+	q = convertToPostgres(q, values)
+	ivalues := make([]interface{}, 0, len(values))
+	for _, v := range values {
+		ivalues = append(ivalues, v)
+	}
+	cursor, err := it.qs.db.Query(q, ivalues...)
+	if err != nil {
+		glog.Errorf("Couldn't get cursor from SQL database: %v", err)
+		cursor = nil
+		return err
+	}
+	it.cursor = cursor
+	return nil
+}
+
+func convertToPostgres(query string, values []string) string {
+	for i := 1; i <= len(values); i++ {
+		query = strings.Replace(query, "?", fmt.Sprintf("$%d", i), 1)
+	}
+	return query
+}
+
+func NewSQLLinkIterator(qs *QuadStore, d quad.Direction, val string) *SQLIterator {
+	l := &SQLIterator{
+		uid: iterator.NextUID(),
+		qs:  qs,
+		sql: &SQLLinkIterator{
+			constraints: []constraint{
+				constraint{
+					dir:  d,
+					vals: []string{val},
+				},
+			},
+			tableName: newTableName(),
+			size:      0,
+		},
+	}
+	return l
+}
+
+func NewSQLIterator(qs *QuadStore, sql sqlIterator) *SQLIterator {
+	l := &SQLIterator{
+		uid: iterator.NextUID(),
+		qs:  qs,
+		sql: sql,
+	}
+	return l
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/sql_link_iterator.go b/vendor/github.com/google/cayley/graph/sql/sql_link_iterator.go
new file mode 100644
index 00000000..824381d9
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/sql_link_iterator.go
@@ -0,0 +1,319 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"fmt"
+	"strings"
+	"sync/atomic"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+var sqlTableID uint64
+
+func init() {
+	atomic.StoreUint64(&sqlTableID, 0)
+}
+
+func newTableName() string {
+	id := atomic.AddUint64(&sqlTableID, 1)
+	return fmt.Sprintf("t_%d", id)
+}
+
+type constraint struct {
+	dir  quad.Direction
+	vals []string
+}
+
+type tagDir struct {
+	tag       string
+	dir       quad.Direction
+	table     string
+	justLocal bool
+}
+
+func (t tagDir) String() string {
+	if t.dir == quad.Any {
+		if t.justLocal {
+			return fmt.Sprintf("%s.__execd as \"%s\", %s.__execd_hash as %s_hash", t.table, t.tag, t.table, t.tag)
+		}
+		return fmt.Sprintf("%s.\"%s\" as \"%s\", %s.%s_hash as %s_hash", t.table, t.tag, t.tag, t.table, t.tag, t.tag)
+	}
+	return fmt.Sprintf("%s.%s as \"%s\", %s.%s_hash as %s_hash", t.table, t.dir, t.tag, t.table, t.dir, t.tag)
+}
+
+type tableDef struct {
+	table  string
+	name   string
+	values []string
+}
+
+type sqlItDir struct {
+	dir quad.Direction
+	it  sqlIterator
+}
+
+type sqlIterator interface {
+	sqlClone() sqlIterator
+
+	buildSQL(next bool, val graph.Value) (string, []string)
+	getTables() []tableDef
+	getTags() []tagDir
+	buildWhere() (string, []string)
+	tableID() tagDir
+
+	quickContains(graph.Value) (ok bool, result bool)
+	buildResult(result []string, cols []string) map[string]string
+	sameTopResult(target []string, test []string) bool
+
+	Result() graph.Value
+	Size(*QuadStore) (int64, bool)
+	Describe() string
+	Type() sqlQueryType
+	Tagger() *graph.Tagger
+}
+
+type SQLLinkIterator struct {
+	tagger graph.Tagger
+
+	nodeIts     []sqlItDir
+	constraints []constraint
+	tableName   string
+	size        int64
+	tagdirs     []tagDir
+
+	resultQuad quad.Quad
+}
+
+func (l *SQLLinkIterator) sqlClone() sqlIterator {
+	m := &SQLLinkIterator{
+		tableName:   l.tableName,
+		size:        l.size,
+		constraints: make([]constraint, len(l.constraints)),
+		tagdirs:     make([]tagDir, len(l.tagdirs)),
+	}
+	for _, i := range l.nodeIts {
+		m.nodeIts = append(m.nodeIts, sqlItDir{
+			dir: i.dir,
+			it:  i.it.sqlClone(),
+		})
+	}
+	copy(m.constraints, l.constraints)
+	copy(m.tagdirs, l.tagdirs)
+	m.tagger.CopyFromTagger(l.Tagger())
+	return m
+}
+
+func (l *SQLLinkIterator) Tagger() *graph.Tagger {
+	return &l.tagger
+}
+
+func (l *SQLLinkIterator) Result() graph.Value {
+	return l.resultQuad
+}
+
+func (l *SQLLinkIterator) Size(qs *QuadStore) (int64, bool) {
+	if l.size != 0 {
+		return l.size, true
+	}
+	if len(l.constraints) > 0 {
+		l.size = qs.sizeForIterator(false, l.constraints[0].dir, l.constraints[0].vals[0])
+	} else if len(l.nodeIts) > 1 {
+		subsize, _ := l.nodeIts[0].it.(*SQLNodeIterator).Size(qs)
+		return subsize * 20, false
+	} else {
+		return qs.Size(), false
+	}
+	return l.size, true
+}
+
+func (l *SQLLinkIterator) Describe() string {
+	s, _ := l.buildSQL(true, nil)
+	return fmt.Sprintf("SQL_LINK_QUERY: %s", s)
+}
+
+func (l *SQLLinkIterator) Type() sqlQueryType {
+	return link
+}
+
+func (l *SQLLinkIterator) quickContains(v graph.Value) (bool, bool) {
+	for _, c := range l.constraints {
+		none := true
+		desired := v.(quad.Quad).Get(c.dir)
+		for _, s := range c.vals {
+			if s == desired {
+				none = false
+				break
+			}
+		}
+		if none {
+			return true, false
+		}
+	}
+	if len(l.nodeIts) == 0 {
+		return true, true
+	}
+	return false, false
+}
+
+func (l *SQLLinkIterator) buildResult(result []string, cols []string) map[string]string {
+	var q quad.Quad
+	q.Subject = result[0]
+	q.Predicate = result[1]
+	q.Object = result[2]
+	q.Label = result[3]
+	l.resultQuad = q
+	m := make(map[string]string)
+	for i, c := range cols[4:] {
+		m[c] = result[i+4]
+	}
+	return m
+}
+
+func (l *SQLLinkIterator) getTables() []tableDef {
+	out := []tableDef{tableDef{table: "quads", name: l.tableName}}
+	for _, i := range l.nodeIts {
+		out = append(out, i.it.getTables()...)
+	}
+	return out
+}
+
+func (l *SQLLinkIterator) getTags() []tagDir {
+	var out []tagDir
+	for _, tag := range l.tagger.Tags() {
+		out = append(out, tagDir{
+			dir:   quad.Any,
+			table: l.tableName,
+			tag:   tag,
+		})
+	}
+	for _, tag := range l.tagdirs {
+		out = append(out, tagDir{
+			dir:   tag.dir,
+			table: l.tableName,
+			tag:   tag.tag,
+		})
+
+	}
+	for _, i := range l.nodeIts {
+		out = append(out, i.it.getTags()...)
+	}
+	return out
+}
+
+func (l *SQLLinkIterator) buildWhere() (string, []string) {
+	var q []string
+	var vals []string
+	for _, c := range l.constraints {
+		if len(c.vals) == 1 {
+			q = append(q, fmt.Sprintf("%s.%s_hash = ?", l.tableName, c.dir))
+			vals = append(vals, hashOf(c.vals[0]))
+		} else if len(c.vals) > 1 {
+			valslots := strings.Join(strings.Split(strings.Repeat("?", len(c.vals)), ""), ", ")
+			subq := fmt.Sprintf("%s.%s_hash IN (%s)", l.tableName, c.dir, valslots)
+			q = append(q, subq)
+			for _, v := range c.vals {
+				vals = append(vals, hashOf(v))
+			}
+		}
+	}
+	for _, i := range l.nodeIts {
+		t := i.it.tableID()
+		dir := t.dir.String()
+		if t.dir == quad.Any {
+			dir = t.tag
+		}
+		q = append(q, fmt.Sprintf("%s.%s_hash = %s.%s_hash", l.tableName, i.dir, t.table, dir))
+	}
+	for _, i := range l.nodeIts {
+		s, v := i.it.buildWhere()
+		q = append(q, s)
+		vals = append(vals, v...)
+	}
+	query := strings.Join(q, " AND ")
+	return query, vals
+}
+
+func (l *SQLLinkIterator) tableID() tagDir {
+	return tagDir{
+		dir:   quad.Any,
+		table: l.tableName,
+	}
+}
+
+func (l *SQLLinkIterator) buildSQL(next bool, val graph.Value) (string, []string) {
+	query := "SELECT "
+	t := []string{
+		fmt.Sprintf("%s.subject", l.tableName),
+		fmt.Sprintf("%s.predicate", l.tableName),
+		fmt.Sprintf("%s.object", l.tableName),
+		fmt.Sprintf("%s.label", l.tableName),
+	}
+	for _, v := range l.getTags() {
+		t = append(t, v.String())
+	}
+	query += strings.Join(t, ", ")
+	query += " FROM "
+	t = []string{}
+	var values []string
+	for _, k := range l.getTables() {
+		values = append(values, k.values...)
+		t = append(t, fmt.Sprintf("%s as %s", k.table, k.name))
+	}
+	query += strings.Join(t, ", ")
+	constraint, wherevalues := l.buildWhere()
+	if constraint != "" {
+		query += " WHERE "
+	}
+
+	values = append(values, wherevalues...)
+	if !next {
+		v := val.(quad.Quad)
+		if constraint != "" {
+			constraint += " AND "
+		} else {
+			constraint += " WHERE "
+		}
+		t = []string{
+			fmt.Sprintf("%s.subject_hash = ?", l.tableName),
+			fmt.Sprintf("%s.predicate_hash = ?", l.tableName),
+			fmt.Sprintf("%s.object_hash = ?", l.tableName),
+			fmt.Sprintf("%s.label_hash = ?", l.tableName),
+		}
+		constraint += strings.Join(t, " AND ")
+		values = append(values, hashOf(v.Subject))
+		values = append(values, hashOf(v.Predicate))
+		values = append(values, hashOf(v.Object))
+		values = append(values, hashOf(v.Label))
+	}
+	query += constraint
+	query += ";"
+
+	if glog.V(4) {
+		dstr := query
+		for i := 1; i <= len(values); i++ {
+			dstr = strings.Replace(dstr, "?", fmt.Sprintf("'%s'", values[i-1]), 1)
+		}
+		glog.V(4).Infoln(dstr)
+	}
+	return query, values
+}
+
+func (l *SQLLinkIterator) sameTopResult(target []string, test []string) bool {
+	return target[0] == test[0] && target[1] == test[1] && target[2] == test[2] && target[3] == test[3]
+}
diff --git a/vendor/github.com/google/cayley/graph/sql/sql_node_intersection.go b/vendor/github.com/google/cayley/graph/sql/sql_node_intersection.go
new file mode 100644
index 00000000..a9e26e2f
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/sql_node_intersection.go
@@ -0,0 +1,211 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+type SQLNodeIntersection struct {
+	tableName string
+
+	nodeIts    []sqlIterator
+	nodetables []string
+	size       int64
+	tagger     graph.Tagger
+
+	result string
+}
+
+func (n *SQLNodeIntersection) sqlClone() sqlIterator {
+	m := &SQLNodeIntersection{
+		tableName: n.tableName,
+		size:      n.size,
+	}
+	for _, i := range n.nodeIts {
+		m.nodeIts = append(m.nodeIts, i.sqlClone())
+	}
+	m.tagger.CopyFromTagger(n.Tagger())
+	return m
+}
+
+func (n *SQLNodeIntersection) Tagger() *graph.Tagger {
+	return &n.tagger
+}
+
+func (n *SQLNodeIntersection) Result() graph.Value {
+	return n.result
+}
+
+func (n *SQLNodeIntersection) Type() sqlQueryType {
+	return nodeIntersect
+}
+
+func (n *SQLNodeIntersection) Size(qs *QuadStore) (int64, bool) {
+	return qs.Size() / int64(len(n.nodeIts)+1), true
+}
+
+func (n *SQLNodeIntersection) Describe() string {
+	s, _ := n.buildSQL(true, nil)
+	return fmt.Sprintf("SQL_NODE_INTERSECTION: %s", s)
+}
+
+func (n *SQLNodeIntersection) buildResult(result []string, cols []string) map[string]string {
+	m := make(map[string]string)
+	for i, c := range cols {
+		if strings.HasSuffix(c, "_hash") {
+			continue
+		}
+		if c == "__execd" {
+			n.result = result[i]
+		}
+		m[c] = result[i]
+	}
+	return m
+}
+
+func (n *SQLNodeIntersection) makeNodeTableNames() {
+	if n.nodetables != nil {
+		return
+	}
+	n.nodetables = make([]string, len(n.nodeIts))
+	for i, _ := range n.nodetables {
+		n.nodetables[i] = newNodeTableName()
+	}
+}
+
+func (n *SQLNodeIntersection) getTables() []tableDef {
+	if len(n.nodeIts) == 0 {
+		panic("Combined no subnode queries")
+	}
+	return n.buildSubqueries()
+}
+
+func (n *SQLNodeIntersection) buildSubqueries() []tableDef {
+	var out []tableDef
+	n.makeNodeTableNames()
+	for i, it := range n.nodeIts {
+		var td tableDef
+		var table string
+		table, td.values = it.buildSQL(true, nil)
+		td.table = fmt.Sprintf("\n(%s)", table[:len(table)-1])
+		td.name = n.nodetables[i]
+		out = append(out, td)
+	}
+	return out
+}
+
+func (n *SQLNodeIntersection) tableID() tagDir {
+	n.makeNodeTableNames()
+	return tagDir{
+		table: n.nodetables[0],
+		dir:   quad.Any,
+		tag:   "__execd",
+	}
+}
+
+func (n *SQLNodeIntersection) getLocalTags() []tagDir {
+	myTag := n.tableID()
+	var out []tagDir
+	for _, tag := range n.tagger.Tags() {
+		out = append(out, tagDir{
+			dir:       myTag.dir,
+			table:     myTag.table,
+			tag:       tag,
+			justLocal: true,
+		})
+	}
+	return out
+}
+
+func (n *SQLNodeIntersection) getTags() []tagDir {
+	out := n.getLocalTags()
+	n.makeNodeTableNames()
+	for i, it := range n.nodeIts {
+		for _, v := range it.getTags() {
+			out = append(out, tagDir{
+				tag:   v.tag,
+				dir:   quad.Any,
+				table: n.nodetables[i],
+			})
+		}
+	}
+	return out
+}
+
+func (n *SQLNodeIntersection) buildWhere() (string, []string) {
+	var q []string
+	var vals []string
+	for _, tb := range n.nodetables[1:] {
+		q = append(q, fmt.Sprintf("%s.__execd_hash = %s.__execd_hash", n.nodetables[0], tb))
+	}
+	query := strings.Join(q, " AND ")
+	return query, vals
+}
+
+func (n *SQLNodeIntersection) buildSQL(next bool, val graph.Value) (string, []string) {
+	topData := n.tableID()
+	tags := []tagDir{topData}
+	tags = append(tags, n.getTags()...)
+	query := "SELECT "
+	var t []string
+	for _, v := range tags {
+		t = append(t, v.String())
+	}
+	query += strings.Join(t, ", ")
+	query += " FROM "
+	t = []string{}
+	var values []string
+	for _, k := range n.getTables() {
+		values = append(values, k.values...)
+		t = append(t, fmt.Sprintf("%s as %s", k.table, k.name))
+	}
+	query += strings.Join(t, ", ")
+	query += " WHERE "
+
+	constraint, wherevalues := n.buildWhere()
+	values = append(values, wherevalues...)
+
+	if !next {
+		v := val.(string)
+		if constraint != "" {
+			constraint += " AND "
+		}
+		constraint += fmt.Sprintf("%s.%s_hash = ?", topData.table, topData.dir)
+		values = append(values, hashOf(v))
+	}
+	query += constraint
+	query += ";"
+
+	if glog.V(4) {
+		dstr := query
+		for i := 1; i <= len(values); i++ {
+			dstr = strings.Replace(dstr, "?", fmt.Sprintf("'%s'", values[i-1]), 1)
+		}
+		glog.V(4).Infoln(dstr)
+	}
+	return query, values
+}
+
+func (n *SQLNodeIntersection) sameTopResult(target []string, test []string) bool {
+	return target[0] == test[0]
+}
+
+func (n *SQLNodeIntersection) quickContains(_ graph.Value) (bool, bool) { return false, false }
diff --git a/vendor/github.com/google/cayley/graph/sql/sql_node_iterator.go b/vendor/github.com/google/cayley/graph/sql/sql_node_iterator.go
new file mode 100644
index 00000000..ba259eac
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/sql/sql_node_iterator.go
@@ -0,0 +1,226 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sql
+
+import (
+	"fmt"
+	"strings"
+	"sync/atomic"
+
+	"github.com/barakmich/glog"
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+var sqlNodeTableID uint64
+
+type sqlQueryType int
+
+const (
+	node sqlQueryType = iota
+	link
+	nodeIntersect
+)
+
+func init() {
+	atomic.StoreUint64(&sqlNodeTableID, 0)
+}
+
+func newNodeTableName() string {
+	id := atomic.AddUint64(&sqlNodeTableID, 1)
+	return fmt.Sprintf("n_%d", id)
+}
+
+type SQLNodeIterator struct {
+	tableName string
+
+	linkIt   sqlItDir
+	size     int64
+	tagger   graph.Tagger
+	fixedSet []string
+
+	result string
+}
+
+func (n *SQLNodeIterator) sqlClone() sqlIterator {
+	m := &SQLNodeIterator{
+		tableName: n.tableName,
+		size:      n.size,
+		linkIt: sqlItDir{
+			dir: n.linkIt.dir,
+			it:  n.linkIt.it.sqlClone(),
+		},
+		fixedSet: make([]string, len(n.fixedSet)),
+	}
+	m.tagger.CopyFromTagger(n.Tagger())
+	copy(m.fixedSet, n.fixedSet)
+	return m
+}
+
+func (n *SQLNodeIterator) Tagger() *graph.Tagger {
+	return &n.tagger
+}
+
+func (n *SQLNodeIterator) Result() graph.Value {
+	return n.result
+}
+
+func (n *SQLNodeIterator) Type() sqlQueryType {
+	return node
+}
+
+func (n *SQLNodeIterator) Size(qs *QuadStore) (int64, bool) {
+	return qs.Size() / 2, true
+}
+
+func (n *SQLNodeIterator) Describe() string {
+	s, _ := n.buildSQL(true, nil)
+	return fmt.Sprintf("SQL_NODE_QUERY: %s", s)
+}
+
+func (n *SQLNodeIterator) buildResult(result []string, cols []string) map[string]string {
+	m := make(map[string]string)
+	for i, c := range cols {
+		if strings.HasSuffix(c, "_hash") {
+			continue
+		}
+		if c == "__execd" {
+			n.result = result[i]
+		}
+		m[c] = result[i]
+	}
+	return m
+}
+
+func (n *SQLNodeIterator) getTables() []tableDef {
+	var out []tableDef
+	if n.linkIt.it != nil {
+		out = n.linkIt.it.getTables()
+	}
+	if len(out) == 0 {
+		out = append(out, tableDef{table: "quads", name: n.tableName})
+	}
+	return out
+}
+
+func (n *SQLNodeIterator) tableID() tagDir {
+	if n.linkIt.it != nil {
+		return tagDir{
+			table: n.linkIt.it.tableID().table,
+			dir:   n.linkIt.dir,
+			tag:   "__execd",
+		}
+	}
+	return tagDir{
+		table: n.tableName,
+		dir:   quad.Any,
+		tag:   "__execd",
+	}
+}
+
+func (n *SQLNodeIterator) getLocalTags() []tagDir {
+	myTag := n.tableID()
+	var out []tagDir
+	for _, tag := range n.tagger.Tags() {
+		out = append(out, tagDir{
+			dir:       myTag.dir,
+			table:     myTag.table,
+			tag:       tag,
+			justLocal: true,
+		})
+	}
+	return out
+}
+
+func (n *SQLNodeIterator) getTags() []tagDir {
+	out := n.getLocalTags()
+	if n.linkIt.it != nil {
+		out = append(out, n.linkIt.it.getTags()...)
+	}
+	return out
+}
+
+func (n *SQLNodeIterator) buildWhere() (string, []string) {
+	var q []string
+	var vals []string
+	if n.linkIt.it != nil {
+		s, v := n.linkIt.it.buildWhere()
+		q = append(q, s)
+		vals = append(vals, v...)
+	}
+	if len(n.fixedSet) != 0 {
+		topData := n.tableID()
+		var valueChain []string
+		for _, v := range n.fixedSet {
+			vals = append(vals, hashOf(v))
+			valueChain = append(valueChain, "?")
+		}
+		q = append(q, fmt.Sprintf("%s.%s_hash IN (%s)", topData.table, topData.dir, strings.Join(valueChain, ", ")))
+	}
+	query := strings.Join(q, " AND ")
+	return query, vals
+}
+
+func (n *SQLNodeIterator) buildSQL(next bool, val graph.Value) (string, []string) {
+	topData := n.tableID()
+	tags := []tagDir{topData}
+	tags = append(tags, n.getTags()...)
+	query := "SELECT "
+
+	var t []string
+	for _, v := range tags {
+		t = append(t, v.String())
+	}
+	query += strings.Join(t, ", ")
+	query += " FROM "
+	t = []string{}
+	var values []string
+	for _, k := range n.getTables() {
+		values = append(values, k.values...)
+		t = append(t, fmt.Sprintf("%s as %s", k.table, k.name))
+	}
+	query += strings.Join(t, ", ")
+	query += " WHERE "
+
+	constraint, wherevalues := n.buildWhere()
+	values = append(values, wherevalues...)
+
+	if !next {
+		v := val.(string)
+		if constraint != "" {
+			constraint += " AND "
+		}
+		constraint += fmt.Sprintf("%s.%s_hash = ?", topData.table, topData.dir)
+		values = append(values, hashOf(v))
+	}
+
+	query += constraint
+	query += ";"
+
+	if glog.V(4) {
+		dstr := query
+		for i := 1; i <= len(values); i++ {
+			dstr = strings.Replace(dstr, "?", fmt.Sprintf("'%s'", values[i-1]), 1)
+		}
+		glog.V(4).Infoln(dstr)
+	}
+	return query, values
+}
+
+func (n *SQLNodeIterator) sameTopResult(target []string, test []string) bool {
+	return target[0] == test[0]
+}
+
+func (n *SQLNodeIterator) quickContains(_ graph.Value) (bool, bool) { return false, false }
diff --git a/vendor/github.com/google/cayley/graph/transaction.go b/vendor/github.com/google/cayley/graph/transaction.go
new file mode 100644
index 00000000..a37d9df4
--- /dev/null
+++ b/vendor/github.com/google/cayley/graph/transaction.go
@@ -0,0 +1,65 @@
+// Copyright 2015 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package graph
+
+import "github.com/google/cayley/quad"
+
+// Transaction stores a bunch of Deltas to apply atomatically on the database.
+type Transaction struct {
+	Deltas map[Delta]struct{}
+}
+
+// NewTransaction initialize a new transaction.
+func NewTransaction() *Transaction {
+	return &Transaction{Deltas: make(map[Delta]struct{}, 100)}
+}
+
+// AddQuad adds a new quad to the transaction if it is not already present in it.
+// If there is a 'remove' delta for that quad, it will remove that delta from
+// the transaction instead of actually addind the quad.
+func (t *Transaction) AddQuad(q quad.Quad) {
+	ad := Delta{
+		Quad:   q,
+		Action: Add,
+	}
+	rd := Delta{
+		Quad:   q,
+		Action: Delete,
+	}
+
+	if _, adExists := t.Deltas[ad]; !adExists {
+		if _, rdExists := t.Deltas[rd]; rdExists {
+			delete(t.Deltas, rd)
+		} else {
+			t.Deltas[ad] = struct{}{}
+		}
+	}
+}
+
+// RemoveQuad adds a quad to remove to the transaction.
+// The quad will be removed from the database if it is not present in the
+// transaction, otherwise it simply remove it from the transaction.
+func (t *Transaction) RemoveQuad(q quad.Quad) {
+	ad := Delta{
+		Quad:   q,
+		Action: Add,
+	}
+
+	if _, adExists := t.Deltas[ad]; adExists {
+		delete(t.Deltas, ad)
+	} else {
+		t.Deltas[Delta{Quad: q, Action: Delete}] = struct{}{}
+	}
+}
diff --git a/vendor/github.com/google/cayley/imports.go b/vendor/github.com/google/cayley/imports.go
new file mode 100644
index 00000000..c855ce9e
--- /dev/null
+++ b/vendor/github.com/google/cayley/imports.go
@@ -0,0 +1,53 @@
+package cayley
+
+import (
+	"github.com/google/cayley/graph"
+	_ "github.com/google/cayley/graph/memstore"
+	"github.com/google/cayley/graph/path"
+	"github.com/google/cayley/quad"
+	_ "github.com/google/cayley/writer"
+)
+
+type Iterator graph.Iterator
+type QuadStore graph.QuadStore
+type QuadWriter graph.QuadWriter
+
+type Path path.Path
+
+var (
+	StartMorphism = path.StartMorphism
+	StartPath     = path.StartPath
+
+	RawNext        = graph.Next
+	NewTransaction = graph.NewTransaction
+)
+
+type Handle struct {
+	graph.QuadStore
+	graph.QuadWriter
+}
+
+func Quad(subject, predicate, object, label string) quad.Quad {
+	return quad.Quad{subject, predicate, object, label}
+}
+
+func NewGraph(name, dbpath string, opts graph.Options) (*Handle, error) {
+	qs, err := graph.NewQuadStore(name, dbpath, opts)
+	if err != nil {
+		return nil, err
+	}
+	qw, err := graph.NewQuadWriter("single", qs, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Handle{qs, qw}, nil
+}
+
+func NewMemoryGraph() (*Handle, error) {
+	return NewGraph("memstore", "", nil)
+}
+
+func (h *Handle) Close() {
+	h.QuadStore.Close()
+	h.QuadWriter.Close()
+}
diff --git a/vendor/github.com/google/cayley/internal/config/config.go b/vendor/github.com/google/cayley/internal/config/config.go
new file mode 100644
index 00000000..fa18b577
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/config/config.go
@@ -0,0 +1,145 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strconv"
+	"time"
+)
+
+// Config defines the behavior of cayley database instances.
+type Config struct {
+	DatabaseType               string
+	DatabasePath               string
+	DatabaseOptions            map[string]interface{}
+	ReplicationType            string
+	ReplicationOptions         map[string]interface{}
+	ListenHost                 string
+	ListenPort                 string
+	ReadOnly                   bool
+	Timeout                    time.Duration
+	LoadSize                   int
+	RequiresHTTPRequestContext bool
+}
+
+type config struct {
+	DatabaseType               string                 `json:"database"`
+	DatabasePath               string                 `json:"db_path"`
+	DatabaseOptions            map[string]interface{} `json:"db_options"`
+	ReplicationType            string                 `json:"replication"`
+	ReplicationOptions         map[string]interface{} `json:"replication_options"`
+	ListenHost                 string                 `json:"listen_host"`
+	ListenPort                 string                 `json:"listen_port"`
+	ReadOnly                   bool                   `json:"read_only"`
+	Timeout                    duration               `json:"timeout"`
+	LoadSize                   int                    `json:"load_size"`
+	RequiresHTTPRequestContext bool                   `json:"http_request_context"`
+}
+
+func (c *Config) UnmarshalJSON(data []byte) error {
+	var t config
+	err := json.Unmarshal(data, &t)
+	if err != nil {
+		return err
+	}
+	*c = Config{
+		DatabaseType:               t.DatabaseType,
+		DatabasePath:               t.DatabasePath,
+		DatabaseOptions:            t.DatabaseOptions,
+		ReplicationType:            t.ReplicationType,
+		ReplicationOptions:         t.ReplicationOptions,
+		ListenHost:                 t.ListenHost,
+		ListenPort:                 t.ListenPort,
+		ReadOnly:                   t.ReadOnly,
+		Timeout:                    time.Duration(t.Timeout),
+		LoadSize:                   t.LoadSize,
+		RequiresHTTPRequestContext: t.RequiresHTTPRequestContext,
+	}
+	return nil
+}
+
+func (c *Config) MarshalJSON() ([]byte, error) {
+	return json.Marshal(config{
+		DatabaseType:       c.DatabaseType,
+		DatabasePath:       c.DatabasePath,
+		DatabaseOptions:    c.DatabaseOptions,
+		ReplicationType:    c.ReplicationType,
+		ReplicationOptions: c.ReplicationOptions,
+		ListenHost:         c.ListenHost,
+		ListenPort:         c.ListenPort,
+		ReadOnly:           c.ReadOnly,
+		Timeout:            duration(c.Timeout),
+		LoadSize:           c.LoadSize,
+	})
+}
+
+// duration is a time.Duration that satisfies the
+// json.UnMarshaler and json.Marshaler interfaces.
+type duration time.Duration
+
+// UnmarshalJSON unmarshals a duration according to the following scheme:
+//  * If the element is absent the duration is zero.
+//  * If the element is parsable as a time.Duration, the parsed value is kept.
+//  * If the element is parsable as a number, that number of seconds is kept.
+func (d *duration) UnmarshalJSON(data []byte) error {
+	if len(data) == 0 {
+		*d = 0
+		return nil
+	}
+	text := string(data)
+	t, err := time.ParseDuration(text)
+	if err == nil {
+		*d = duration(t)
+		return nil
+	}
+	i, err := strconv.ParseInt(text, 10, 64)
+	if err == nil {
+		*d = duration(time.Duration(i) * time.Second)
+		return nil
+	}
+	// This hack is to get around strconv.ParseFloat
+	// not handling e-notation for integers.
+	f, err := strconv.ParseFloat(text, 64)
+	*d = duration(time.Duration(f) * time.Second)
+	return err
+}
+
+func (d *duration) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%q", *d)), nil
+}
+
+// Load reads a JSON-encoded config contained in the given file. A zero value
+// config is returned if the filename is empty.
+func Load(file string) (*Config, error) {
+	config := &Config{}
+	if file == "" {
+		return config, nil
+	}
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, fmt.Errorf("could not open config file %q: %v", file, err)
+	}
+	defer f.Close()
+
+	dec := json.NewDecoder(f)
+	err = dec.Decode(config)
+	if err != nil {
+		return nil, fmt.Errorf("could not parse config file %q: %v", file, err)
+	}
+	return config, nil
+}
diff --git a/vendor/github.com/google/cayley/internal/db/db.go b/vendor/github.com/google/cayley/internal/db/db.go
new file mode 100644
index 00000000..c139b1e6
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/db/db.go
@@ -0,0 +1,105 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package db
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/internal/config"
+	"github.com/google/cayley/quad"
+)
+
+var ErrNotPersistent = errors.New("database type is not persistent")
+
+func Init(cfg *config.Config) error {
+	if !graph.IsPersistent(cfg.DatabaseType) {
+		return fmt.Errorf("ignoring unproductive database initialization request: %v", ErrNotPersistent)
+	}
+
+	return graph.InitQuadStore(cfg.DatabaseType, cfg.DatabasePath, cfg.DatabaseOptions)
+}
+
+func Open(cfg *config.Config) (*graph.Handle, error) {
+	qs, err := OpenQuadStore(cfg)
+	if err != nil {
+		return nil, err
+	}
+	qw, err := OpenQuadWriter(qs, cfg)
+	if err != nil {
+		return nil, err
+	}
+	return &graph.Handle{QuadStore: qs, QuadWriter: qw}, nil
+}
+
+func OpenQuadStore(cfg *config.Config) (graph.QuadStore, error) {
+	glog.Infof("Opening quad store %q at %s", cfg.DatabaseType, cfg.DatabasePath)
+	qs, err := graph.NewQuadStore(cfg.DatabaseType, cfg.DatabasePath, cfg.DatabaseOptions)
+	if err != nil {
+		return nil, err
+	}
+
+	return qs, nil
+}
+
+func OpenQuadWriter(qs graph.QuadStore, cfg *config.Config) (graph.QuadWriter, error) {
+	glog.Infof("Opening replication method %q", cfg.ReplicationType)
+	w, err := graph.NewQuadWriter(cfg.ReplicationType, qs, cfg.ReplicationOptions)
+	if err != nil {
+		return nil, err
+	}
+
+	return w, nil
+}
+
+func Load(qw graph.QuadWriter, cfg *config.Config, dec quad.Unmarshaler) error {
+	block := make([]quad.Quad, 0, cfg.LoadSize)
+	count := 0
+	for {
+		t, err := dec.Unmarshal()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		block = append(block, t)
+		if len(block) == cap(block) {
+			count += len(block)
+			err := qw.AddQuadSet(block)
+			if err != nil {
+				return fmt.Errorf("db: failed to load data: %v", err)
+			}
+			block = block[:0]
+			if glog.V(2) {
+				glog.V(2).Infof("Wrote %d quads.", count)
+			}
+		}
+	}
+	count += len(block)
+	err := qw.AddQuadSet(block)
+	if err != nil {
+		return fmt.Errorf("db: failed to load data: %v", err)
+	}
+	if glog.V(2) {
+		glog.V(2).Infof("Wrote %d quads.", count)
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/google/cayley/internal/db/repl.go b/vendor/github.com/google/cayley/internal/db/repl.go
new file mode 100644
index 00000000..134a8fff
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/db/repl.go
@@ -0,0 +1,254 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package db
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/peterh/liner"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/internal/config"
+	"github.com/google/cayley/quad/cquads"
+	"github.com/google/cayley/query"
+	"github.com/google/cayley/query/gremlin"
+	"github.com/google/cayley/query/mql"
+	"github.com/google/cayley/query/sexp"
+)
+
+func trace(s string) (string, time.Time) {
+	return s, time.Now()
+}
+
+func un(s string, startTime time.Time) {
+	endTime := time.Now()
+
+	fmt.Printf(s, float64(endTime.UnixNano()-startTime.UnixNano())/float64(1E6))
+}
+
+func Run(query string, ses query.Session) {
+	nResults := 0
+	startTrace, startTime := trace("Elapsed time: %g ms\n\n")
+	defer func() {
+		if nResults > 0 {
+			un(startTrace, startTime)
+		}
+	}()
+	fmt.Printf("\n")
+	c := make(chan interface{}, 5)
+	go ses.Execute(query, c, 100)
+	for res := range c {
+		fmt.Print(ses.Format(res))
+		nResults++
+	}
+	if nResults > 0 {
+		results := "Result"
+		if nResults > 1 {
+			results += "s"
+		}
+		fmt.Printf("-----------\n%d %s\n", nResults, results)
+	}
+}
+
+const (
+	ps1 = "cayley> "
+	ps2 = "...     "
+
+	history = ".cayley_history"
+)
+
+func Repl(h *graph.Handle, queryLanguage string, cfg *config.Config) error {
+	var ses query.Session
+	switch queryLanguage {
+	case "sexp":
+		ses = sexp.NewSession(h.QuadStore)
+	case "mql":
+		ses = mql.NewSession(h.QuadStore)
+	case "gremlin":
+		fallthrough
+	default:
+		ses = gremlin.NewSession(h.QuadStore, cfg.Timeout, true)
+	}
+
+	term, err := terminal(history)
+	if os.IsNotExist(err) {
+		fmt.Printf("creating new history file: %q\n", history)
+	}
+	defer persist(term, history)
+
+	var (
+		prompt = ps1
+
+		code string
+	)
+
+	for {
+		if len(code) == 0 {
+			prompt = ps1
+		} else {
+			prompt = ps2
+		}
+		line, err := term.Prompt(prompt)
+		if err != nil {
+			if err == io.EOF {
+				fmt.Println()
+				return nil
+			}
+			return err
+		}
+
+		term.AppendHistory(line)
+
+		line = strings.TrimSpace(line)
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+
+		if code == "" {
+			cmd, args := splitLine(line)
+
+			switch cmd {
+			case ":debug":
+				args = strings.TrimSpace(args)
+				var debug bool
+				switch args {
+				case "t":
+					debug = true
+				case "f":
+					// Do nothing.
+				default:
+					debug, err = strconv.ParseBool(args)
+					if err != nil {
+						fmt.Printf("Error: cannot parse %q as a valid boolean - acceptable values: 't'|'true' or 'f'|'false'\n", args)
+						continue
+					}
+				}
+				ses.Debug(debug)
+				fmt.Printf("Debug set to %t\n", debug)
+				continue
+
+			case ":a":
+				quad, err := cquads.Parse(args)
+				if err != nil {
+					fmt.Printf("Error: not a valid quad: %v\n", err)
+					continue
+				}
+
+				h.QuadWriter.AddQuad(quad)
+				continue
+
+			case ":d":
+				quad, err := cquads.Parse(args)
+				if err != nil {
+					fmt.Printf("Error: not a valid quad: %v\n", err)
+					continue
+				}
+				err = h.QuadWriter.RemoveQuad(quad)
+				if err != nil {
+					fmt.Printf("error deleting: %v\n", err)
+				}
+				continue
+
+			case "exit":
+				term.Close()
+				os.Exit(0)
+
+			default:
+				if cmd[0] == ':' {
+					fmt.Printf("Unknown command: %q\n", cmd)
+					continue
+				}
+			}
+		}
+
+		code += line
+
+		result, err := ses.Parse(code)
+		switch result {
+		case query.Parsed:
+			Run(code, ses)
+			code = ""
+		case query.ParseFail:
+			fmt.Println("Error: ", err)
+			code = ""
+		case query.ParseMore:
+		}
+	}
+}
+
+// Splits a line into a command and its arguments
+// e.g. ":a b c d ." will be split into ":a" and " b c d ."
+func splitLine(line string) (string, string) {
+	var command, arguments string
+
+	line = strings.TrimSpace(line)
+
+	// An empty line/a line consisting of whitespace contains neither command nor arguments
+	if len(line) > 0 {
+		command = strings.Fields(line)[0]
+
+		// A line containing only a command has no arguments
+		if len(line) > len(command) {
+			arguments = line[len(command):]
+		}
+	}
+
+	return command, arguments
+}
+
+func terminal(path string) (*liner.State, error) {
+	term := liner.NewLiner()
+
+	go func() {
+		c := make(chan os.Signal, 1)
+		signal.Notify(c, os.Interrupt, os.Kill)
+		<-c
+
+		err := persist(term, history)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to properly clean up terminal: %v\n", err)
+			os.Exit(1)
+		}
+
+		os.Exit(0)
+	}()
+
+	f, err := os.Open(path)
+	if err != nil {
+		return term, err
+	}
+	defer f.Close()
+	_, err = term.ReadHistory(f)
+	return term, err
+}
+
+func persist(term *liner.State, path string) error {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
+	if err != nil {
+		return fmt.Errorf("could not open %q to append history: %v", path, err)
+	}
+	defer f.Close()
+	_, err = term.WriteHistory(f)
+	if err != nil {
+		return fmt.Errorf("could not write history to %q: %v", path, err)
+	}
+	return term.Close()
+}
diff --git a/vendor/github.com/google/cayley/internal/decompressor.go b/vendor/github.com/google/cayley/internal/decompressor.go
new file mode 100644
index 00000000..1d3ab008
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/decompressor.go
@@ -0,0 +1,46 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+	"bufio"
+	"bytes"
+	"compress/bzip2"
+	"compress/gzip"
+	"io"
+)
+
+const (
+	gzipMagic  = "\x1f\x8b"
+	b2zipMagic = "BZh"
+)
+
+// Decompressor detects the file type of an io.Reader between
+// bzip, gzip, or raw quad file.
+func Decompressor(r io.Reader) (io.Reader, error) {
+	br := bufio.NewReader(r)
+	buf, err := br.Peek(3)
+	if err != nil {
+		return nil, err
+	}
+	switch {
+	case bytes.Compare(buf[:2], []byte(gzipMagic)) == 0:
+		return gzip.NewReader(br)
+	case bytes.Compare(buf[:3], []byte(b2zipMagic)) == 0:
+		return bzip2.NewReader(br), nil
+	default:
+		return br, nil
+	}
+}
diff --git a/vendor/github.com/google/cayley/internal/dump.go b/vendor/github.com/google/cayley/internal/dump.go
new file mode 100644
index 00000000..e8a0f9a9
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/dump.go
@@ -0,0 +1,61 @@
+package internal
+
+import (
+	"fmt"
+	"os"
+	"compress/gzip"
+	"path/filepath"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/exporter"
+)
+
+// Dump the content of the database into a file based
+// on a few different formats
+func Dump(qs graph.QuadStore, outFile, typ string) error {
+	var f *os.File
+	if outFile == "-" {
+		f = os.Stdout
+	} else {
+		var err error
+		f, err = os.Create(outFile)
+		if err != nil {
+			return fmt.Errorf("could not open file %q: %v", outFile, err)
+		}
+		defer f.Close()
+		fmt.Printf("dumping db to file %q\n", outFile)
+	}
+
+	var export *exporter.Exporter
+	if filepath.Ext(outFile) == ".gz" {
+		gzip := gzip.NewWriter(f)
+		defer gzip.Close()
+		export = exporter.NewExporter(gzip, qs)
+	} else {
+		export = exporter.NewExporter(f, qs)
+	}
+
+	//TODO: add possible support for exporting specific queries only
+	switch typ {
+	case "quad":
+		export.ExportQuad()
+	case "json":
+		export.ExportJson()
+	// gml/graphml experimental
+	case "gml":
+		export.ExportGml()
+	case "graphml":
+		export.ExportGraphml()
+	default:
+		return fmt.Errorf("unknown format %q", typ)
+	}
+	
+	if export.Err() != nil {
+		return export.Err()
+	}
+
+        if outFile != "-" {
+		fmt.Printf("%d entries were written\n", export.Count())
+	}
+	return nil
+}
diff --git a/vendor/github.com/google/cayley/internal/http/docs.go b/vendor/github.com/google/cayley/internal/http/docs.go
new file mode 100644
index 00000000..0d1d2349
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/http/docs.go
@@ -0,0 +1,74 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+
+	"github.com/julienschmidt/httprouter"
+	"github.com/russross/blackfriday"
+)
+
+type DocRequestHandler struct {
+	assets string
+}
+
+func MarkdownWithCSS(input []byte, title string) []byte {
+	// set up the HTML renderer
+	htmlFlags := 0
+	htmlFlags |= blackfriday.HTML_USE_XHTML
+	htmlFlags |= blackfriday.HTML_USE_SMARTYPANTS
+	htmlFlags |= blackfriday.HTML_SMARTYPANTS_FRACTIONS
+	htmlFlags |= blackfriday.HTML_SMARTYPANTS_LATEX_DASHES
+	htmlFlags |= blackfriday.HTML_COMPLETE_PAGE
+	renderer := blackfriday.HtmlRenderer(htmlFlags, title, markdownCSS)
+
+	// set up the parser
+	extensions := 0
+	//extensions |= blackfriday.EXTENSION_NO_INTRA_EMPHASIS
+	extensions |= blackfriday.EXTENSION_TABLES
+	extensions |= blackfriday.EXTENSION_FENCED_CODE
+	extensions |= blackfriday.EXTENSION_AUTOLINK
+	extensions |= blackfriday.EXTENSION_STRIKETHROUGH
+	//extensions |= blackfriday.EXTENSION_SPACE_HEADERS
+	extensions |= blackfriday.EXTENSION_HEADER_IDS
+	extensions |= blackfriday.EXTENSION_LAX_HTML_BLOCKS
+
+	return blackfriday.Markdown(input, renderer, extensions)
+}
+
+func (h *DocRequestHandler) ServeHTTP(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
+	docpage := params.ByName("docpage")
+	if docpage == "" {
+		docpage = "Index"
+	}
+	file, err := os.Open(fmt.Sprintf("%s/docs/%s.md", h.assets, docpage))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusNotFound)
+		return
+	}
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusNoContent)
+		return
+	}
+	output := MarkdownWithCSS(data, fmt.Sprintf("Cayley Docs - %s", docpage))
+	fmt.Fprint(w, string(output))
+}
+
+var markdownCSS = "/static/css/docs.css"
diff --git a/vendor/github.com/google/cayley/internal/http/http.go b/vendor/github.com/google/cayley/internal/http/http.go
new file mode 100644
index 00000000..90691b10
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/http/http.go
@@ -0,0 +1,171 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"flag"
+	"fmt"
+	"html/template"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/barakmich/glog"
+	"github.com/julienschmidt/httprouter"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/internal/config"
+	"github.com/google/cayley/internal/db"
+)
+
+type ResponseHandler func(http.ResponseWriter, *http.Request, httprouter.Params) int
+
+var assetsPath = flag.String("assets", "", "Explicit path to the HTTP assets.")
+var assetsDirs = []string{"templates", "static", "docs"}
+
+func hasAssets(path string) bool {
+	for _, dir := range assetsDirs {
+		if _, err := os.Stat(fmt.Sprint(path, "/", dir)); os.IsNotExist(err) {
+			return false
+		}
+	}
+	return true
+}
+
+func findAssetsPath() string {
+	if *assetsPath != "" {
+		if hasAssets(*assetsPath) {
+			return *assetsPath
+		}
+		glog.Fatalln("Cannot find assets at", *assetsPath, ".")
+	}
+
+	if hasAssets(".") {
+		return "."
+	}
+
+	if hasAssets("..") {
+		return ".."
+	}
+
+	gopathPath := os.ExpandEnv("$GOPATH/src/github.com/google/cayley")
+	if hasAssets(gopathPath) {
+		return gopathPath
+	}
+	glog.Fatalln("Cannot find assets in any of the default search paths. Please run in the same directory, in a Go workspace, or set --assets .")
+	panic("cannot reach")
+}
+
+func LogRequest(handler ResponseHandler) httprouter.Handle {
+	return func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
+		start := time.Now()
+		addr := req.Header.Get("X-Real-IP")
+		if addr == "" {
+			addr = req.Header.Get("X-Forwarded-For")
+			if addr == "" {
+				addr = req.RemoteAddr
+			}
+		}
+		glog.Infof("Started %s %s for %s", req.Method, req.URL.Path, addr)
+		code := handler(w, req, params)
+		glog.Infof("Completed %v %s %s in %v", code, http.StatusText(code), req.URL.Path, time.Since(start))
+
+	}
+}
+
+func jsonResponse(w http.ResponseWriter, code int, err interface{}) int {
+	http.Error(w, fmt.Sprintf("{\"error\" : \"%s\"}", err), code)
+	return code
+}
+
+type TemplateRequestHandler struct {
+	templates *template.Template
+}
+
+func (h *TemplateRequestHandler) ServeHTTP(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
+	uiType := params.ByName("ui_type")
+	if r.URL.Path == "/" {
+		uiType = "query"
+	}
+	err := h.templates.ExecuteTemplate(w, uiType+".html", h)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+type API struct {
+	config *config.Config
+	handle *graph.Handle
+}
+
+func (api *API) GetHandleForRequest(r *http.Request) (*graph.Handle, error) {
+	if !api.config.RequiresHTTPRequestContext {
+		return api.handle, nil
+	}
+
+	opts := make(graph.Options)
+	opts["HTTPRequest"] = r
+
+	qs, err := graph.NewQuadStoreForRequest(api.handle.QuadStore, opts)
+	if err != nil {
+		return nil, err
+	}
+	qw, err := db.OpenQuadWriter(qs, api.config)
+	if err != nil {
+		return nil, err
+	}
+	return &graph.Handle{QuadStore: qs, QuadWriter: qw}, nil
+}
+
+func (api *API) APIv1(r *httprouter.Router) {
+	r.POST("/api/v1/query/:query_lang", LogRequest(api.ServeV1Query))
+	r.POST("/api/v1/shape/:query_lang", LogRequest(api.ServeV1Shape))
+	r.POST("/api/v1/write", LogRequest(api.ServeV1Write))
+	r.POST("/api/v1/write/file/nquad", LogRequest(api.ServeV1WriteNQuad))
+	//TODO(barakmich): /write/text/nquad, which reads from request.body instead of HTML5 file form?
+	r.POST("/api/v1/delete", LogRequest(api.ServeV1Delete))
+}
+
+func SetupRoutes(handle *graph.Handle, cfg *config.Config) {
+	r := httprouter.New()
+	assets := findAssetsPath()
+	if glog.V(2) {
+		glog.V(2).Infoln("Found assets at", assets)
+	}
+	var templates = template.Must(template.ParseGlob(fmt.Sprint(assets, "/templates/*.tmpl")))
+	templates.ParseGlob(fmt.Sprint(assets, "/templates/*.html"))
+	root := &TemplateRequestHandler{templates: templates}
+	docs := &DocRequestHandler{assets: assets}
+	api := &API{config: cfg, handle: handle}
+	api.APIv1(r)
+
+	//m.Use(martini.Static("static", martini.StaticOptions{Prefix: "/static", SkipLogging: true}))
+	//r.Handler("GET", "/static", http.StripPrefix("/static", http.FileServer(http.Dir("static/"))))
+	r.GET("/docs/:docpage", docs.ServeHTTP)
+	r.GET("/ui/:ui_type", root.ServeHTTP)
+	r.GET("/", root.ServeHTTP)
+	http.Handle("/static/", http.StripPrefix("/static", http.FileServer(http.Dir(fmt.Sprint(assets, "/static/")))))
+	http.Handle("/", r)
+}
+
+func Serve(handle *graph.Handle, cfg *config.Config) {
+	SetupRoutes(handle, cfg)
+	glog.Infof("Cayley now listening on %s:%s\n", cfg.ListenHost, cfg.ListenPort)
+	fmt.Printf("Cayley now listening on %s:%s\n", cfg.ListenHost, cfg.ListenPort)
+	err := http.ListenAndServe(fmt.Sprintf("%s:%s", cfg.ListenHost, cfg.ListenPort), nil)
+	if err != nil {
+		glog.Fatal("ListenAndServe: ", err)
+	}
+}
diff --git a/vendor/github.com/google/cayley/internal/http/query.go b/vendor/github.com/google/cayley/internal/http/query.go
new file mode 100644
index 00000000..44d5fb47
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/http/query.go
@@ -0,0 +1,146 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/julienschmidt/httprouter"
+
+	"github.com/google/cayley/query"
+	"github.com/google/cayley/query/gremlin"
+	"github.com/google/cayley/query/mql"
+)
+
+type SuccessQueryWrapper struct {
+	Result interface{} `json:"result"`
+}
+
+type ErrorQueryWrapper struct {
+	Error string `json:"error"`
+}
+
+func WrapErrResult(err error) ([]byte, error) {
+	var wrap ErrorQueryWrapper
+	wrap.Error = err.Error()
+	return json.MarshalIndent(wrap, "", " ")
+}
+
+func WrapResult(result interface{}) ([]byte, error) {
+	var wrap SuccessQueryWrapper
+	wrap.Result = result
+	return json.MarshalIndent(wrap, "", " ")
+}
+
+func Run(q string, ses query.HTTP) (interface{}, error) {
+	c := make(chan interface{}, 5)
+	go ses.Execute(q, c, 100)
+	for res := range c {
+		ses.Collate(res)
+	}
+	return ses.Results()
+}
+
+func GetQueryShape(q string, ses query.HTTP) ([]byte, error) {
+	s, err := ses.ShapeOf(q)
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(s)
+}
+
+// TODO(barakmich): Turn this into proper middleware.
+func (api *API) ServeV1Query(w http.ResponseWriter, r *http.Request, params httprouter.Params) int {
+	h, err := api.GetHandleForRequest(r)
+	var ses query.HTTP
+	switch params.ByName("query_lang") {
+	case "gremlin":
+		ses = gremlin.NewSession(h.QuadStore, api.config.Timeout, false)
+	case "mql":
+		ses = mql.NewSession(h.QuadStore)
+	default:
+		return jsonResponse(w, 400, "Need a query language.")
+	}
+	bodyBytes, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	code := string(bodyBytes)
+	result, err := ses.Parse(code)
+	switch result {
+	case query.Parsed:
+		var output interface{}
+		var bytes []byte
+		var err error
+		output, err = Run(code, ses)
+		if err != nil {
+			bytes, err = WrapErrResult(err)
+			http.Error(w, string(bytes), 400)
+			ses = nil
+			return 400
+		}
+		bytes, err = WrapResult(output)
+		if err != nil {
+			ses = nil
+			return jsonResponse(w, 400, err)
+		}
+		fmt.Fprint(w, string(bytes))
+		ses = nil
+		return 200
+	case query.ParseFail:
+		ses = nil
+		return jsonResponse(w, 400, err)
+	default:
+		ses = nil
+		return jsonResponse(w, 500, "Incomplete data?")
+	}
+}
+
+func (api *API) ServeV1Shape(w http.ResponseWriter, r *http.Request, params httprouter.Params) int {
+	h, err := api.GetHandleForRequest(r)
+	var ses query.HTTP
+	switch params.ByName("query_lang") {
+	case "gremlin":
+		ses = gremlin.NewSession(h.QuadStore, api.config.Timeout, false)
+	case "mql":
+		ses = mql.NewSession(h.QuadStore)
+	default:
+		return jsonResponse(w, 400, "Need a query language.")
+	}
+	bodyBytes, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	code := string(bodyBytes)
+	result, err := ses.Parse(code)
+	switch result {
+	case query.Parsed:
+		var output []byte
+		var err error
+		output, err = GetQueryShape(code, ses)
+		if err != nil {
+			return jsonResponse(w, 400, err)
+		}
+		fmt.Fprint(w, string(output))
+		return 200
+	case query.ParseFail:
+		return jsonResponse(w, 400, err)
+	default:
+		return jsonResponse(w, 500, "Incomplete data?")
+	}
+}
diff --git a/vendor/github.com/google/cayley/internal/http/write.go b/vendor/github.com/google/cayley/internal/http/write.go
new file mode 100644
index 00000000..de2c24be
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/http/write.go
@@ -0,0 +1,144 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+
+	"github.com/barakmich/glog"
+	"github.com/julienschmidt/httprouter"
+
+	"github.com/google/cayley/internal"
+	"github.com/google/cayley/quad"
+	"github.com/google/cayley/quad/cquads"
+)
+
+func ParseJSONToQuadList(jsonBody []byte) ([]quad.Quad, error) {
+	var quads []quad.Quad
+	err := json.Unmarshal(jsonBody, &quads)
+	if err != nil {
+		return nil, err
+	}
+	for i, q := range quads {
+		if !q.IsValid() {
+			return nil, fmt.Errorf("invalid quad at index %d. %s", i, q)
+		}
+	}
+	return quads, nil
+}
+
+func (api *API) ServeV1Write(w http.ResponseWriter, r *http.Request, _ httprouter.Params) int {
+	if api.config.ReadOnly {
+		return jsonResponse(w, 400, "Database is read-only.")
+	}
+	bodyBytes, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	quads, err := ParseJSONToQuadList(bodyBytes)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	h, err := api.GetHandleForRequest(r)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+
+	h.QuadWriter.AddQuadSet(quads)
+	fmt.Fprintf(w, "{\"result\": \"Successfully wrote %d quads.\"}", len(quads))
+	return 200
+}
+
+func (api *API) ServeV1WriteNQuad(w http.ResponseWriter, r *http.Request, params httprouter.Params) int {
+	if api.config.ReadOnly {
+		return jsonResponse(w, 400, "Database is read-only.")
+	}
+
+	formFile, _, err := r.FormFile("NQuadFile")
+	if err != nil {
+		glog.Errorln(err)
+		return jsonResponse(w, 500, "Couldn't read file: "+err.Error())
+	}
+	defer formFile.Close()
+
+	blockSize, blockErr := strconv.ParseInt(r.URL.Query().Get("block_size"), 10, 64)
+	if blockErr != nil {
+		blockSize = int64(api.config.LoadSize)
+	}
+
+	quadReader, err := internal.Decompressor(formFile)
+	// TODO(kortschak) Make this configurable from the web UI.
+	dec := cquads.NewDecoder(quadReader)
+
+	h, err := api.GetHandleForRequest(r)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+
+	var (
+		n     int
+		block = make([]quad.Quad, 0, blockSize)
+	)
+	for {
+		t, err := dec.Unmarshal()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			glog.Fatalln("what can do this here?", err) // FIXME(kortschak)
+		}
+		block = append(block, t)
+		n++
+		if len(block) == cap(block) {
+			h.QuadWriter.AddQuadSet(block)
+			block = block[:0]
+		}
+	}
+	h.QuadWriter.AddQuadSet(block)
+
+	fmt.Fprintf(w, "{\"result\": \"Successfully wrote %d quads.\"}", n)
+
+	return 200
+}
+
+func (api *API) ServeV1Delete(w http.ResponseWriter, r *http.Request, params httprouter.Params) int {
+	if api.config.ReadOnly {
+		return jsonResponse(w, 400, "Database is read-only.")
+	}
+	bodyBytes, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	quads, err := ParseJSONToQuadList(bodyBytes)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	h, err := api.GetHandleForRequest(r)
+	if err != nil {
+		return jsonResponse(w, 400, err)
+	}
+	count := 0
+	for _, q := range quads {
+		h.QuadWriter.RemoveQuad(q)
+		count++
+	}
+	fmt.Fprintf(w, "{\"result\": \"Successfully deleted %d quads.\"}", count)
+	return 200
+}
diff --git a/vendor/github.com/google/cayley/internal/load.go b/vendor/github.com/google/cayley/internal/load.go
new file mode 100644
index 00000000..eb5020ae
--- /dev/null
+++ b/vendor/github.com/google/cayley/internal/load.go
@@ -0,0 +1,82 @@
+package internal
+
+import (
+	"fmt"
+	"io"
+	client "net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/internal/config"
+	"github.com/google/cayley/internal/db"
+	"github.com/google/cayley/quad"
+	"github.com/google/cayley/quad/cquads"
+	"github.com/google/cayley/quad/nquads"
+)
+
+// Load loads a graph from the given path and write it to qw.  See
+// DecompressAndLoad for more information.
+func Load(qw graph.QuadWriter, cfg *config.Config, path, typ string) error {
+	return DecompressAndLoad(qw, cfg, path, typ, db.Load)
+}
+
+// DecompressAndLoad will load or fetch a graph from the given path, decompress
+// it, and then call the given load function to process the decompressed graph.
+// If no loadFn is provided, db.Load is called.
+func DecompressAndLoad(qw graph.QuadWriter, cfg *config.Config, path, typ string, loadFn func(graph.QuadWriter, *config.Config, quad.Unmarshaler) error) error {
+	var r io.Reader
+
+	if path == "" {
+		path = cfg.DatabasePath
+	}
+	if path == "" {
+		return nil
+	}
+	u, err := url.Parse(path)
+	if err != nil || u.Scheme == "file" || u.Scheme == "" {
+		// Don't alter relative URL path or non-URL path parameter.
+		if u.Scheme != "" && err == nil {
+			// Recovery heuristic for mistyping "file://path/to/file".
+			path = filepath.Join(u.Host, u.Path)
+		}
+		f, err := os.Open(path)
+		if err != nil {
+			return fmt.Errorf("could not open file %q: %v", path, err)
+		}
+		defer f.Close()
+		r = f
+	} else {
+		res, err := client.Get(path)
+		if err != nil {
+			return fmt.Errorf("could not get resource <%s>: %v", u, err)
+		}
+		defer res.Body.Close()
+		r = res.Body
+	}
+
+	r, err = Decompressor(r)
+	if err != nil {
+		if err == io.EOF {
+			return nil
+		}
+		return err
+	}
+
+	var dec quad.Unmarshaler
+	switch typ {
+	case "cquad":
+		dec = cquads.NewDecoder(r)
+	case "nquad":
+		dec = nquads.NewDecoder(r)
+	default:
+		return fmt.Errorf("unknown quad format %q", typ)
+	}
+
+	if loadFn != nil {
+		return loadFn(qw, cfg, dec)
+	}
+
+	return db.Load(qw, cfg, dec)
+}
diff --git a/vendor/github.com/google/cayley/quad/cquads/actions.rl b/vendor/github.com/google/cayley/quad/cquads/actions.rl
new file mode 100644
index 00000000..d1e84a3c
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/cquads/actions.rl
@@ -0,0 +1,95 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+%%{
+	machine quads;
+
+	action Escape {
+		isEscaped = true
+	}
+
+	action Quote {
+		isQuoted = true
+	}
+
+	action StartSubject {
+		subject = p
+	}
+
+	action StartPredicate {
+		predicate = p
+	}
+
+	action StartObject {
+		object = p
+	}
+
+	action StartLabel {
+		label = p
+	}
+
+	action SetSubject {
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	}
+
+	action SetPredicate {
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	}
+
+	action SetObject {
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	}
+
+	action SetLabel {
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	}
+
+	action Return {
+		return q, nil
+	}
+
+	action Comment {
+	}
+
+	action Error {
+		if p < len(data) {
+			if r := data[p]; r < unicode.MaxASCII {
+				return q, fmt.Errorf("%v: unexpected rune %q at %d", quad.ErrInvalid, data[p], p)
+			} else {
+				return q, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", quad.ErrInvalid, data[p], data[p], p)
+			}
+		}
+		return q, quad.ErrIncomplete
+	}
+}%%
diff --git a/vendor/github.com/google/cayley/quad/cquads/cquads.go b/vendor/github.com/google/cayley/quad/cquads/cquads.go
new file mode 100644
index 00000000..7b77bf49
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/cquads/cquads.go
@@ -0,0 +1,138 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:generate ragel -Z -G2 parse.rl
+
+// Package cquads implements parsing N-Quads like line-based syntax
+// for RDF datasets.
+//
+// N-Quad parsing is performed as based on a simplified grammar derived from
+// the N-Quads grammar defined by http://www.w3.org/TR/n-quads/.
+//
+// For a complete definition of the grammar, see cquads.rl.
+package cquads
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"strconv"
+
+	"github.com/google/cayley/quad"
+)
+
+// Decoder implements simplified N-Quad document parsing.
+type Decoder struct {
+	r    *bufio.Reader
+	line []byte
+}
+
+// NewDecoder returns an N-Quad decoder that takes its input from the
+// provided io.Reader.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: bufio.NewReader(r)}
+}
+
+// Unmarshal returns the next valid N-Quad as a quad.Quad, or an error.
+func (dec *Decoder) Unmarshal() (quad.Quad, error) {
+	dec.line = dec.line[:0]
+	var line []byte
+	for {
+		for {
+			l, pre, err := dec.r.ReadLine()
+			if err != nil {
+				return quad.Quad{}, err
+			}
+			dec.line = append(dec.line, l...)
+			if !pre {
+				break
+			}
+		}
+		if line = bytes.TrimSpace(dec.line); len(line) != 0 && line[0] != '#' {
+			break
+		}
+		dec.line = dec.line[:0]
+	}
+	q, err := Parse(string(line))
+	if err != nil {
+		return quad.Quad{}, fmt.Errorf("failed to parse %q: %v", dec.line, err)
+	}
+	if !q.IsValid() {
+		return dec.Unmarshal()
+	}
+	return q, nil
+}
+
+func unEscape(r []rune, isQuoted, isEscaped bool) string {
+	if isQuoted {
+		r = r[1 : len(r)-1]
+	}
+	if len(r) >= 2 && r[0] == '<' && r[len(r)-1] == '>' {
+		return string(r[1 : len(r)-1])
+	}
+	if !isEscaped {
+		return string(r)
+	}
+
+	buf := bytes.NewBuffer(make([]byte, 0, len(r)))
+
+	for i := 0; i < len(r); {
+		switch r[i] {
+		case '\\':
+			i++
+			var c byte
+			switch r[i] {
+			case 't':
+				c = '\t'
+			case 'b':
+				c = '\b'
+			case 'n':
+				c = '\n'
+			case 'r':
+				c = '\r'
+			case 'f':
+				c = '\f'
+			case '"':
+				c = '"'
+			case '\'':
+				c = '\''
+			case '\\':
+				c = '\\'
+			case 'u':
+				rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32)
+				if err != nil {
+					panic(fmt.Errorf("internal parser error: %v", err))
+				}
+				buf.WriteRune(rune(rc))
+				i += 5
+				continue
+			case 'U':
+				rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32)
+				if err != nil {
+					panic(fmt.Errorf("internal parser error: %v", err))
+				}
+				buf.WriteRune(rune(rc))
+				i += 9
+				continue
+			}
+			buf.WriteByte(c)
+		default:
+			buf.WriteRune(r[i])
+		}
+		i++
+	}
+
+	return buf.String()
+}
diff --git a/vendor/github.com/google/cayley/quad/cquads/cquads.rl b/vendor/github.com/google/cayley/quad/cquads/cquads.rl
new file mode 100644
index 00000000..53104f01
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/cquads/cquads.rl
@@ -0,0 +1,107 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Ragel gramar definition derived from http://www.w3.org/TR/n-quads/#sec-grammar.
+
+%%{
+	machine quads;
+
+	alphtype rune;
+
+	PN_CHARS_BASE           = [A-Za-z]
+							| 0x00c0 .. 0x00d6
+							| 0x00d8 .. 0x00f6
+							| 0x00f8 .. 0x02ff
+							| 0x0370 .. 0x037d
+							| 0x037f .. 0x1fff
+							| 0x200c .. 0x200d
+							| 0x2070 .. 0x218f
+							| 0x2c00 .. 0x2fef
+							| 0x3001 .. 0xd7ff
+							| 0xf900 .. 0xfdcf
+							| 0xfdf0 .. 0xfffd
+							| 0x10000 .. 0xeffff
+							;
+
+	PN_CHARS_U              = PN_CHARS_BASE | '_' | ':' ;
+
+	PN_CHARS                = PN_CHARS_U
+							| '-'
+							| [0-9]
+							| 0xb7
+							| 0x0300 .. 0x036f
+							| 0x203f .. 0x2040
+							;
+
+	ECHAR                   = ('\\' [tbnrf"'\\]) %Escape ;
+
+	UCHAR                   = ('\\u' xdigit {4}
+							| '\\U' xdigit {8}) %Escape
+							;
+
+	BLANK_NODE_LABEL        = '_:' (PN_CHARS_U | [0-9]) ((PN_CHARS | '.')* PN_CHARS)? ;
+
+	STRING_LITERAL          = (
+							  '!'
+							| '#' .. '['
+							| ']' .. 0x7e
+							| 0x80 .. 0x10ffff
+							| ECHAR
+							| UCHAR)+ - ('_:' | any* '.' | '#' any*)
+							;
+
+	STRING_LITERAL_QUOTE    = '"' (
+							  0x00 .. 0x09
+							| 0x0b .. 0x0c
+							| 0x0e .. '!'
+							| '#' .. '['
+							| ']' .. 0x10ffff
+							| ECHAR
+							| UCHAR)*
+							  '"'
+							;
+
+	IRIREF                  = '<' (
+							  '!'
+							| '#' .. ';'
+							| '='
+							| '?' .. '['
+							| ']'
+							| '_'
+							| 'a' .. 'z'
+							| '~'
+							| 0x80 .. 0x10ffff
+							| UCHAR)*
+							  '>'
+							;
+
+	LANGTAG                 = '@' [a-zA-Z]+ ('-' [a-zA-Z0-9]+)* ;
+
+	whitespace              = [ \t] ;
+
+	literal                 = STRING_LITERAL | STRING_LITERAL_QUOTE % Quote | STRING_LITERAL_QUOTE ('^^' IRIREF | LANGTAG) ;
+
+	subject                 = (literal | BLANK_NODE_LABEL) ;
+	predicate               = literal ;
+	object                  = (literal | BLANK_NODE_LABEL) ;
+	graphLabel              = (literal | BLANK_NODE_LABEL) ;
+
+	statement := (
+					whitespace*  subject    >StartSubject   %SetSubject
+					whitespace+  predicate  >StartPredicate %SetPredicate
+					whitespace+  object     >StartObject    %SetObject
+					(whitespace+ graphLabel >StartLabel     %SetLabel)?
+					whitespace*  '.' whitespace* ('#' any*)? >Comment
+				 ) %Return @!Error ;
+}%%
diff --git a/vendor/github.com/google/cayley/quad/cquads/parse.go b/vendor/github.com/google/cayley/quad/cquads/parse.go
new file mode 100644
index 00000000..a977562e
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/cquads/parse.go
@@ -0,0 +1,6717 @@
+
+// line 1 "parse.rl"
+// GO SOURCE FILE MACHINE GENERATED BY RAGEL; DO NOT EDIT
+
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cquads
+
+import (
+	"fmt"
+	"unicode"
+
+	"github.com/google/cayley/quad"
+)
+
+
+// line 30 "parse.go"
+const quads_start int = 1
+const quads_first_final int = 178
+const quads_error int = 0
+
+const quads_en_statement int = 1
+
+
+// line 34 "parse.rl"
+
+
+// Parse returns a valid quad.Quad or a non-nil error. Parse does
+// handle comments except where the comment placement does not prevent
+// a complete valid quad.Quad from being defined.
+func Parse(statement string) (quad.Quad, error) {
+	data := []rune(statement)
+
+	var (
+		cs, p int
+		pe    = len(data)
+		eof   = pe
+
+		subject   = -1
+		predicate = -1
+		object    = -1
+		label     = -1
+
+		isEscaped bool
+		isQuoted  bool
+
+		q quad.Quad
+	)
+
+	
+// line 64 "parse.go"
+	{
+	cs = quads_start
+	}
+
+// line 59 "parse.rl"
+
+	
+// line 72 "parse.go"
+	{
+	if p == pe {
+		goto _test_eof
+	}
+	switch cs {
+	case 1:
+		goto st_case_1
+	case 0:
+		goto st_case_0
+	case 2:
+		goto st_case_2
+	case 3:
+		goto st_case_3
+	case 4:
+		goto st_case_4
+	case 5:
+		goto st_case_5
+	case 6:
+		goto st_case_6
+	case 7:
+		goto st_case_7
+	case 8:
+		goto st_case_8
+	case 9:
+		goto st_case_9
+	case 178:
+		goto st_case_178
+	case 179:
+		goto st_case_179
+	case 180:
+		goto st_case_180
+	case 181:
+		goto st_case_181
+	case 182:
+		goto st_case_182
+	case 183:
+		goto st_case_183
+	case 184:
+		goto st_case_184
+	case 185:
+		goto st_case_185
+	case 186:
+		goto st_case_186
+	case 187:
+		goto st_case_187
+	case 188:
+		goto st_case_188
+	case 189:
+		goto st_case_189
+	case 190:
+		goto st_case_190
+	case 191:
+		goto st_case_191
+	case 192:
+		goto st_case_192
+	case 193:
+		goto st_case_193
+	case 194:
+		goto st_case_194
+	case 195:
+		goto st_case_195
+	case 10:
+		goto st_case_10
+	case 11:
+		goto st_case_11
+	case 12:
+		goto st_case_12
+	case 13:
+		goto st_case_13
+	case 14:
+		goto st_case_14
+	case 15:
+		goto st_case_15
+	case 16:
+		goto st_case_16
+	case 17:
+		goto st_case_17
+	case 18:
+		goto st_case_18
+	case 19:
+		goto st_case_19
+	case 20:
+		goto st_case_20
+	case 21:
+		goto st_case_21
+	case 22:
+		goto st_case_22
+	case 23:
+		goto st_case_23
+	case 24:
+		goto st_case_24
+	case 25:
+		goto st_case_25
+	case 26:
+		goto st_case_26
+	case 27:
+		goto st_case_27
+	case 28:
+		goto st_case_28
+	case 29:
+		goto st_case_29
+	case 30:
+		goto st_case_30
+	case 31:
+		goto st_case_31
+	case 32:
+		goto st_case_32
+	case 33:
+		goto st_case_33
+	case 34:
+		goto st_case_34
+	case 35:
+		goto st_case_35
+	case 36:
+		goto st_case_36
+	case 37:
+		goto st_case_37
+	case 38:
+		goto st_case_38
+	case 39:
+		goto st_case_39
+	case 40:
+		goto st_case_40
+	case 41:
+		goto st_case_41
+	case 42:
+		goto st_case_42
+	case 43:
+		goto st_case_43
+	case 44:
+		goto st_case_44
+	case 45:
+		goto st_case_45
+	case 46:
+		goto st_case_46
+	case 47:
+		goto st_case_47
+	case 48:
+		goto st_case_48
+	case 49:
+		goto st_case_49
+	case 50:
+		goto st_case_50
+	case 51:
+		goto st_case_51
+	case 196:
+		goto st_case_196
+	case 197:
+		goto st_case_197
+	case 198:
+		goto st_case_198
+	case 199:
+		goto st_case_199
+	case 200:
+		goto st_case_200
+	case 201:
+		goto st_case_201
+	case 202:
+		goto st_case_202
+	case 203:
+		goto st_case_203
+	case 204:
+		goto st_case_204
+	case 205:
+		goto st_case_205
+	case 206:
+		goto st_case_206
+	case 207:
+		goto st_case_207
+	case 208:
+		goto st_case_208
+	case 209:
+		goto st_case_209
+	case 210:
+		goto st_case_210
+	case 211:
+		goto st_case_211
+	case 212:
+		goto st_case_212
+	case 213:
+		goto st_case_213
+	case 214:
+		goto st_case_214
+	case 215:
+		goto st_case_215
+	case 216:
+		goto st_case_216
+	case 217:
+		goto st_case_217
+	case 218:
+		goto st_case_218
+	case 219:
+		goto st_case_219
+	case 220:
+		goto st_case_220
+	case 221:
+		goto st_case_221
+	case 222:
+		goto st_case_222
+	case 223:
+		goto st_case_223
+	case 224:
+		goto st_case_224
+	case 225:
+		goto st_case_225
+	case 226:
+		goto st_case_226
+	case 227:
+		goto st_case_227
+	case 228:
+		goto st_case_228
+	case 229:
+		goto st_case_229
+	case 230:
+		goto st_case_230
+	case 231:
+		goto st_case_231
+	case 232:
+		goto st_case_232
+	case 233:
+		goto st_case_233
+	case 234:
+		goto st_case_234
+	case 235:
+		goto st_case_235
+	case 236:
+		goto st_case_236
+	case 237:
+		goto st_case_237
+	case 238:
+		goto st_case_238
+	case 239:
+		goto st_case_239
+	case 240:
+		goto st_case_240
+	case 241:
+		goto st_case_241
+	case 52:
+		goto st_case_52
+	case 53:
+		goto st_case_53
+	case 54:
+		goto st_case_54
+	case 55:
+		goto st_case_55
+	case 56:
+		goto st_case_56
+	case 57:
+		goto st_case_57
+	case 58:
+		goto st_case_58
+	case 59:
+		goto st_case_59
+	case 60:
+		goto st_case_60
+	case 61:
+		goto st_case_61
+	case 62:
+		goto st_case_62
+	case 63:
+		goto st_case_63
+	case 64:
+		goto st_case_64
+	case 65:
+		goto st_case_65
+	case 66:
+		goto st_case_66
+	case 67:
+		goto st_case_67
+	case 68:
+		goto st_case_68
+	case 69:
+		goto st_case_69
+	case 70:
+		goto st_case_70
+	case 71:
+		goto st_case_71
+	case 72:
+		goto st_case_72
+	case 73:
+		goto st_case_73
+	case 74:
+		goto st_case_74
+	case 75:
+		goto st_case_75
+	case 76:
+		goto st_case_76
+	case 77:
+		goto st_case_77
+	case 78:
+		goto st_case_78
+	case 79:
+		goto st_case_79
+	case 80:
+		goto st_case_80
+	case 81:
+		goto st_case_81
+	case 82:
+		goto st_case_82
+	case 83:
+		goto st_case_83
+	case 84:
+		goto st_case_84
+	case 85:
+		goto st_case_85
+	case 86:
+		goto st_case_86
+	case 87:
+		goto st_case_87
+	case 88:
+		goto st_case_88
+	case 89:
+		goto st_case_89
+	case 90:
+		goto st_case_90
+	case 91:
+		goto st_case_91
+	case 92:
+		goto st_case_92
+	case 93:
+		goto st_case_93
+	case 94:
+		goto st_case_94
+	case 95:
+		goto st_case_95
+	case 96:
+		goto st_case_96
+	case 97:
+		goto st_case_97
+	case 98:
+		goto st_case_98
+	case 99:
+		goto st_case_99
+	case 100:
+		goto st_case_100
+	case 101:
+		goto st_case_101
+	case 102:
+		goto st_case_102
+	case 103:
+		goto st_case_103
+	case 104:
+		goto st_case_104
+	case 105:
+		goto st_case_105
+	case 106:
+		goto st_case_106
+	case 107:
+		goto st_case_107
+	case 108:
+		goto st_case_108
+	case 109:
+		goto st_case_109
+	case 110:
+		goto st_case_110
+	case 111:
+		goto st_case_111
+	case 112:
+		goto st_case_112
+	case 113:
+		goto st_case_113
+	case 114:
+		goto st_case_114
+	case 115:
+		goto st_case_115
+	case 116:
+		goto st_case_116
+	case 117:
+		goto st_case_117
+	case 118:
+		goto st_case_118
+	case 119:
+		goto st_case_119
+	case 120:
+		goto st_case_120
+	case 121:
+		goto st_case_121
+	case 122:
+		goto st_case_122
+	case 123:
+		goto st_case_123
+	case 124:
+		goto st_case_124
+	case 125:
+		goto st_case_125
+	case 126:
+		goto st_case_126
+	case 127:
+		goto st_case_127
+	case 128:
+		goto st_case_128
+	case 129:
+		goto st_case_129
+	case 130:
+		goto st_case_130
+	case 131:
+		goto st_case_131
+	case 132:
+		goto st_case_132
+	case 133:
+		goto st_case_133
+	case 134:
+		goto st_case_134
+	case 135:
+		goto st_case_135
+	case 136:
+		goto st_case_136
+	case 137:
+		goto st_case_137
+	case 138:
+		goto st_case_138
+	case 139:
+		goto st_case_139
+	case 140:
+		goto st_case_140
+	case 141:
+		goto st_case_141
+	case 142:
+		goto st_case_142
+	case 143:
+		goto st_case_143
+	case 144:
+		goto st_case_144
+	case 145:
+		goto st_case_145
+	case 146:
+		goto st_case_146
+	case 147:
+		goto st_case_147
+	case 148:
+		goto st_case_148
+	case 149:
+		goto st_case_149
+	case 150:
+		goto st_case_150
+	case 151:
+		goto st_case_151
+	case 152:
+		goto st_case_152
+	case 153:
+		goto st_case_153
+	case 154:
+		goto st_case_154
+	case 155:
+		goto st_case_155
+	case 156:
+		goto st_case_156
+	case 157:
+		goto st_case_157
+	case 158:
+		goto st_case_158
+	case 159:
+		goto st_case_159
+	case 160:
+		goto st_case_160
+	case 161:
+		goto st_case_161
+	case 162:
+		goto st_case_162
+	case 163:
+		goto st_case_163
+	case 164:
+		goto st_case_164
+	case 165:
+		goto st_case_165
+	case 166:
+		goto st_case_166
+	case 167:
+		goto st_case_167
+	case 168:
+		goto st_case_168
+	case 169:
+		goto st_case_169
+	case 170:
+		goto st_case_170
+	case 171:
+		goto st_case_171
+	case 172:
+		goto st_case_172
+	case 173:
+		goto st_case_173
+	case 174:
+		goto st_case_174
+	case 175:
+		goto st_case_175
+	case 176:
+		goto st_case_176
+	case 177:
+		goto st_case_177
+	}
+	goto st_out
+	st1:
+		if p++; p == pe {
+			goto _test_eof1
+		}
+	st_case_1:
+		switch data[p] {
+		case 9:
+			goto st1
+		case 32:
+			goto st1
+		case 33:
+			goto tr2
+		case 34:
+			goto tr3
+		case 46:
+			goto tr4
+		case 92:
+			goto tr5
+		case 95:
+			goto tr6
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr2
+			}
+		case data[p] >= 36:
+			goto tr2
+		}
+		goto tr0
+tr0:
+// line 85 "actions.rl"
+
+
+		if p < len(data) {
+			if r := data[p]; r < unicode.MaxASCII {
+				return q, fmt.Errorf("%v: unexpected rune %q at %d", quad.ErrInvalid, data[p], p)
+			} else {
+				return q, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", quad.ErrInvalid, data[p], data[p], p)
+			}
+		}
+		return q, quad.ErrIncomplete
+	
+	goto st0
+// line 608 "parse.go"
+st_case_0:
+	st0:
+		cs = 0
+		goto _out
+tr2:
+// line 26 "actions.rl"
+
+
+		subject = p
+	
+	goto st2
+tr203:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st2
+	st2:
+		if p++; p == pe {
+			goto _test_eof2
+		}
+	st_case_2:
+// line 632 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		case 33:
+			goto st2
+		case 46:
+			goto st136
+		case 92:
+			goto st137
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st2
+			}
+		case data[p] >= 35:
+			goto st2
+		}
+		goto tr0
+tr7:
+// line 42 "actions.rl"
+
+
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st3
+tr202:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 42 "actions.rl"
+
+
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st3
+tr215:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 42 "actions.rl"
+
+
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st3
+	st3:
+		if p++; p == pe {
+			goto _test_eof3
+		}
+	st_case_3:
+// line 705 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st3
+		case 32:
+			goto st3
+		case 33:
+			goto tr12
+		case 34:
+			goto tr13
+		case 46:
+			goto tr14
+		case 92:
+			goto tr15
+		case 95:
+			goto tr16
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr12
+			}
+		case data[p] >= 36:
+			goto tr12
+		}
+		goto tr0
+tr12:
+// line 30 "actions.rl"
+
+
+		predicate = p
+	
+	goto st4
+tr153:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st4
+	st4:
+		if p++; p == pe {
+			goto _test_eof4
+		}
+	st_case_4:
+// line 750 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr17
+		case 32:
+			goto tr17
+		case 33:
+			goto st4
+		case 46:
+			goto st94
+		case 92:
+			goto st95
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st4
+			}
+		case data[p] >= 35:
+			goto st4
+		}
+		goto tr0
+tr17:
+// line 51 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st5
+tr152:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 51 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st5
+tr165:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 51 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st5
+	st5:
+		if p++; p == pe {
+			goto _test_eof5
+		}
+	st_case_5:
+// line 823 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st5
+		case 32:
+			goto st5
+		case 33:
+			goto tr22
+		case 34:
+			goto tr23
+		case 46:
+			goto tr24
+		case 92:
+			goto tr25
+		case 95:
+			goto tr26
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr22
+			}
+		case data[p] >= 36:
+			goto tr22
+		}
+		goto tr0
+tr22:
+// line 34 "actions.rl"
+
+
+		object = p
+	
+	goto st6
+tr101:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st6
+	st6:
+		if p++; p == pe {
+			goto _test_eof6
+		}
+	st_case_6:
+// line 868 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr27
+		case 32:
+			goto tr27
+		case 33:
+			goto st6
+		case 46:
+			goto tr29
+		case 92:
+			goto st53
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st6
+			}
+		case data[p] >= 35:
+			goto st6
+		}
+		goto tr0
+tr27:
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st7
+tr100:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st7
+tr113:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st7
+	st7:
+		if p++; p == pe {
+			goto _test_eof7
+		}
+	st_case_7:
+// line 941 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st7
+		case 32:
+			goto st7
+		case 33:
+			goto tr32
+		case 34:
+			goto tr33
+		case 46:
+			goto tr34
+		case 92:
+			goto tr35
+		case 95:
+			goto tr36
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr32
+			}
+		case data[p] >= 36:
+			goto tr32
+		}
+		goto tr0
+tr32:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st8
+tr48:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st8
+	st8:
+		if p++; p == pe {
+			goto _test_eof8
+		}
+	st_case_8:
+// line 986 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr37
+		case 32:
+			goto tr37
+		case 33:
+			goto st8
+		case 46:
+			goto tr39
+		case 92:
+			goto st11
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st8
+			}
+		case data[p] >= 35:
+			goto st8
+		}
+		goto tr0
+tr37:
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st9
+tr47:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st9
+tr60:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st9
+	st9:
+		if p++; p == pe {
+			goto _test_eof9
+		}
+	st_case_9:
+// line 1059 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st9
+		case 32:
+			goto st9
+		case 46:
+			goto st178
+		}
+		goto tr0
+tr119:
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st178
+tr66:
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st178
+tr61:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st178
+tr114:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st178
+	st178:
+		if p++; p == pe {
+			goto _test_eof178
+		}
+	st_case_178:
+// line 1132 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st178
+		case 32:
+			goto st178
+		case 35:
+			goto tr250
+		}
+		goto st0
+tr250:
+// line 82 "actions.rl"
+
+
+	
+	goto st179
+	st179:
+		if p++; p == pe {
+			goto _test_eof179
+		}
+	st_case_179:
+// line 1153 "parse.go"
+		goto st179
+tr34:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st180
+tr39:
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st180
+tr49:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st180
+	st180:
+		if p++; p == pe {
+			goto _test_eof180
+		}
+	st_case_180:
+// line 1196 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st178
+		case 32:
+			goto st178
+		case 33:
+			goto st8
+		case 35:
+			goto tr252
+		case 46:
+			goto st10
+		case 92:
+			goto st11
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st8
+			}
+		case data[p] >= 36:
+			goto st8
+		}
+		goto st0
+tr279:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st181
+tr264:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st181
+tr252:
+// line 82 "actions.rl"
+
+
+	
+	goto st181
+	st181:
+		if p++; p == pe {
+			goto _test_eof181
+		}
+	st_case_181:
+// line 1245 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr253
+		case 32:
+			goto tr253
+		case 33:
+			goto st181
+		case 46:
+			goto tr255
+		case 92:
+			goto st186
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st181
+			}
+		case data[p] >= 35:
+			goto st181
+		}
+		goto st179
+tr253:
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st182
+tr263:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st182
+tr287:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st182
+	st182:
+		if p++; p == pe {
+			goto _test_eof182
+		}
+	st_case_182:
+// line 1318 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st182
+		case 32:
+			goto st182
+		case 46:
+			goto st183
+		}
+		goto st179
+tr293:
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st183
+tr288:
+// line 22 "actions.rl"
+
+
+		isQuoted = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st183
+	st183:
+		if p++; p == pe {
+			goto _test_eof183
+		}
+	st_case_183:
+// line 1362 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st183
+		case 32:
+			goto st183
+		case 35:
+			goto tr250
+		}
+		goto st179
+tr281:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st184
+tr255:
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st184
+tr265:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 69 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st184
+	st184:
+		if p++; p == pe {
+			goto _test_eof184
+		}
+	st_case_184:
+// line 1413 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st183
+		case 32:
+			goto st183
+		case 33:
+			goto st181
+		case 35:
+			goto tr252
+		case 46:
+			goto st185
+		case 92:
+			goto st186
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st181
+			}
+		case data[p] >= 36:
+			goto st181
+		}
+		goto st179
+	st185:
+		if p++; p == pe {
+			goto _test_eof185
+		}
+	st_case_185:
+		switch data[p] {
+		case 33:
+			goto st181
+		case 46:
+			goto st185
+		case 92:
+			goto st186
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st181
+			}
+		case data[p] >= 35:
+			goto st181
+		}
+		goto st179
+tr282:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st186
+tr266:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st186
+	st186:
+		if p++; p == pe {
+			goto _test_eof186
+		}
+	st_case_186:
+// line 1478 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st187
+		case 39:
+			goto st187
+		case 85:
+			goto st188
+		case 92:
+			goto st187
+		case 98:
+			goto st187
+		case 102:
+			goto st187
+		case 110:
+			goto st187
+		case 114:
+			goto st187
+		case 116:
+			goto st187
+		case 117:
+			goto st192
+		}
+		goto st179
+	st187:
+		if p++; p == pe {
+			goto _test_eof187
+		}
+	st_case_187:
+		switch data[p] {
+		case 9:
+			goto tr263
+		case 32:
+			goto tr263
+		case 33:
+			goto tr264
+		case 46:
+			goto tr265
+		case 92:
+			goto tr266
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr264
+			}
+		case data[p] >= 35:
+			goto tr264
+		}
+		goto st179
+	st188:
+		if p++; p == pe {
+			goto _test_eof188
+		}
+	st_case_188:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st189
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st189
+			}
+		default:
+			goto st189
+		}
+		goto st179
+	st189:
+		if p++; p == pe {
+			goto _test_eof189
+		}
+	st_case_189:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st190
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st190
+			}
+		default:
+			goto st190
+		}
+		goto st179
+	st190:
+		if p++; p == pe {
+			goto _test_eof190
+		}
+	st_case_190:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st191
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st191
+			}
+		default:
+			goto st191
+		}
+		goto st179
+	st191:
+		if p++; p == pe {
+			goto _test_eof191
+		}
+	st_case_191:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st192
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st192
+			}
+		default:
+			goto st192
+		}
+		goto st179
+	st192:
+		if p++; p == pe {
+			goto _test_eof192
+		}
+	st_case_192:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st193
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st193
+			}
+		default:
+			goto st193
+		}
+		goto st179
+	st193:
+		if p++; p == pe {
+			goto _test_eof193
+		}
+	st_case_193:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st194
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st194
+			}
+		default:
+			goto st194
+		}
+		goto st179
+	st194:
+		if p++; p == pe {
+			goto _test_eof194
+		}
+	st_case_194:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st195
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st195
+			}
+		default:
+			goto st195
+		}
+		goto st179
+	st195:
+		if p++; p == pe {
+			goto _test_eof195
+		}
+	st_case_195:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st187
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st187
+			}
+		default:
+			goto st187
+		}
+		goto st179
+	st10:
+		if p++; p == pe {
+			goto _test_eof10
+		}
+	st_case_10:
+		switch data[p] {
+		case 33:
+			goto st8
+		case 46:
+			goto st10
+		case 92:
+			goto st11
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st8
+			}
+		case data[p] >= 35:
+			goto st8
+		}
+		goto tr0
+tr35:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st11
+tr50:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st11
+	st11:
+		if p++; p == pe {
+			goto _test_eof11
+		}
+	st_case_11:
+// line 1713 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st12
+		case 39:
+			goto st12
+		case 85:
+			goto st13
+		case 92:
+			goto st12
+		case 98:
+			goto st12
+		case 102:
+			goto st12
+		case 110:
+			goto st12
+		case 114:
+			goto st12
+		case 116:
+			goto st12
+		case 117:
+			goto st17
+		}
+		goto tr0
+	st12:
+		if p++; p == pe {
+			goto _test_eof12
+		}
+	st_case_12:
+		switch data[p] {
+		case 9:
+			goto tr47
+		case 32:
+			goto tr47
+		case 33:
+			goto tr48
+		case 46:
+			goto tr49
+		case 92:
+			goto tr50
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr48
+			}
+		case data[p] >= 35:
+			goto tr48
+		}
+		goto tr0
+	st13:
+		if p++; p == pe {
+			goto _test_eof13
+		}
+	st_case_13:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st14
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st14
+			}
+		default:
+			goto st14
+		}
+		goto tr0
+	st14:
+		if p++; p == pe {
+			goto _test_eof14
+		}
+	st_case_14:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st15
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st15
+			}
+		default:
+			goto st15
+		}
+		goto tr0
+	st15:
+		if p++; p == pe {
+			goto _test_eof15
+		}
+	st_case_15:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st16
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st16
+			}
+		default:
+			goto st16
+		}
+		goto tr0
+	st16:
+		if p++; p == pe {
+			goto _test_eof16
+		}
+	st_case_16:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st17
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st17
+			}
+		default:
+			goto st17
+		}
+		goto tr0
+	st17:
+		if p++; p == pe {
+			goto _test_eof17
+		}
+	st_case_17:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st18
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st18
+			}
+		default:
+			goto st18
+		}
+		goto tr0
+	st18:
+		if p++; p == pe {
+			goto _test_eof18
+		}
+	st_case_18:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st19
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st19
+			}
+		default:
+			goto st19
+		}
+		goto tr0
+	st19:
+		if p++; p == pe {
+			goto _test_eof19
+		}
+	st_case_19:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st20
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st20
+			}
+		default:
+			goto st20
+		}
+		goto tr0
+	st20:
+		if p++; p == pe {
+			goto _test_eof20
+		}
+	st_case_20:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st12
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st12
+			}
+		default:
+			goto st12
+		}
+		goto tr0
+tr33:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st21
+tr87:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st21
+	st21:
+		if p++; p == pe {
+			goto _test_eof21
+		}
+	st_case_21:
+// line 1926 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st22
+		case 92:
+			goto st41
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto st21
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto st21
+			}
+		default:
+			goto st21
+		}
+		goto tr0
+tr88:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st22
+	st22:
+		if p++; p == pe {
+			goto _test_eof22
+		}
+	st_case_22:
+// line 1958 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr60
+		case 32:
+			goto tr60
+		case 46:
+			goto tr61
+		case 64:
+			goto st23
+		case 94:
+			goto st27
+		}
+		goto tr0
+	st23:
+		if p++; p == pe {
+			goto _test_eof23
+		}
+	st_case_23:
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st24
+			}
+		case data[p] >= 65:
+			goto st24
+		}
+		goto tr0
+	st24:
+		if p++; p == pe {
+			goto _test_eof24
+		}
+	st_case_24:
+		switch data[p] {
+		case 9:
+			goto tr37
+		case 32:
+			goto tr37
+		case 45:
+			goto st25
+		case 46:
+			goto tr66
+		}
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st24
+			}
+		case data[p] >= 65:
+			goto st24
+		}
+		goto tr0
+	st25:
+		if p++; p == pe {
+			goto _test_eof25
+		}
+	st_case_25:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st26
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st26
+			}
+		default:
+			goto st26
+		}
+		goto tr0
+	st26:
+		if p++; p == pe {
+			goto _test_eof26
+		}
+	st_case_26:
+		switch data[p] {
+		case 9:
+			goto tr37
+		case 32:
+			goto tr37
+		case 45:
+			goto st25
+		case 46:
+			goto tr66
+		}
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st26
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st26
+			}
+		default:
+			goto st26
+		}
+		goto tr0
+	st27:
+		if p++; p == pe {
+			goto _test_eof27
+		}
+	st_case_27:
+		if data[p] == 94 {
+			goto st28
+		}
+		goto tr0
+	st28:
+		if p++; p == pe {
+			goto _test_eof28
+		}
+	st_case_28:
+		if data[p] == 60 {
+			goto st29
+		}
+		goto tr0
+tr81:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st29
+	st29:
+		if p++; p == pe {
+			goto _test_eof29
+		}
+	st_case_29:
+// line 2086 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st29
+		case 62:
+			goto st30
+		case 92:
+			goto st31
+		case 95:
+			goto st29
+		case 126:
+			goto st29
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st29
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st29
+				}
+			case data[p] >= 97:
+				goto st29
+			}
+		default:
+			goto st29
+		}
+		goto tr0
+tr82:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st30
+	st30:
+		if p++; p == pe {
+			goto _test_eof30
+		}
+	st_case_30:
+// line 2129 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr37
+		case 32:
+			goto tr37
+		case 46:
+			goto tr66
+		}
+		goto tr0
+tr83:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st31
+	st31:
+		if p++; p == pe {
+			goto _test_eof31
+		}
+	st_case_31:
+// line 2151 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st32
+		case 117:
+			goto st36
+		}
+		goto tr0
+	st32:
+		if p++; p == pe {
+			goto _test_eof32
+		}
+	st_case_32:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st33
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st33
+			}
+		default:
+			goto st33
+		}
+		goto tr0
+	st33:
+		if p++; p == pe {
+			goto _test_eof33
+		}
+	st_case_33:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st34
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st34
+			}
+		default:
+			goto st34
+		}
+		goto tr0
+	st34:
+		if p++; p == pe {
+			goto _test_eof34
+		}
+	st_case_34:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st35
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st35
+			}
+		default:
+			goto st35
+		}
+		goto tr0
+	st35:
+		if p++; p == pe {
+			goto _test_eof35
+		}
+	st_case_35:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st36
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st36
+			}
+		default:
+			goto st36
+		}
+		goto tr0
+	st36:
+		if p++; p == pe {
+			goto _test_eof36
+		}
+	st_case_36:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st37
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st37
+			}
+		default:
+			goto st37
+		}
+		goto tr0
+	st37:
+		if p++; p == pe {
+			goto _test_eof37
+		}
+	st_case_37:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st38
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st38
+			}
+		default:
+			goto st38
+		}
+		goto tr0
+	st38:
+		if p++; p == pe {
+			goto _test_eof38
+		}
+	st_case_38:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st39
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st39
+			}
+		default:
+			goto st39
+		}
+		goto tr0
+	st39:
+		if p++; p == pe {
+			goto _test_eof39
+		}
+	st_case_39:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st40
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st40
+			}
+		default:
+			goto st40
+		}
+		goto tr0
+	st40:
+		if p++; p == pe {
+			goto _test_eof40
+		}
+	st_case_40:
+		switch data[p] {
+		case 33:
+			goto tr81
+		case 62:
+			goto tr82
+		case 92:
+			goto tr83
+		case 95:
+			goto tr81
+		case 126:
+			goto tr81
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr81
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr81
+				}
+			case data[p] >= 97:
+				goto tr81
+			}
+		default:
+			goto tr81
+		}
+		goto tr0
+tr89:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st41
+	st41:
+		if p++; p == pe {
+			goto _test_eof41
+		}
+	st_case_41:
+// line 2350 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st42
+		case 39:
+			goto st42
+		case 85:
+			goto st43
+		case 92:
+			goto st42
+		case 98:
+			goto st42
+		case 102:
+			goto st42
+		case 110:
+			goto st42
+		case 114:
+			goto st42
+		case 116:
+			goto st42
+		case 117:
+			goto st47
+		}
+		goto tr0
+	st42:
+		if p++; p == pe {
+			goto _test_eof42
+		}
+	st_case_42:
+		switch data[p] {
+		case 34:
+			goto tr88
+		case 92:
+			goto tr89
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto tr87
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto tr87
+			}
+		default:
+			goto tr87
+		}
+		goto tr0
+	st43:
+		if p++; p == pe {
+			goto _test_eof43
+		}
+	st_case_43:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st44
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st44
+			}
+		default:
+			goto st44
+		}
+		goto tr0
+	st44:
+		if p++; p == pe {
+			goto _test_eof44
+		}
+	st_case_44:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st45
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st45
+			}
+		default:
+			goto st45
+		}
+		goto tr0
+	st45:
+		if p++; p == pe {
+			goto _test_eof45
+		}
+	st_case_45:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st46
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st46
+			}
+		default:
+			goto st46
+		}
+		goto tr0
+	st46:
+		if p++; p == pe {
+			goto _test_eof46
+		}
+	st_case_46:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st47
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st47
+			}
+		default:
+			goto st47
+		}
+		goto tr0
+	st47:
+		if p++; p == pe {
+			goto _test_eof47
+		}
+	st_case_47:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st48
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st48
+			}
+		default:
+			goto st48
+		}
+		goto tr0
+	st48:
+		if p++; p == pe {
+			goto _test_eof48
+		}
+	st_case_48:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st49
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st49
+			}
+		default:
+			goto st49
+		}
+		goto tr0
+	st49:
+		if p++; p == pe {
+			goto _test_eof49
+		}
+	st_case_49:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st50
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st50
+			}
+		default:
+			goto st50
+		}
+		goto tr0
+	st50:
+		if p++; p == pe {
+			goto _test_eof50
+		}
+	st_case_50:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st42
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st42
+			}
+		default:
+			goto st42
+		}
+		goto tr0
+tr36:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st51
+	st51:
+		if p++; p == pe {
+			goto _test_eof51
+		}
+	st_case_51:
+// line 2554 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr37
+		case 32:
+			goto tr37
+		case 33:
+			goto st8
+		case 46:
+			goto tr39
+		case 58:
+			goto st10
+		case 92:
+			goto st11
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st8
+			}
+		case data[p] >= 35:
+			goto st8
+		}
+		goto tr0
+tr29:
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st196
+tr102:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st196
+	st196:
+		if p++; p == pe {
+			goto _test_eof196
+		}
+	st_case_196:
+// line 2612 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st178
+		case 32:
+			goto st178
+		case 33:
+			goto st6
+		case 35:
+			goto tr273
+		case 46:
+			goto st52
+		case 92:
+			goto st53
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st6
+			}
+		case data[p] >= 36:
+			goto st6
+		}
+		goto st0
+tr328:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st197
+tr273:
+// line 82 "actions.rl"
+
+
+	
+	goto st197
+	st197:
+		if p++; p == pe {
+			goto _test_eof197
+		}
+	st_case_197:
+// line 2654 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr274
+		case 32:
+			goto tr274
+		case 33:
+			goto st197
+		case 46:
+			goto tr276
+		case 92:
+			goto st232
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st197
+			}
+		case data[p] >= 35:
+			goto st197
+		}
+		goto st179
+tr274:
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st198
+tr327:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st198
+	st198:
+		if p++; p == pe {
+			goto _test_eof198
+		}
+	st_case_198:
+// line 2710 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st198
+		case 32:
+			goto st198
+		case 33:
+			goto tr279
+		case 34:
+			goto tr280
+		case 46:
+			goto tr281
+		case 92:
+			goto tr282
+		case 95:
+			goto tr283
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr279
+			}
+		case data[p] >= 36:
+			goto tr279
+		}
+		goto st179
+tr280:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st199
+tr314:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st199
+	st199:
+		if p++; p == pe {
+			goto _test_eof199
+		}
+	st_case_199:
+// line 2755 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st200
+		case 92:
+			goto st219
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto st199
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto st199
+			}
+		default:
+			goto st199
+		}
+		goto st179
+tr315:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st200
+	st200:
+		if p++; p == pe {
+			goto _test_eof200
+		}
+	st_case_200:
+// line 2787 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr287
+		case 32:
+			goto tr287
+		case 46:
+			goto tr288
+		case 64:
+			goto st201
+		case 94:
+			goto st205
+		}
+		goto st179
+	st201:
+		if p++; p == pe {
+			goto _test_eof201
+		}
+	st_case_201:
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st202
+			}
+		case data[p] >= 65:
+			goto st202
+		}
+		goto st179
+	st202:
+		if p++; p == pe {
+			goto _test_eof202
+		}
+	st_case_202:
+		switch data[p] {
+		case 9:
+			goto tr253
+		case 32:
+			goto tr253
+		case 45:
+			goto st203
+		case 46:
+			goto tr293
+		}
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st202
+			}
+		case data[p] >= 65:
+			goto st202
+		}
+		goto st179
+	st203:
+		if p++; p == pe {
+			goto _test_eof203
+		}
+	st_case_203:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st204
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st204
+			}
+		default:
+			goto st204
+		}
+		goto st179
+	st204:
+		if p++; p == pe {
+			goto _test_eof204
+		}
+	st_case_204:
+		switch data[p] {
+		case 9:
+			goto tr253
+		case 32:
+			goto tr253
+		case 45:
+			goto st203
+		case 46:
+			goto tr293
+		}
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st204
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st204
+			}
+		default:
+			goto st204
+		}
+		goto st179
+	st205:
+		if p++; p == pe {
+			goto _test_eof205
+		}
+	st_case_205:
+		if data[p] == 94 {
+			goto st206
+		}
+		goto st179
+	st206:
+		if p++; p == pe {
+			goto _test_eof206
+		}
+	st_case_206:
+		if data[p] == 60 {
+			goto st207
+		}
+		goto st179
+tr308:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st207
+	st207:
+		if p++; p == pe {
+			goto _test_eof207
+		}
+	st_case_207:
+// line 2915 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st207
+		case 62:
+			goto st208
+		case 92:
+			goto st209
+		case 95:
+			goto st207
+		case 126:
+			goto st207
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st207
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st207
+				}
+			case data[p] >= 97:
+				goto st207
+			}
+		default:
+			goto st207
+		}
+		goto st179
+tr309:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st208
+	st208:
+		if p++; p == pe {
+			goto _test_eof208
+		}
+	st_case_208:
+// line 2958 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr253
+		case 32:
+			goto tr253
+		case 46:
+			goto tr293
+		}
+		goto st179
+tr310:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st209
+	st209:
+		if p++; p == pe {
+			goto _test_eof209
+		}
+	st_case_209:
+// line 2980 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st210
+		case 117:
+			goto st214
+		}
+		goto st179
+	st210:
+		if p++; p == pe {
+			goto _test_eof210
+		}
+	st_case_210:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st211
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st211
+			}
+		default:
+			goto st211
+		}
+		goto st179
+	st211:
+		if p++; p == pe {
+			goto _test_eof211
+		}
+	st_case_211:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st212
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st212
+			}
+		default:
+			goto st212
+		}
+		goto st179
+	st212:
+		if p++; p == pe {
+			goto _test_eof212
+		}
+	st_case_212:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st213
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st213
+			}
+		default:
+			goto st213
+		}
+		goto st179
+	st213:
+		if p++; p == pe {
+			goto _test_eof213
+		}
+	st_case_213:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st214
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st214
+			}
+		default:
+			goto st214
+		}
+		goto st179
+	st214:
+		if p++; p == pe {
+			goto _test_eof214
+		}
+	st_case_214:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st215
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st215
+			}
+		default:
+			goto st215
+		}
+		goto st179
+	st215:
+		if p++; p == pe {
+			goto _test_eof215
+		}
+	st_case_215:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st216
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st216
+			}
+		default:
+			goto st216
+		}
+		goto st179
+	st216:
+		if p++; p == pe {
+			goto _test_eof216
+		}
+	st_case_216:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st217
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st217
+			}
+		default:
+			goto st217
+		}
+		goto st179
+	st217:
+		if p++; p == pe {
+			goto _test_eof217
+		}
+	st_case_217:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st218
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st218
+			}
+		default:
+			goto st218
+		}
+		goto st179
+	st218:
+		if p++; p == pe {
+			goto _test_eof218
+		}
+	st_case_218:
+		switch data[p] {
+		case 33:
+			goto tr308
+		case 62:
+			goto tr309
+		case 92:
+			goto tr310
+		case 95:
+			goto tr308
+		case 126:
+			goto tr308
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr308
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr308
+				}
+			case data[p] >= 97:
+				goto tr308
+			}
+		default:
+			goto tr308
+		}
+		goto st179
+tr316:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st219
+	st219:
+		if p++; p == pe {
+			goto _test_eof219
+		}
+	st_case_219:
+// line 3179 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st220
+		case 39:
+			goto st220
+		case 85:
+			goto st221
+		case 92:
+			goto st220
+		case 98:
+			goto st220
+		case 102:
+			goto st220
+		case 110:
+			goto st220
+		case 114:
+			goto st220
+		case 116:
+			goto st220
+		case 117:
+			goto st225
+		}
+		goto st179
+	st220:
+		if p++; p == pe {
+			goto _test_eof220
+		}
+	st_case_220:
+		switch data[p] {
+		case 34:
+			goto tr315
+		case 92:
+			goto tr316
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto tr314
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto tr314
+			}
+		default:
+			goto tr314
+		}
+		goto st179
+	st221:
+		if p++; p == pe {
+			goto _test_eof221
+		}
+	st_case_221:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st222
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st222
+			}
+		default:
+			goto st222
+		}
+		goto st179
+	st222:
+		if p++; p == pe {
+			goto _test_eof222
+		}
+	st_case_222:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st223
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st223
+			}
+		default:
+			goto st223
+		}
+		goto st179
+	st223:
+		if p++; p == pe {
+			goto _test_eof223
+		}
+	st_case_223:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st224
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st224
+			}
+		default:
+			goto st224
+		}
+		goto st179
+	st224:
+		if p++; p == pe {
+			goto _test_eof224
+		}
+	st_case_224:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st225
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st225
+			}
+		default:
+			goto st225
+		}
+		goto st179
+	st225:
+		if p++; p == pe {
+			goto _test_eof225
+		}
+	st_case_225:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st226
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st226
+			}
+		default:
+			goto st226
+		}
+		goto st179
+	st226:
+		if p++; p == pe {
+			goto _test_eof226
+		}
+	st_case_226:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st227
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st227
+			}
+		default:
+			goto st227
+		}
+		goto st179
+	st227:
+		if p++; p == pe {
+			goto _test_eof227
+		}
+	st_case_227:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st228
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st228
+			}
+		default:
+			goto st228
+		}
+		goto st179
+	st228:
+		if p++; p == pe {
+			goto _test_eof228
+		}
+	st_case_228:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st220
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st220
+			}
+		default:
+			goto st220
+		}
+		goto st179
+tr283:
+// line 38 "actions.rl"
+
+
+		label = p
+	
+	goto st229
+	st229:
+		if p++; p == pe {
+			goto _test_eof229
+		}
+	st_case_229:
+// line 3383 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr253
+		case 32:
+			goto tr253
+		case 33:
+			goto st181
+		case 46:
+			goto tr255
+		case 58:
+			goto st185
+		case 92:
+			goto st186
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st181
+			}
+		case data[p] >= 35:
+			goto st181
+		}
+		goto st179
+tr276:
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st230
+tr329:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+// line 60 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isQuoted, isEscaped)
+		isEscaped = false
+		isQuoted = false
+	
+	goto st230
+	st230:
+		if p++; p == pe {
+			goto _test_eof230
+		}
+	st_case_230:
+// line 3441 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st183
+		case 32:
+			goto st183
+		case 33:
+			goto st197
+		case 35:
+			goto tr273
+		case 46:
+			goto st231
+		case 92:
+			goto st232
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st197
+			}
+		case data[p] >= 36:
+			goto st197
+		}
+		goto st179
+	st231:
+		if p++; p == pe {
+			goto _test_eof231
+		}
+	st_case_231:
+		switch data[p] {
+		case 33:
+			goto st197
+		case 46:
+			goto st231
+		case 92:
+			goto st232
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st197
+			}
+		case data[p] >= 35:
+			goto st197
+		}
+		goto st179
+tr330:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st232
+	st232:
+		if p++; p == pe {
+			goto _test_eof232
+		}
+	st_case_232:
+// line 3499 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st233
+		case 39:
+			goto st233
+		case 85:
+			goto st234
+		case 92:
+			goto st233
+		case 98:
+			goto st233
+		case 102:
+			goto st233
+		case 110:
+			goto st233
+		case 114:
+			goto st233
+		case 116:
+			goto st233
+		case 117:
+			goto st238
+		}
+		goto st179
+	st233:
+		if p++; p == pe {
+			goto _test_eof233
+		}
+	st_case_233:
+		switch data[p] {
+		case 9:
+			goto tr327
+		case 32:
+			goto tr327
+		case 33:
+			goto tr328
+		case 46:
+			goto tr329
+		case 92:
+			goto tr330
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr328
+			}
+		case data[p] >= 35:
+			goto tr328
+		}
+		goto st179
+	st234:
+		if p++; p == pe {
+			goto _test_eof234
+		}
+	st_case_234:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st235
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st235
+			}
+		default:
+			goto st235
+		}
+		goto st179
+	st235:
+		if p++; p == pe {
+			goto _test_eof235
+		}
+	st_case_235:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st236
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st236
+			}
+		default:
+			goto st236
+		}
+		goto st179
+	st236:
+		if p++; p == pe {
+			goto _test_eof236
+		}
+	st_case_236:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st237
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st237
+			}
+		default:
+			goto st237
+		}
+		goto st179
+	st237:
+		if p++; p == pe {
+			goto _test_eof237
+		}
+	st_case_237:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st238
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st238
+			}
+		default:
+			goto st238
+		}
+		goto st179
+	st238:
+		if p++; p == pe {
+			goto _test_eof238
+		}
+	st_case_238:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st239
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st239
+			}
+		default:
+			goto st239
+		}
+		goto st179
+	st239:
+		if p++; p == pe {
+			goto _test_eof239
+		}
+	st_case_239:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st240
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st240
+			}
+		default:
+			goto st240
+		}
+		goto st179
+	st240:
+		if p++; p == pe {
+			goto _test_eof240
+		}
+	st_case_240:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st241
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st241
+			}
+		default:
+			goto st241
+		}
+		goto st179
+	st241:
+		if p++; p == pe {
+			goto _test_eof241
+		}
+	st_case_241:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st233
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st233
+			}
+		default:
+			goto st233
+		}
+		goto st179
+tr24:
+// line 34 "actions.rl"
+
+
+		object = p
+	
+	goto st52
+	st52:
+		if p++; p == pe {
+			goto _test_eof52
+		}
+	st_case_52:
+// line 3705 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st6
+		case 46:
+			goto st52
+		case 92:
+			goto st53
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st6
+			}
+		case data[p] >= 35:
+			goto st6
+		}
+		goto tr0
+tr25:
+// line 34 "actions.rl"
+
+
+		object = p
+	
+	goto st53
+tr103:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st53
+	st53:
+		if p++; p == pe {
+			goto _test_eof53
+		}
+	st_case_53:
+// line 3742 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st54
+		case 39:
+			goto st54
+		case 85:
+			goto st55
+		case 92:
+			goto st54
+		case 98:
+			goto st54
+		case 102:
+			goto st54
+		case 110:
+			goto st54
+		case 114:
+			goto st54
+		case 116:
+			goto st54
+		case 117:
+			goto st59
+		}
+		goto tr0
+	st54:
+		if p++; p == pe {
+			goto _test_eof54
+		}
+	st_case_54:
+		switch data[p] {
+		case 9:
+			goto tr100
+		case 32:
+			goto tr100
+		case 33:
+			goto tr101
+		case 46:
+			goto tr102
+		case 92:
+			goto tr103
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr101
+			}
+		case data[p] >= 35:
+			goto tr101
+		}
+		goto tr0
+	st55:
+		if p++; p == pe {
+			goto _test_eof55
+		}
+	st_case_55:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st56
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st56
+			}
+		default:
+			goto st56
+		}
+		goto tr0
+	st56:
+		if p++; p == pe {
+			goto _test_eof56
+		}
+	st_case_56:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st57
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st57
+			}
+		default:
+			goto st57
+		}
+		goto tr0
+	st57:
+		if p++; p == pe {
+			goto _test_eof57
+		}
+	st_case_57:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st58
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st58
+			}
+		default:
+			goto st58
+		}
+		goto tr0
+	st58:
+		if p++; p == pe {
+			goto _test_eof58
+		}
+	st_case_58:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st59
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st59
+			}
+		default:
+			goto st59
+		}
+		goto tr0
+	st59:
+		if p++; p == pe {
+			goto _test_eof59
+		}
+	st_case_59:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st60
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st60
+			}
+		default:
+			goto st60
+		}
+		goto tr0
+	st60:
+		if p++; p == pe {
+			goto _test_eof60
+		}
+	st_case_60:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st61
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st61
+			}
+		default:
+			goto st61
+		}
+		goto tr0
+	st61:
+		if p++; p == pe {
+			goto _test_eof61
+		}
+	st_case_61:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st62
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st62
+			}
+		default:
+			goto st62
+		}
+		goto tr0
+	st62:
+		if p++; p == pe {
+			goto _test_eof62
+		}
+	st_case_62:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st54
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st54
+			}
+		default:
+			goto st54
+		}
+		goto tr0
+tr23:
+// line 34 "actions.rl"
+
+
+		object = p
+	
+	goto st63
+tr140:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st63
+	st63:
+		if p++; p == pe {
+			goto _test_eof63
+		}
+	st_case_63:
+// line 3955 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st64
+		case 92:
+			goto st83
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto st63
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto st63
+			}
+		default:
+			goto st63
+		}
+		goto tr0
+tr141:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st64
+	st64:
+		if p++; p == pe {
+			goto _test_eof64
+		}
+	st_case_64:
+// line 3987 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr113
+		case 32:
+			goto tr113
+		case 46:
+			goto tr114
+		case 64:
+			goto st65
+		case 94:
+			goto st69
+		}
+		goto tr0
+	st65:
+		if p++; p == pe {
+			goto _test_eof65
+		}
+	st_case_65:
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st66
+			}
+		case data[p] >= 65:
+			goto st66
+		}
+		goto tr0
+	st66:
+		if p++; p == pe {
+			goto _test_eof66
+		}
+	st_case_66:
+		switch data[p] {
+		case 9:
+			goto tr27
+		case 32:
+			goto tr27
+		case 45:
+			goto st67
+		case 46:
+			goto tr119
+		}
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st66
+			}
+		case data[p] >= 65:
+			goto st66
+		}
+		goto tr0
+	st67:
+		if p++; p == pe {
+			goto _test_eof67
+		}
+	st_case_67:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st68
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st68
+			}
+		default:
+			goto st68
+		}
+		goto tr0
+	st68:
+		if p++; p == pe {
+			goto _test_eof68
+		}
+	st_case_68:
+		switch data[p] {
+		case 9:
+			goto tr27
+		case 32:
+			goto tr27
+		case 45:
+			goto st67
+		case 46:
+			goto tr119
+		}
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st68
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st68
+			}
+		default:
+			goto st68
+		}
+		goto tr0
+	st69:
+		if p++; p == pe {
+			goto _test_eof69
+		}
+	st_case_69:
+		if data[p] == 94 {
+			goto st70
+		}
+		goto tr0
+	st70:
+		if p++; p == pe {
+			goto _test_eof70
+		}
+	st_case_70:
+		if data[p] == 60 {
+			goto st71
+		}
+		goto tr0
+tr134:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st71
+	st71:
+		if p++; p == pe {
+			goto _test_eof71
+		}
+	st_case_71:
+// line 4115 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st71
+		case 62:
+			goto st72
+		case 92:
+			goto st73
+		case 95:
+			goto st71
+		case 126:
+			goto st71
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st71
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st71
+				}
+			case data[p] >= 97:
+				goto st71
+			}
+		default:
+			goto st71
+		}
+		goto tr0
+tr135:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st72
+	st72:
+		if p++; p == pe {
+			goto _test_eof72
+		}
+	st_case_72:
+// line 4158 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr27
+		case 32:
+			goto tr27
+		case 46:
+			goto tr119
+		}
+		goto tr0
+tr136:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st73
+	st73:
+		if p++; p == pe {
+			goto _test_eof73
+		}
+	st_case_73:
+// line 4180 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st74
+		case 117:
+			goto st78
+		}
+		goto tr0
+	st74:
+		if p++; p == pe {
+			goto _test_eof74
+		}
+	st_case_74:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st75
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st75
+			}
+		default:
+			goto st75
+		}
+		goto tr0
+	st75:
+		if p++; p == pe {
+			goto _test_eof75
+		}
+	st_case_75:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st76
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st76
+			}
+		default:
+			goto st76
+		}
+		goto tr0
+	st76:
+		if p++; p == pe {
+			goto _test_eof76
+		}
+	st_case_76:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st77
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st77
+			}
+		default:
+			goto st77
+		}
+		goto tr0
+	st77:
+		if p++; p == pe {
+			goto _test_eof77
+		}
+	st_case_77:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st78
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st78
+			}
+		default:
+			goto st78
+		}
+		goto tr0
+	st78:
+		if p++; p == pe {
+			goto _test_eof78
+		}
+	st_case_78:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st79
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st79
+			}
+		default:
+			goto st79
+		}
+		goto tr0
+	st79:
+		if p++; p == pe {
+			goto _test_eof79
+		}
+	st_case_79:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st80
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st80
+			}
+		default:
+			goto st80
+		}
+		goto tr0
+	st80:
+		if p++; p == pe {
+			goto _test_eof80
+		}
+	st_case_80:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st81
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st81
+			}
+		default:
+			goto st81
+		}
+		goto tr0
+	st81:
+		if p++; p == pe {
+			goto _test_eof81
+		}
+	st_case_81:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st82
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st82
+			}
+		default:
+			goto st82
+		}
+		goto tr0
+	st82:
+		if p++; p == pe {
+			goto _test_eof82
+		}
+	st_case_82:
+		switch data[p] {
+		case 33:
+			goto tr134
+		case 62:
+			goto tr135
+		case 92:
+			goto tr136
+		case 95:
+			goto tr134
+		case 126:
+			goto tr134
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr134
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr134
+				}
+			case data[p] >= 97:
+				goto tr134
+			}
+		default:
+			goto tr134
+		}
+		goto tr0
+tr142:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st83
+	st83:
+		if p++; p == pe {
+			goto _test_eof83
+		}
+	st_case_83:
+// line 4379 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st84
+		case 39:
+			goto st84
+		case 85:
+			goto st85
+		case 92:
+			goto st84
+		case 98:
+			goto st84
+		case 102:
+			goto st84
+		case 110:
+			goto st84
+		case 114:
+			goto st84
+		case 116:
+			goto st84
+		case 117:
+			goto st89
+		}
+		goto tr0
+	st84:
+		if p++; p == pe {
+			goto _test_eof84
+		}
+	st_case_84:
+		switch data[p] {
+		case 34:
+			goto tr141
+		case 92:
+			goto tr142
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto tr140
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto tr140
+			}
+		default:
+			goto tr140
+		}
+		goto tr0
+	st85:
+		if p++; p == pe {
+			goto _test_eof85
+		}
+	st_case_85:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st86
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st86
+			}
+		default:
+			goto st86
+		}
+		goto tr0
+	st86:
+		if p++; p == pe {
+			goto _test_eof86
+		}
+	st_case_86:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st87
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st87
+			}
+		default:
+			goto st87
+		}
+		goto tr0
+	st87:
+		if p++; p == pe {
+			goto _test_eof87
+		}
+	st_case_87:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st88
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st88
+			}
+		default:
+			goto st88
+		}
+		goto tr0
+	st88:
+		if p++; p == pe {
+			goto _test_eof88
+		}
+	st_case_88:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st89
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st89
+			}
+		default:
+			goto st89
+		}
+		goto tr0
+	st89:
+		if p++; p == pe {
+			goto _test_eof89
+		}
+	st_case_89:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st90
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st90
+			}
+		default:
+			goto st90
+		}
+		goto tr0
+	st90:
+		if p++; p == pe {
+			goto _test_eof90
+		}
+	st_case_90:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st91
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st91
+			}
+		default:
+			goto st91
+		}
+		goto tr0
+	st91:
+		if p++; p == pe {
+			goto _test_eof91
+		}
+	st_case_91:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st92
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st92
+			}
+		default:
+			goto st92
+		}
+		goto tr0
+	st92:
+		if p++; p == pe {
+			goto _test_eof92
+		}
+	st_case_92:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st84
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st84
+			}
+		default:
+			goto st84
+		}
+		goto tr0
+tr26:
+// line 34 "actions.rl"
+
+
+		object = p
+	
+	goto st93
+	st93:
+		if p++; p == pe {
+			goto _test_eof93
+		}
+	st_case_93:
+// line 4583 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr27
+		case 32:
+			goto tr27
+		case 33:
+			goto st6
+		case 46:
+			goto tr29
+		case 58:
+			goto st52
+		case 92:
+			goto st53
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st6
+			}
+		case data[p] >= 35:
+			goto st6
+		}
+		goto tr0
+tr14:
+// line 30 "actions.rl"
+
+
+		predicate = p
+	
+	goto st94
+tr154:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st94
+	st94:
+		if p++; p == pe {
+			goto _test_eof94
+		}
+	st_case_94:
+// line 4626 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st4
+		case 46:
+			goto st94
+		case 92:
+			goto st95
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st4
+			}
+		case data[p] >= 35:
+			goto st4
+		}
+		goto tr0
+tr15:
+// line 30 "actions.rl"
+
+
+		predicate = p
+	
+	goto st95
+tr155:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st95
+	st95:
+		if p++; p == pe {
+			goto _test_eof95
+		}
+	st_case_95:
+// line 4663 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st96
+		case 39:
+			goto st96
+		case 85:
+			goto st97
+		case 92:
+			goto st96
+		case 98:
+			goto st96
+		case 102:
+			goto st96
+		case 110:
+			goto st96
+		case 114:
+			goto st96
+		case 116:
+			goto st96
+		case 117:
+			goto st101
+		}
+		goto tr0
+	st96:
+		if p++; p == pe {
+			goto _test_eof96
+		}
+	st_case_96:
+		switch data[p] {
+		case 9:
+			goto tr152
+		case 32:
+			goto tr152
+		case 33:
+			goto tr153
+		case 46:
+			goto tr154
+		case 92:
+			goto tr155
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr153
+			}
+		case data[p] >= 35:
+			goto tr153
+		}
+		goto tr0
+	st97:
+		if p++; p == pe {
+			goto _test_eof97
+		}
+	st_case_97:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st98
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st98
+			}
+		default:
+			goto st98
+		}
+		goto tr0
+	st98:
+		if p++; p == pe {
+			goto _test_eof98
+		}
+	st_case_98:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st99
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st99
+			}
+		default:
+			goto st99
+		}
+		goto tr0
+	st99:
+		if p++; p == pe {
+			goto _test_eof99
+		}
+	st_case_99:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st100
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st100
+			}
+		default:
+			goto st100
+		}
+		goto tr0
+	st100:
+		if p++; p == pe {
+			goto _test_eof100
+		}
+	st_case_100:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st101
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st101
+			}
+		default:
+			goto st101
+		}
+		goto tr0
+	st101:
+		if p++; p == pe {
+			goto _test_eof101
+		}
+	st_case_101:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st102
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st102
+			}
+		default:
+			goto st102
+		}
+		goto tr0
+	st102:
+		if p++; p == pe {
+			goto _test_eof102
+		}
+	st_case_102:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st103
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st103
+			}
+		default:
+			goto st103
+		}
+		goto tr0
+	st103:
+		if p++; p == pe {
+			goto _test_eof103
+		}
+	st_case_103:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st104
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st104
+			}
+		default:
+			goto st104
+		}
+		goto tr0
+	st104:
+		if p++; p == pe {
+			goto _test_eof104
+		}
+	st_case_104:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st96
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st96
+			}
+		default:
+			goto st96
+		}
+		goto tr0
+tr13:
+// line 30 "actions.rl"
+
+
+		predicate = p
+	
+	goto st105
+tr190:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st105
+	st105:
+		if p++; p == pe {
+			goto _test_eof105
+		}
+	st_case_105:
+// line 4876 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st106
+		case 92:
+			goto st125
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto st105
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto st105
+			}
+		default:
+			goto st105
+		}
+		goto tr0
+tr191:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st106
+	st106:
+		if p++; p == pe {
+			goto _test_eof106
+		}
+	st_case_106:
+// line 4908 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr165
+		case 32:
+			goto tr165
+		case 64:
+			goto st107
+		case 94:
+			goto st111
+		}
+		goto tr0
+	st107:
+		if p++; p == pe {
+			goto _test_eof107
+		}
+	st_case_107:
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st108
+			}
+		case data[p] >= 65:
+			goto st108
+		}
+		goto tr0
+	st108:
+		if p++; p == pe {
+			goto _test_eof108
+		}
+	st_case_108:
+		switch data[p] {
+		case 9:
+			goto tr17
+		case 32:
+			goto tr17
+		case 45:
+			goto st109
+		}
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st108
+			}
+		case data[p] >= 65:
+			goto st108
+		}
+		goto tr0
+	st109:
+		if p++; p == pe {
+			goto _test_eof109
+		}
+	st_case_109:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st110
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st110
+			}
+		default:
+			goto st110
+		}
+		goto tr0
+	st110:
+		if p++; p == pe {
+			goto _test_eof110
+		}
+	st_case_110:
+		switch data[p] {
+		case 9:
+			goto tr17
+		case 32:
+			goto tr17
+		case 45:
+			goto st109
+		}
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st110
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st110
+			}
+		default:
+			goto st110
+		}
+		goto tr0
+	st111:
+		if p++; p == pe {
+			goto _test_eof111
+		}
+	st_case_111:
+		if data[p] == 94 {
+			goto st112
+		}
+		goto tr0
+	st112:
+		if p++; p == pe {
+			goto _test_eof112
+		}
+	st_case_112:
+		if data[p] == 60 {
+			goto st113
+		}
+		goto tr0
+tr184:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st113
+	st113:
+		if p++; p == pe {
+			goto _test_eof113
+		}
+	st_case_113:
+// line 5030 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st113
+		case 62:
+			goto st114
+		case 92:
+			goto st115
+		case 95:
+			goto st113
+		case 126:
+			goto st113
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st113
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st113
+				}
+			case data[p] >= 97:
+				goto st113
+			}
+		default:
+			goto st113
+		}
+		goto tr0
+tr185:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st114
+	st114:
+		if p++; p == pe {
+			goto _test_eof114
+		}
+	st_case_114:
+// line 5073 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr17
+		case 32:
+			goto tr17
+		}
+		goto tr0
+tr186:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st115
+	st115:
+		if p++; p == pe {
+			goto _test_eof115
+		}
+	st_case_115:
+// line 5093 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st116
+		case 117:
+			goto st120
+		}
+		goto tr0
+	st116:
+		if p++; p == pe {
+			goto _test_eof116
+		}
+	st_case_116:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st117
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st117
+			}
+		default:
+			goto st117
+		}
+		goto tr0
+	st117:
+		if p++; p == pe {
+			goto _test_eof117
+		}
+	st_case_117:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st118
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st118
+			}
+		default:
+			goto st118
+		}
+		goto tr0
+	st118:
+		if p++; p == pe {
+			goto _test_eof118
+		}
+	st_case_118:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st119
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st119
+			}
+		default:
+			goto st119
+		}
+		goto tr0
+	st119:
+		if p++; p == pe {
+			goto _test_eof119
+		}
+	st_case_119:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st120
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st120
+			}
+		default:
+			goto st120
+		}
+		goto tr0
+	st120:
+		if p++; p == pe {
+			goto _test_eof120
+		}
+	st_case_120:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st121
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st121
+			}
+		default:
+			goto st121
+		}
+		goto tr0
+	st121:
+		if p++; p == pe {
+			goto _test_eof121
+		}
+	st_case_121:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st122
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st122
+			}
+		default:
+			goto st122
+		}
+		goto tr0
+	st122:
+		if p++; p == pe {
+			goto _test_eof122
+		}
+	st_case_122:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st123
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st123
+			}
+		default:
+			goto st123
+		}
+		goto tr0
+	st123:
+		if p++; p == pe {
+			goto _test_eof123
+		}
+	st_case_123:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st124
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st124
+			}
+		default:
+			goto st124
+		}
+		goto tr0
+	st124:
+		if p++; p == pe {
+			goto _test_eof124
+		}
+	st_case_124:
+		switch data[p] {
+		case 33:
+			goto tr184
+		case 62:
+			goto tr185
+		case 92:
+			goto tr186
+		case 95:
+			goto tr184
+		case 126:
+			goto tr184
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr184
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr184
+				}
+			case data[p] >= 97:
+				goto tr184
+			}
+		default:
+			goto tr184
+		}
+		goto tr0
+tr192:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st125
+	st125:
+		if p++; p == pe {
+			goto _test_eof125
+		}
+	st_case_125:
+// line 5292 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st126
+		case 39:
+			goto st126
+		case 85:
+			goto st127
+		case 92:
+			goto st126
+		case 98:
+			goto st126
+		case 102:
+			goto st126
+		case 110:
+			goto st126
+		case 114:
+			goto st126
+		case 116:
+			goto st126
+		case 117:
+			goto st131
+		}
+		goto tr0
+	st126:
+		if p++; p == pe {
+			goto _test_eof126
+		}
+	st_case_126:
+		switch data[p] {
+		case 34:
+			goto tr191
+		case 92:
+			goto tr192
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto tr190
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto tr190
+			}
+		default:
+			goto tr190
+		}
+		goto tr0
+	st127:
+		if p++; p == pe {
+			goto _test_eof127
+		}
+	st_case_127:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st128
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st128
+			}
+		default:
+			goto st128
+		}
+		goto tr0
+	st128:
+		if p++; p == pe {
+			goto _test_eof128
+		}
+	st_case_128:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st129
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st129
+			}
+		default:
+			goto st129
+		}
+		goto tr0
+	st129:
+		if p++; p == pe {
+			goto _test_eof129
+		}
+	st_case_129:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st130
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st130
+			}
+		default:
+			goto st130
+		}
+		goto tr0
+	st130:
+		if p++; p == pe {
+			goto _test_eof130
+		}
+	st_case_130:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st131
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st131
+			}
+		default:
+			goto st131
+		}
+		goto tr0
+	st131:
+		if p++; p == pe {
+			goto _test_eof131
+		}
+	st_case_131:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st132
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st132
+			}
+		default:
+			goto st132
+		}
+		goto tr0
+	st132:
+		if p++; p == pe {
+			goto _test_eof132
+		}
+	st_case_132:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st133
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st133
+			}
+		default:
+			goto st133
+		}
+		goto tr0
+	st133:
+		if p++; p == pe {
+			goto _test_eof133
+		}
+	st_case_133:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st134
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st134
+			}
+		default:
+			goto st134
+		}
+		goto tr0
+	st134:
+		if p++; p == pe {
+			goto _test_eof134
+		}
+	st_case_134:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st126
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st126
+			}
+		default:
+			goto st126
+		}
+		goto tr0
+tr16:
+// line 30 "actions.rl"
+
+
+		predicate = p
+	
+	goto st135
+	st135:
+		if p++; p == pe {
+			goto _test_eof135
+		}
+	st_case_135:
+// line 5496 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr17
+		case 32:
+			goto tr17
+		case 33:
+			goto st4
+		case 46:
+			goto st94
+		case 58:
+			goto st94
+		case 92:
+			goto st95
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st4
+			}
+		case data[p] >= 35:
+			goto st4
+		}
+		goto tr0
+tr4:
+// line 26 "actions.rl"
+
+
+		subject = p
+	
+	goto st136
+tr204:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st136
+	st136:
+		if p++; p == pe {
+			goto _test_eof136
+		}
+	st_case_136:
+// line 5539 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st2
+		case 46:
+			goto st136
+		case 92:
+			goto st137
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st2
+			}
+		case data[p] >= 35:
+			goto st2
+		}
+		goto tr0
+tr5:
+// line 26 "actions.rl"
+
+
+		subject = p
+	
+	goto st137
+tr205:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st137
+	st137:
+		if p++; p == pe {
+			goto _test_eof137
+		}
+	st_case_137:
+// line 5576 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st138
+		case 39:
+			goto st138
+		case 85:
+			goto st139
+		case 92:
+			goto st138
+		case 98:
+			goto st138
+		case 102:
+			goto st138
+		case 110:
+			goto st138
+		case 114:
+			goto st138
+		case 116:
+			goto st138
+		case 117:
+			goto st143
+		}
+		goto tr0
+	st138:
+		if p++; p == pe {
+			goto _test_eof138
+		}
+	st_case_138:
+		switch data[p] {
+		case 9:
+			goto tr202
+		case 32:
+			goto tr202
+		case 33:
+			goto tr203
+		case 46:
+			goto tr204
+		case 92:
+			goto tr205
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto tr203
+			}
+		case data[p] >= 35:
+			goto tr203
+		}
+		goto tr0
+	st139:
+		if p++; p == pe {
+			goto _test_eof139
+		}
+	st_case_139:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st140
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st140
+			}
+		default:
+			goto st140
+		}
+		goto tr0
+	st140:
+		if p++; p == pe {
+			goto _test_eof140
+		}
+	st_case_140:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st141
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st141
+			}
+		default:
+			goto st141
+		}
+		goto tr0
+	st141:
+		if p++; p == pe {
+			goto _test_eof141
+		}
+	st_case_141:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st142
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st142
+			}
+		default:
+			goto st142
+		}
+		goto tr0
+	st142:
+		if p++; p == pe {
+			goto _test_eof142
+		}
+	st_case_142:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st143
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st143
+			}
+		default:
+			goto st143
+		}
+		goto tr0
+	st143:
+		if p++; p == pe {
+			goto _test_eof143
+		}
+	st_case_143:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st144
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st144
+			}
+		default:
+			goto st144
+		}
+		goto tr0
+	st144:
+		if p++; p == pe {
+			goto _test_eof144
+		}
+	st_case_144:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st145
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st145
+			}
+		default:
+			goto st145
+		}
+		goto tr0
+	st145:
+		if p++; p == pe {
+			goto _test_eof145
+		}
+	st_case_145:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st146
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st146
+			}
+		default:
+			goto st146
+		}
+		goto tr0
+	st146:
+		if p++; p == pe {
+			goto _test_eof146
+		}
+	st_case_146:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st138
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st138
+			}
+		default:
+			goto st138
+		}
+		goto tr0
+tr3:
+// line 26 "actions.rl"
+
+
+		subject = p
+	
+	goto st147
+tr240:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st147
+	st147:
+		if p++; p == pe {
+			goto _test_eof147
+		}
+	st_case_147:
+// line 5789 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st148
+		case 92:
+			goto st167
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto st147
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto st147
+			}
+		default:
+			goto st147
+		}
+		goto tr0
+tr241:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st148
+	st148:
+		if p++; p == pe {
+			goto _test_eof148
+		}
+	st_case_148:
+// line 5821 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr215
+		case 32:
+			goto tr215
+		case 64:
+			goto st149
+		case 94:
+			goto st153
+		}
+		goto tr0
+	st149:
+		if p++; p == pe {
+			goto _test_eof149
+		}
+	st_case_149:
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st150
+			}
+		case data[p] >= 65:
+			goto st150
+		}
+		goto tr0
+	st150:
+		if p++; p == pe {
+			goto _test_eof150
+		}
+	st_case_150:
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		case 45:
+			goto st151
+		}
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st150
+			}
+		case data[p] >= 65:
+			goto st150
+		}
+		goto tr0
+	st151:
+		if p++; p == pe {
+			goto _test_eof151
+		}
+	st_case_151:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st152
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st152
+			}
+		default:
+			goto st152
+		}
+		goto tr0
+	st152:
+		if p++; p == pe {
+			goto _test_eof152
+		}
+	st_case_152:
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		case 45:
+			goto st151
+		}
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st152
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st152
+			}
+		default:
+			goto st152
+		}
+		goto tr0
+	st153:
+		if p++; p == pe {
+			goto _test_eof153
+		}
+	st_case_153:
+		if data[p] == 94 {
+			goto st154
+		}
+		goto tr0
+	st154:
+		if p++; p == pe {
+			goto _test_eof154
+		}
+	st_case_154:
+		if data[p] == 60 {
+			goto st155
+		}
+		goto tr0
+tr234:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st155
+	st155:
+		if p++; p == pe {
+			goto _test_eof155
+		}
+	st_case_155:
+// line 5943 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st155
+		case 62:
+			goto st156
+		case 92:
+			goto st157
+		case 95:
+			goto st155
+		case 126:
+			goto st155
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st155
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st155
+				}
+			case data[p] >= 97:
+				goto st155
+			}
+		default:
+			goto st155
+		}
+		goto tr0
+tr235:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st156
+	st156:
+		if p++; p == pe {
+			goto _test_eof156
+		}
+	st_case_156:
+// line 5986 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		}
+		goto tr0
+tr236:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st157
+	st157:
+		if p++; p == pe {
+			goto _test_eof157
+		}
+	st_case_157:
+// line 6006 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st158
+		case 117:
+			goto st162
+		}
+		goto tr0
+	st158:
+		if p++; p == pe {
+			goto _test_eof158
+		}
+	st_case_158:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st159
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st159
+			}
+		default:
+			goto st159
+		}
+		goto tr0
+	st159:
+		if p++; p == pe {
+			goto _test_eof159
+		}
+	st_case_159:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st160
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st160
+			}
+		default:
+			goto st160
+		}
+		goto tr0
+	st160:
+		if p++; p == pe {
+			goto _test_eof160
+		}
+	st_case_160:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st161
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st161
+			}
+		default:
+			goto st161
+		}
+		goto tr0
+	st161:
+		if p++; p == pe {
+			goto _test_eof161
+		}
+	st_case_161:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st162
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st162
+			}
+		default:
+			goto st162
+		}
+		goto tr0
+	st162:
+		if p++; p == pe {
+			goto _test_eof162
+		}
+	st_case_162:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st163
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st163
+			}
+		default:
+			goto st163
+		}
+		goto tr0
+	st163:
+		if p++; p == pe {
+			goto _test_eof163
+		}
+	st_case_163:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st164
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st164
+			}
+		default:
+			goto st164
+		}
+		goto tr0
+	st164:
+		if p++; p == pe {
+			goto _test_eof164
+		}
+	st_case_164:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st165
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st165
+			}
+		default:
+			goto st165
+		}
+		goto tr0
+	st165:
+		if p++; p == pe {
+			goto _test_eof165
+		}
+	st_case_165:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st166
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st166
+			}
+		default:
+			goto st166
+		}
+		goto tr0
+	st166:
+		if p++; p == pe {
+			goto _test_eof166
+		}
+	st_case_166:
+		switch data[p] {
+		case 33:
+			goto tr234
+		case 62:
+			goto tr235
+		case 92:
+			goto tr236
+		case 95:
+			goto tr234
+		case 126:
+			goto tr234
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr234
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr234
+				}
+			case data[p] >= 97:
+				goto tr234
+			}
+		default:
+			goto tr234
+		}
+		goto tr0
+tr242:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st167
+	st167:
+		if p++; p == pe {
+			goto _test_eof167
+		}
+	st_case_167:
+// line 6205 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st168
+		case 39:
+			goto st168
+		case 85:
+			goto st169
+		case 92:
+			goto st168
+		case 98:
+			goto st168
+		case 102:
+			goto st168
+		case 110:
+			goto st168
+		case 114:
+			goto st168
+		case 116:
+			goto st168
+		case 117:
+			goto st173
+		}
+		goto tr0
+	st168:
+		if p++; p == pe {
+			goto _test_eof168
+		}
+	st_case_168:
+		switch data[p] {
+		case 34:
+			goto tr241
+		case 92:
+			goto tr242
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto tr240
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto tr240
+			}
+		default:
+			goto tr240
+		}
+		goto tr0
+	st169:
+		if p++; p == pe {
+			goto _test_eof169
+		}
+	st_case_169:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st170
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st170
+			}
+		default:
+			goto st170
+		}
+		goto tr0
+	st170:
+		if p++; p == pe {
+			goto _test_eof170
+		}
+	st_case_170:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st171
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st171
+			}
+		default:
+			goto st171
+		}
+		goto tr0
+	st171:
+		if p++; p == pe {
+			goto _test_eof171
+		}
+	st_case_171:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st172
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st172
+			}
+		default:
+			goto st172
+		}
+		goto tr0
+	st172:
+		if p++; p == pe {
+			goto _test_eof172
+		}
+	st_case_172:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st173
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st173
+			}
+		default:
+			goto st173
+		}
+		goto tr0
+	st173:
+		if p++; p == pe {
+			goto _test_eof173
+		}
+	st_case_173:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st174
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st174
+			}
+		default:
+			goto st174
+		}
+		goto tr0
+	st174:
+		if p++; p == pe {
+			goto _test_eof174
+		}
+	st_case_174:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st175
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st175
+			}
+		default:
+			goto st175
+		}
+		goto tr0
+	st175:
+		if p++; p == pe {
+			goto _test_eof175
+		}
+	st_case_175:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st176
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st176
+			}
+		default:
+			goto st176
+		}
+		goto tr0
+	st176:
+		if p++; p == pe {
+			goto _test_eof176
+		}
+	st_case_176:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st168
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st168
+			}
+		default:
+			goto st168
+		}
+		goto tr0
+tr6:
+// line 26 "actions.rl"
+
+
+		subject = p
+	
+	goto st177
+	st177:
+		if p++; p == pe {
+			goto _test_eof177
+		}
+	st_case_177:
+// line 6409 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		case 33:
+			goto st2
+		case 46:
+			goto st136
+		case 58:
+			goto st136
+		case 92:
+			goto st137
+		}
+		switch {
+		case data[p] > 126:
+			if 128 <= data[p] && data[p] <= 1114111 {
+				goto st2
+			}
+		case data[p] >= 35:
+			goto st2
+		}
+		goto tr0
+	st_out:
+	_test_eof1: cs = 1; goto _test_eof
+	_test_eof2: cs = 2; goto _test_eof
+	_test_eof3: cs = 3; goto _test_eof
+	_test_eof4: cs = 4; goto _test_eof
+	_test_eof5: cs = 5; goto _test_eof
+	_test_eof6: cs = 6; goto _test_eof
+	_test_eof7: cs = 7; goto _test_eof
+	_test_eof8: cs = 8; goto _test_eof
+	_test_eof9: cs = 9; goto _test_eof
+	_test_eof178: cs = 178; goto _test_eof
+	_test_eof179: cs = 179; goto _test_eof
+	_test_eof180: cs = 180; goto _test_eof
+	_test_eof181: cs = 181; goto _test_eof
+	_test_eof182: cs = 182; goto _test_eof
+	_test_eof183: cs = 183; goto _test_eof
+	_test_eof184: cs = 184; goto _test_eof
+	_test_eof185: cs = 185; goto _test_eof
+	_test_eof186: cs = 186; goto _test_eof
+	_test_eof187: cs = 187; goto _test_eof
+	_test_eof188: cs = 188; goto _test_eof
+	_test_eof189: cs = 189; goto _test_eof
+	_test_eof190: cs = 190; goto _test_eof
+	_test_eof191: cs = 191; goto _test_eof
+	_test_eof192: cs = 192; goto _test_eof
+	_test_eof193: cs = 193; goto _test_eof
+	_test_eof194: cs = 194; goto _test_eof
+	_test_eof195: cs = 195; goto _test_eof
+	_test_eof10: cs = 10; goto _test_eof
+	_test_eof11: cs = 11; goto _test_eof
+	_test_eof12: cs = 12; goto _test_eof
+	_test_eof13: cs = 13; goto _test_eof
+	_test_eof14: cs = 14; goto _test_eof
+	_test_eof15: cs = 15; goto _test_eof
+	_test_eof16: cs = 16; goto _test_eof
+	_test_eof17: cs = 17; goto _test_eof
+	_test_eof18: cs = 18; goto _test_eof
+	_test_eof19: cs = 19; goto _test_eof
+	_test_eof20: cs = 20; goto _test_eof
+	_test_eof21: cs = 21; goto _test_eof
+	_test_eof22: cs = 22; goto _test_eof
+	_test_eof23: cs = 23; goto _test_eof
+	_test_eof24: cs = 24; goto _test_eof
+	_test_eof25: cs = 25; goto _test_eof
+	_test_eof26: cs = 26; goto _test_eof
+	_test_eof27: cs = 27; goto _test_eof
+	_test_eof28: cs = 28; goto _test_eof
+	_test_eof29: cs = 29; goto _test_eof
+	_test_eof30: cs = 30; goto _test_eof
+	_test_eof31: cs = 31; goto _test_eof
+	_test_eof32: cs = 32; goto _test_eof
+	_test_eof33: cs = 33; goto _test_eof
+	_test_eof34: cs = 34; goto _test_eof
+	_test_eof35: cs = 35; goto _test_eof
+	_test_eof36: cs = 36; goto _test_eof
+	_test_eof37: cs = 37; goto _test_eof
+	_test_eof38: cs = 38; goto _test_eof
+	_test_eof39: cs = 39; goto _test_eof
+	_test_eof40: cs = 40; goto _test_eof
+	_test_eof41: cs = 41; goto _test_eof
+	_test_eof42: cs = 42; goto _test_eof
+	_test_eof43: cs = 43; goto _test_eof
+	_test_eof44: cs = 44; goto _test_eof
+	_test_eof45: cs = 45; goto _test_eof
+	_test_eof46: cs = 46; goto _test_eof
+	_test_eof47: cs = 47; goto _test_eof
+	_test_eof48: cs = 48; goto _test_eof
+	_test_eof49: cs = 49; goto _test_eof
+	_test_eof50: cs = 50; goto _test_eof
+	_test_eof51: cs = 51; goto _test_eof
+	_test_eof196: cs = 196; goto _test_eof
+	_test_eof197: cs = 197; goto _test_eof
+	_test_eof198: cs = 198; goto _test_eof
+	_test_eof199: cs = 199; goto _test_eof
+	_test_eof200: cs = 200; goto _test_eof
+	_test_eof201: cs = 201; goto _test_eof
+	_test_eof202: cs = 202; goto _test_eof
+	_test_eof203: cs = 203; goto _test_eof
+	_test_eof204: cs = 204; goto _test_eof
+	_test_eof205: cs = 205; goto _test_eof
+	_test_eof206: cs = 206; goto _test_eof
+	_test_eof207: cs = 207; goto _test_eof
+	_test_eof208: cs = 208; goto _test_eof
+	_test_eof209: cs = 209; goto _test_eof
+	_test_eof210: cs = 210; goto _test_eof
+	_test_eof211: cs = 211; goto _test_eof
+	_test_eof212: cs = 212; goto _test_eof
+	_test_eof213: cs = 213; goto _test_eof
+	_test_eof214: cs = 214; goto _test_eof
+	_test_eof215: cs = 215; goto _test_eof
+	_test_eof216: cs = 216; goto _test_eof
+	_test_eof217: cs = 217; goto _test_eof
+	_test_eof218: cs = 218; goto _test_eof
+	_test_eof219: cs = 219; goto _test_eof
+	_test_eof220: cs = 220; goto _test_eof
+	_test_eof221: cs = 221; goto _test_eof
+	_test_eof222: cs = 222; goto _test_eof
+	_test_eof223: cs = 223; goto _test_eof
+	_test_eof224: cs = 224; goto _test_eof
+	_test_eof225: cs = 225; goto _test_eof
+	_test_eof226: cs = 226; goto _test_eof
+	_test_eof227: cs = 227; goto _test_eof
+	_test_eof228: cs = 228; goto _test_eof
+	_test_eof229: cs = 229; goto _test_eof
+	_test_eof230: cs = 230; goto _test_eof
+	_test_eof231: cs = 231; goto _test_eof
+	_test_eof232: cs = 232; goto _test_eof
+	_test_eof233: cs = 233; goto _test_eof
+	_test_eof234: cs = 234; goto _test_eof
+	_test_eof235: cs = 235; goto _test_eof
+	_test_eof236: cs = 236; goto _test_eof
+	_test_eof237: cs = 237; goto _test_eof
+	_test_eof238: cs = 238; goto _test_eof
+	_test_eof239: cs = 239; goto _test_eof
+	_test_eof240: cs = 240; goto _test_eof
+	_test_eof241: cs = 241; goto _test_eof
+	_test_eof52: cs = 52; goto _test_eof
+	_test_eof53: cs = 53; goto _test_eof
+	_test_eof54: cs = 54; goto _test_eof
+	_test_eof55: cs = 55; goto _test_eof
+	_test_eof56: cs = 56; goto _test_eof
+	_test_eof57: cs = 57; goto _test_eof
+	_test_eof58: cs = 58; goto _test_eof
+	_test_eof59: cs = 59; goto _test_eof
+	_test_eof60: cs = 60; goto _test_eof
+	_test_eof61: cs = 61; goto _test_eof
+	_test_eof62: cs = 62; goto _test_eof
+	_test_eof63: cs = 63; goto _test_eof
+	_test_eof64: cs = 64; goto _test_eof
+	_test_eof65: cs = 65; goto _test_eof
+	_test_eof66: cs = 66; goto _test_eof
+	_test_eof67: cs = 67; goto _test_eof
+	_test_eof68: cs = 68; goto _test_eof
+	_test_eof69: cs = 69; goto _test_eof
+	_test_eof70: cs = 70; goto _test_eof
+	_test_eof71: cs = 71; goto _test_eof
+	_test_eof72: cs = 72; goto _test_eof
+	_test_eof73: cs = 73; goto _test_eof
+	_test_eof74: cs = 74; goto _test_eof
+	_test_eof75: cs = 75; goto _test_eof
+	_test_eof76: cs = 76; goto _test_eof
+	_test_eof77: cs = 77; goto _test_eof
+	_test_eof78: cs = 78; goto _test_eof
+	_test_eof79: cs = 79; goto _test_eof
+	_test_eof80: cs = 80; goto _test_eof
+	_test_eof81: cs = 81; goto _test_eof
+	_test_eof82: cs = 82; goto _test_eof
+	_test_eof83: cs = 83; goto _test_eof
+	_test_eof84: cs = 84; goto _test_eof
+	_test_eof85: cs = 85; goto _test_eof
+	_test_eof86: cs = 86; goto _test_eof
+	_test_eof87: cs = 87; goto _test_eof
+	_test_eof88: cs = 88; goto _test_eof
+	_test_eof89: cs = 89; goto _test_eof
+	_test_eof90: cs = 90; goto _test_eof
+	_test_eof91: cs = 91; goto _test_eof
+	_test_eof92: cs = 92; goto _test_eof
+	_test_eof93: cs = 93; goto _test_eof
+	_test_eof94: cs = 94; goto _test_eof
+	_test_eof95: cs = 95; goto _test_eof
+	_test_eof96: cs = 96; goto _test_eof
+	_test_eof97: cs = 97; goto _test_eof
+	_test_eof98: cs = 98; goto _test_eof
+	_test_eof99: cs = 99; goto _test_eof
+	_test_eof100: cs = 100; goto _test_eof
+	_test_eof101: cs = 101; goto _test_eof
+	_test_eof102: cs = 102; goto _test_eof
+	_test_eof103: cs = 103; goto _test_eof
+	_test_eof104: cs = 104; goto _test_eof
+	_test_eof105: cs = 105; goto _test_eof
+	_test_eof106: cs = 106; goto _test_eof
+	_test_eof107: cs = 107; goto _test_eof
+	_test_eof108: cs = 108; goto _test_eof
+	_test_eof109: cs = 109; goto _test_eof
+	_test_eof110: cs = 110; goto _test_eof
+	_test_eof111: cs = 111; goto _test_eof
+	_test_eof112: cs = 112; goto _test_eof
+	_test_eof113: cs = 113; goto _test_eof
+	_test_eof114: cs = 114; goto _test_eof
+	_test_eof115: cs = 115; goto _test_eof
+	_test_eof116: cs = 116; goto _test_eof
+	_test_eof117: cs = 117; goto _test_eof
+	_test_eof118: cs = 118; goto _test_eof
+	_test_eof119: cs = 119; goto _test_eof
+	_test_eof120: cs = 120; goto _test_eof
+	_test_eof121: cs = 121; goto _test_eof
+	_test_eof122: cs = 122; goto _test_eof
+	_test_eof123: cs = 123; goto _test_eof
+	_test_eof124: cs = 124; goto _test_eof
+	_test_eof125: cs = 125; goto _test_eof
+	_test_eof126: cs = 126; goto _test_eof
+	_test_eof127: cs = 127; goto _test_eof
+	_test_eof128: cs = 128; goto _test_eof
+	_test_eof129: cs = 129; goto _test_eof
+	_test_eof130: cs = 130; goto _test_eof
+	_test_eof131: cs = 131; goto _test_eof
+	_test_eof132: cs = 132; goto _test_eof
+	_test_eof133: cs = 133; goto _test_eof
+	_test_eof134: cs = 134; goto _test_eof
+	_test_eof135: cs = 135; goto _test_eof
+	_test_eof136: cs = 136; goto _test_eof
+	_test_eof137: cs = 137; goto _test_eof
+	_test_eof138: cs = 138; goto _test_eof
+	_test_eof139: cs = 139; goto _test_eof
+	_test_eof140: cs = 140; goto _test_eof
+	_test_eof141: cs = 141; goto _test_eof
+	_test_eof142: cs = 142; goto _test_eof
+	_test_eof143: cs = 143; goto _test_eof
+	_test_eof144: cs = 144; goto _test_eof
+	_test_eof145: cs = 145; goto _test_eof
+	_test_eof146: cs = 146; goto _test_eof
+	_test_eof147: cs = 147; goto _test_eof
+	_test_eof148: cs = 148; goto _test_eof
+	_test_eof149: cs = 149; goto _test_eof
+	_test_eof150: cs = 150; goto _test_eof
+	_test_eof151: cs = 151; goto _test_eof
+	_test_eof152: cs = 152; goto _test_eof
+	_test_eof153: cs = 153; goto _test_eof
+	_test_eof154: cs = 154; goto _test_eof
+	_test_eof155: cs = 155; goto _test_eof
+	_test_eof156: cs = 156; goto _test_eof
+	_test_eof157: cs = 157; goto _test_eof
+	_test_eof158: cs = 158; goto _test_eof
+	_test_eof159: cs = 159; goto _test_eof
+	_test_eof160: cs = 160; goto _test_eof
+	_test_eof161: cs = 161; goto _test_eof
+	_test_eof162: cs = 162; goto _test_eof
+	_test_eof163: cs = 163; goto _test_eof
+	_test_eof164: cs = 164; goto _test_eof
+	_test_eof165: cs = 165; goto _test_eof
+	_test_eof166: cs = 166; goto _test_eof
+	_test_eof167: cs = 167; goto _test_eof
+	_test_eof168: cs = 168; goto _test_eof
+	_test_eof169: cs = 169; goto _test_eof
+	_test_eof170: cs = 170; goto _test_eof
+	_test_eof171: cs = 171; goto _test_eof
+	_test_eof172: cs = 172; goto _test_eof
+	_test_eof173: cs = 173; goto _test_eof
+	_test_eof174: cs = 174; goto _test_eof
+	_test_eof175: cs = 175; goto _test_eof
+	_test_eof176: cs = 176; goto _test_eof
+	_test_eof177: cs = 177; goto _test_eof
+
+	_test_eof: {}
+	if p == eof {
+		switch cs {
+		case 179, 181, 182, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241:
+// line 78 "actions.rl"
+
+
+		return q, nil
+	
+		case 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177:
+// line 85 "actions.rl"
+
+
+		if p < len(data) {
+			if r := data[p]; r < unicode.MaxASCII {
+				return q, fmt.Errorf("%v: unexpected rune %q at %d", quad.ErrInvalid, data[p], p)
+			} else {
+				return q, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", quad.ErrInvalid, data[p], data[p], p)
+			}
+		}
+		return q, quad.ErrIncomplete
+	
+		case 178, 180, 183, 184, 196, 230:
+// line 82 "actions.rl"
+
+
+	
+// line 78 "actions.rl"
+
+
+		return q, nil
+	
+// line 6708 "parse.go"
+		}
+	}
+
+	_out: {}
+	}
+
+// line 61 "parse.rl"
+
+	return quad.Quad{}, quad.ErrInvalid
+}
diff --git a/vendor/github.com/google/cayley/quad/cquads/parse.rl b/vendor/github.com/google/cayley/quad/cquads/parse.rl
new file mode 100644
index 00000000..b0329d6d
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/cquads/parse.rl
@@ -0,0 +1,63 @@
+// GO SOURCE FILE MACHINE GENERATED BY RAGEL; DO NOT EDIT
+
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cquads
+
+import (
+	"fmt"
+	"unicode"
+
+	"github.com/google/cayley/quad"
+)
+
+%%{
+	machine quads;
+
+	include "actions.rl";
+
+	include "cquads.rl";
+
+	write data;
+}%%
+
+// Parse returns a valid quad.Quad or a non-nil error. Parse does
+// handle comments except where the comment placement does not prevent
+// a complete valid quad.Quad from being defined.
+func Parse(statement string) (quad.Quad, error) {
+	data := []rune(statement)
+
+	var (
+		cs, p int
+		pe    = len(data)
+		eof   = pe
+
+		subject   = -1
+		predicate = -1
+		object    = -1
+		label     = -1
+
+		isEscaped bool
+		isQuoted  bool
+
+		q quad.Quad
+	)
+
+	%%write init;
+
+	%%write exec;
+
+	return quad.Quad{}, quad.ErrInvalid
+}
diff --git a/vendor/github.com/google/cayley/quad/nquad_tests.tar.gz b/vendor/github.com/google/cayley/quad/nquad_tests.tar.gz
new file mode 100644
index 00000000..f0414931
Binary files /dev/null and b/vendor/github.com/google/cayley/quad/nquad_tests.tar.gz differ
diff --git a/vendor/github.com/google/cayley/quad/nquads/actions.rl b/vendor/github.com/google/cayley/quad/nquads/actions.rl
new file mode 100644
index 00000000..0ba7096e
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/nquads/actions.rl
@@ -0,0 +1,87 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+%%{
+	machine quads;
+
+	action Escape {
+		isEscaped = true
+	}
+
+	action StartSubject {
+		subject = p
+	}
+
+	action StartPredicate {
+		predicate = p
+	}
+
+	action StartObject {
+		object = p
+	}
+
+	action StartLabel {
+		label = p
+	}
+
+	action SetSubject {
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isEscaped)
+		isEscaped = false
+	}
+
+	action SetPredicate {
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isEscaped)
+		isEscaped = false
+	}
+
+	action SetObject {
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	}
+
+	action SetLabel {
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isEscaped)
+		isEscaped = false
+	}
+
+	action Return {
+		return q, nil
+	}
+
+	action Comment {
+	}
+
+	action Error {
+		if p < len(data) {
+			if r := data[p]; r < unicode.MaxASCII {
+				return q, fmt.Errorf("%v: unexpected rune %q at %d", quad.ErrInvalid, data[p], p)
+			} else {
+				return q, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", quad.ErrInvalid, data[p], data[p], p)
+			}
+		}
+		return q, quad.ErrIncomplete
+	}
+}%%
diff --git a/vendor/github.com/google/cayley/quad/nquads/nquads.go b/vendor/github.com/google/cayley/quad/nquads/nquads.go
new file mode 100644
index 00000000..a4c4091b
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/nquads/nquads.go
@@ -0,0 +1,132 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:generate ragel -Z -G2 parse.rl
+
+// Package nquads implements parsing the RDF 1.1 N-Quads line-based syntax
+// for RDF datasets.
+//
+// N-Quad parsing is performed as defined by http://www.w3.org/TR/n-quads/
+// with the exception that the nquads package will allow relative IRI values,
+// which are prohibited by the N-Quads quad-Quads specifications.
+package nquads
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"strconv"
+
+	"github.com/google/cayley/quad"
+)
+
+// Decoder implements N-Quad document parsing according to the RDF
+// 1.1 N-Quads specification.
+type Decoder struct {
+	r    *bufio.Reader
+	line []byte
+}
+
+// NewDecoder returns an N-Quad decoder that takes its input from the
+// provided io.Reader.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: bufio.NewReader(r)}
+}
+
+// Unmarshal returns the next valid N-Quad as a quad.Quad, or an error.
+func (dec *Decoder) Unmarshal() (quad.Quad, error) {
+	dec.line = dec.line[:0]
+	var line []byte
+	for {
+		for {
+			l, pre, err := dec.r.ReadLine()
+			if err != nil {
+				return quad.Quad{}, err
+			}
+			dec.line = append(dec.line, l...)
+			if !pre {
+				break
+			}
+		}
+		if line = bytes.TrimSpace(dec.line); len(line) != 0 && line[0] != '#' {
+			break
+		}
+		dec.line = dec.line[:0]
+	}
+	q, err := Parse(string(line))
+	if err != nil {
+		return quad.Quad{}, fmt.Errorf("failed to parse %q: %v", dec.line, err)
+	}
+	if !q.IsValid() {
+		return dec.Unmarshal()
+	}
+	return q, nil
+}
+
+func unEscape(r []rune, isEscaped bool) string {
+	if !isEscaped {
+		return string(r)
+	}
+
+	buf := bytes.NewBuffer(make([]byte, 0, len(r)))
+
+	for i := 0; i < len(r); {
+		switch r[i] {
+		case '\\':
+			i++
+			var c byte
+			switch r[i] {
+			case 't':
+				c = '\t'
+			case 'b':
+				c = '\b'
+			case 'n':
+				c = '\n'
+			case 'r':
+				c = '\r'
+			case 'f':
+				c = '\f'
+			case '"':
+				c = '"'
+			case '\'':
+				c = '\''
+			case '\\':
+				c = '\\'
+			case 'u':
+				rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32)
+				if err != nil {
+					panic(fmt.Errorf("internal parser error: %v", err))
+				}
+				buf.WriteRune(rune(rc))
+				i += 5
+				continue
+			case 'U':
+				rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32)
+				if err != nil {
+					panic(fmt.Errorf("internal parser error: %v", err))
+				}
+				buf.WriteRune(rune(rc))
+				i += 9
+				continue
+			}
+			buf.WriteByte(c)
+		default:
+			buf.WriteRune(r[i])
+		}
+		i++
+	}
+
+	return buf.String()
+}
diff --git a/vendor/github.com/google/cayley/quad/nquads/nquads.rl b/vendor/github.com/google/cayley/quad/nquads/nquads.rl
new file mode 100644
index 00000000..78a047e8
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/nquads/nquads.rl
@@ -0,0 +1,98 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Ragel gramar definition derived from http://www.w3.org/TR/n-quads/#sec-grammar.
+
+%%{
+	machine quads;
+
+	alphtype rune;
+
+	PN_CHARS_BASE           = [A-Za-z]
+							| 0x00c0 .. 0x00d6
+							| 0x00d8 .. 0x00f6
+							| 0x00f8 .. 0x02ff
+							| 0x0370 .. 0x037d
+							| 0x037f .. 0x1fff
+							| 0x200c .. 0x200d
+							| 0x2070 .. 0x218f
+							| 0x2c00 .. 0x2fef
+							| 0x3001 .. 0xd7ff
+							| 0xf900 .. 0xfdcf
+							| 0xfdf0 .. 0xfffd
+							| 0x10000 .. 0xeffff
+							;
+
+	PN_CHARS_U              = PN_CHARS_BASE | '_' | ':' ;
+
+	PN_CHARS                = PN_CHARS_U
+							| '-'
+							| [0-9]
+							| 0xb7
+							| 0x0300 .. 0x036f
+							| 0x203f .. 0x2040
+							;
+
+	ECHAR                   = ('\\' [tbnrf"'\\]) %Escape ;
+
+	UCHAR                   = ('\\u' xdigit {4}
+							| '\\U' xdigit {8}) %Escape
+							;
+
+	BLANK_NODE_LABEL        = '_:' (PN_CHARS_U | [0-9]) ((PN_CHARS | '.')* PN_CHARS)? ;
+
+	STRING_LITERAL_QUOTE    = '"' (
+							  0x00 .. 0x09
+							| 0x0b .. 0x0c
+							| 0x0e .. '!'
+							| '#' .. '['
+							| ']' .. 0x10ffff
+							| ECHAR
+							| UCHAR)*
+							  '"'
+							;
+
+	IRIREF                  = '<' (
+							  '!'
+							| '#' .. ';'
+							| '='
+							| '?' .. '['
+							| ']'
+							| '_'
+							| 'a' .. 'z'
+							| '~'
+							| 0x80 .. 0x10ffff
+							| UCHAR)*
+							  '>'
+							;
+
+	LANGTAG                 = '@' [a-zA-Z]+ ('-' [a-zA-Z0-9]+)* ;
+
+	whitespace              = [ \t] ;
+
+	literal                 = STRING_LITERAL_QUOTE ('^^' IRIREF | LANGTAG)? ;
+
+	subject                 = IRIREF | BLANK_NODE_LABEL ;
+	predicate               = IRIREF ;
+	object                  = IRIREF | BLANK_NODE_LABEL | literal ;
+	graphLabel              = IRIREF | BLANK_NODE_LABEL ;
+
+	statement := (
+					whitespace*  subject    >StartSubject   %SetSubject
+					whitespace*  predicate  >StartPredicate %SetPredicate
+					whitespace*  object     >StartObject    %SetObject
+					(whitespace* graphLabel >StartLabel     %SetLabel)?
+					whitespace*  '.' whitespace* ('#' any*)? >Comment
+				 ) %Return @!Error ;
+}%%
diff --git a/vendor/github.com/google/cayley/quad/nquads/parse.go b/vendor/github.com/google/cayley/quad/nquads/parse.go
new file mode 100644
index 00000000..991f9323
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/nquads/parse.go
@@ -0,0 +1,3673 @@
+
+// line 1 "parse.rl"
+// GO SOURCE FILE MACHINE GENERATED BY RAGEL; DO NOT EDIT
+
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package nquads
+
+import (
+	"fmt"
+	"unicode"
+
+	"github.com/google/cayley/quad"
+)
+
+
+// line 30 "parse.go"
+const quads_start int = 1
+const quads_first_final int = 88
+const quads_error int = 0
+
+const quads_en_statement int = 1
+
+
+// line 34 "parse.rl"
+
+
+// Parse returns a valid quad.Quad or a non-nil error. Parse does
+// handle comments except where the comment placement does not prevent
+// a complete valid quad.Quad from being defined.
+func Parse(statement string) (quad.Quad, error) {
+	data := []rune(statement)
+
+	var (
+		cs, p int
+		pe    = len(data)
+		eof   = pe
+
+		subject   = -1
+		predicate = -1
+		object    = -1
+		label     = -1
+
+		isEscaped bool
+
+		q quad.Quad
+	)
+
+	
+// line 63 "parse.go"
+	{
+	cs = quads_start
+	}
+
+// line 58 "parse.rl"
+
+	
+// line 71 "parse.go"
+	{
+	if p == pe {
+		goto _test_eof
+	}
+	switch cs {
+	case 1:
+		goto st_case_1
+	case 0:
+		goto st_case_0
+	case 2:
+		goto st_case_2
+	case 3:
+		goto st_case_3
+	case 4:
+		goto st_case_4
+	case 5:
+		goto st_case_5
+	case 6:
+		goto st_case_6
+	case 7:
+		goto st_case_7
+	case 8:
+		goto st_case_8
+	case 9:
+		goto st_case_9
+	case 10:
+		goto st_case_10
+	case 88:
+		goto st_case_88
+	case 89:
+		goto st_case_89
+	case 11:
+		goto st_case_11
+	case 12:
+		goto st_case_12
+	case 13:
+		goto st_case_13
+	case 14:
+		goto st_case_14
+	case 15:
+		goto st_case_15
+	case 16:
+		goto st_case_16
+	case 17:
+		goto st_case_17
+	case 18:
+		goto st_case_18
+	case 19:
+		goto st_case_19
+	case 20:
+		goto st_case_20
+	case 21:
+		goto st_case_21
+	case 22:
+		goto st_case_22
+	case 23:
+		goto st_case_23
+	case 24:
+		goto st_case_24
+	case 25:
+		goto st_case_25
+	case 26:
+		goto st_case_26
+	case 90:
+		goto st_case_90
+	case 27:
+		goto st_case_27
+	case 28:
+		goto st_case_28
+	case 29:
+		goto st_case_29
+	case 30:
+		goto st_case_30
+	case 31:
+		goto st_case_31
+	case 32:
+		goto st_case_32
+	case 33:
+		goto st_case_33
+	case 34:
+		goto st_case_34
+	case 35:
+		goto st_case_35
+	case 36:
+		goto st_case_36
+	case 37:
+		goto st_case_37
+	case 38:
+		goto st_case_38
+	case 39:
+		goto st_case_39
+	case 40:
+		goto st_case_40
+	case 41:
+		goto st_case_41
+	case 42:
+		goto st_case_42
+	case 43:
+		goto st_case_43
+	case 44:
+		goto st_case_44
+	case 45:
+		goto st_case_45
+	case 46:
+		goto st_case_46
+	case 47:
+		goto st_case_47
+	case 48:
+		goto st_case_48
+	case 49:
+		goto st_case_49
+	case 50:
+		goto st_case_50
+	case 51:
+		goto st_case_51
+	case 52:
+		goto st_case_52
+	case 53:
+		goto st_case_53
+	case 54:
+		goto st_case_54
+	case 55:
+		goto st_case_55
+	case 56:
+		goto st_case_56
+	case 57:
+		goto st_case_57
+	case 58:
+		goto st_case_58
+	case 91:
+		goto st_case_91
+	case 59:
+		goto st_case_59
+	case 60:
+		goto st_case_60
+	case 61:
+		goto st_case_61
+	case 62:
+		goto st_case_62
+	case 92:
+		goto st_case_92
+	case 63:
+		goto st_case_63
+	case 64:
+		goto st_case_64
+	case 65:
+		goto st_case_65
+	case 66:
+		goto st_case_66
+	case 67:
+		goto st_case_67
+	case 68:
+		goto st_case_68
+	case 69:
+		goto st_case_69
+	case 70:
+		goto st_case_70
+	case 71:
+		goto st_case_71
+	case 72:
+		goto st_case_72
+	case 73:
+		goto st_case_73
+	case 74:
+		goto st_case_74
+	case 75:
+		goto st_case_75
+	case 76:
+		goto st_case_76
+	case 77:
+		goto st_case_77
+	case 78:
+		goto st_case_78
+	case 79:
+		goto st_case_79
+	case 80:
+		goto st_case_80
+	case 81:
+		goto st_case_81
+	case 82:
+		goto st_case_82
+	case 83:
+		goto st_case_83
+	case 84:
+		goto st_case_84
+	case 85:
+		goto st_case_85
+	case 86:
+		goto st_case_86
+	case 87:
+		goto st_case_87
+	}
+	goto st_out
+	st1:
+		if p++; p == pe {
+			goto _test_eof1
+		}
+	st_case_1:
+		switch data[p] {
+		case 9:
+			goto st1
+		case 32:
+			goto st1
+		case 60:
+			goto tr2
+		case 95:
+			goto tr3
+		}
+		goto tr0
+tr0:
+// line 77 "actions.rl"
+
+
+		if p < len(data) {
+			if r := data[p]; r < unicode.MaxASCII {
+				return q, fmt.Errorf("%v: unexpected rune %q at %d", quad.ErrInvalid, data[p], p)
+			} else {
+				return q, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", quad.ErrInvalid, data[p], data[p], p)
+			}
+		}
+		return q, quad.ErrIncomplete
+	
+	goto st0
+// line 295 "parse.go"
+st_case_0:
+	st0:
+		cs = 0
+		goto _out
+tr2:
+// line 22 "actions.rl"
+
+
+		subject = p
+	
+	goto st2
+tr120:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st2
+	st2:
+		if p++; p == pe {
+			goto _test_eof2
+		}
+	st_case_2:
+// line 319 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st2
+		case 62:
+			goto st3
+		case 92:
+			goto st74
+		case 95:
+			goto st2
+		case 126:
+			goto st2
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st2
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st2
+				}
+			case data[p] >= 97:
+				goto st2
+			}
+		default:
+			goto st2
+		}
+		goto tr0
+tr121:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st3
+	st3:
+		if p++; p == pe {
+			goto _test_eof3
+		}
+	st_case_3:
+// line 362 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		case 60:
+			goto tr8
+		}
+		goto tr0
+tr7:
+// line 38 "actions.rl"
+
+
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isEscaped)
+		isEscaped = false
+	
+	goto st4
+	st4:
+		if p++; p == pe {
+			goto _test_eof4
+		}
+	st_case_4:
+// line 388 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st4
+		case 32:
+			goto st4
+		case 60:
+			goto tr10
+		}
+		goto tr0
+tr8:
+// line 38 "actions.rl"
+
+
+		if subject < 0 {
+			panic("unexpected parser state: subject start not set")
+		}
+		q.Subject = unEscape(data[subject:p], isEscaped)
+		isEscaped = false
+	
+// line 26 "actions.rl"
+
+
+		predicate = p
+	
+	goto st5
+tr10:
+// line 26 "actions.rl"
+
+
+		predicate = p
+	
+	goto st5
+tr108:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st5
+	st5:
+		if p++; p == pe {
+			goto _test_eof5
+		}
+	st_case_5:
+// line 433 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st5
+		case 62:
+			goto st6
+		case 92:
+			goto st64
+		case 95:
+			goto st5
+		case 126:
+			goto st5
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st5
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st5
+				}
+			case data[p] >= 97:
+				goto st5
+			}
+		default:
+			goto st5
+		}
+		goto tr0
+tr109:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st6
+	st6:
+		if p++; p == pe {
+			goto _test_eof6
+		}
+	st_case_6:
+// line 476 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr14
+		case 32:
+			goto tr14
+		case 34:
+			goto tr15
+		case 60:
+			goto tr16
+		case 95:
+			goto tr17
+		}
+		goto tr0
+tr14:
+// line 46 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isEscaped)
+		isEscaped = false
+	
+	goto st7
+	st7:
+		if p++; p == pe {
+			goto _test_eof7
+		}
+	st_case_7:
+// line 506 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st7
+		case 32:
+			goto st7
+		case 34:
+			goto tr19
+		case 60:
+			goto tr20
+		case 95:
+			goto tr21
+		}
+		goto tr0
+tr15:
+// line 46 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isEscaped)
+		isEscaped = false
+	
+// line 30 "actions.rl"
+
+
+		object = p
+	
+	goto st8
+tr19:
+// line 30 "actions.rl"
+
+
+		object = p
+	
+	goto st8
+tr79:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st8
+	st8:
+		if p++; p == pe {
+			goto _test_eof8
+		}
+	st_case_8:
+// line 555 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st9
+		case 92:
+			goto st46
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto st8
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto st8
+			}
+		default:
+			goto st8
+		}
+		goto tr0
+tr80:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st9
+	st9:
+		if p++; p == pe {
+			goto _test_eof9
+		}
+	st_case_9:
+// line 587 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 46:
+			goto tr26
+		case 60:
+			goto tr27
+		case 64:
+			goto st28
+		case 94:
+			goto st32
+		case 95:
+			goto tr30
+		}
+		goto tr0
+tr25:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+	goto st10
+tr96:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+// line 62 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isEscaped)
+		isEscaped = false
+	
+	goto st10
+	st10:
+		if p++; p == pe {
+			goto _test_eof10
+		}
+	st_case_10:
+// line 641 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st10
+		case 32:
+			goto st10
+		case 46:
+			goto st88
+		case 60:
+			goto tr33
+		case 95:
+			goto tr34
+		}
+		goto tr0
+tr26:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+	goto st88
+tr39:
+// line 62 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isEscaped)
+		isEscaped = false
+	
+	goto st88
+	st88:
+		if p++; p == pe {
+			goto _test_eof88
+		}
+	st_case_88:
+// line 682 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st88
+		case 32:
+			goto st88
+		case 35:
+			goto tr127
+		}
+		goto st0
+tr127:
+// line 74 "actions.rl"
+
+
+	
+	goto st89
+	st89:
+		if p++; p == pe {
+			goto _test_eof89
+		}
+	st_case_89:
+// line 703 "parse.go"
+		goto st89
+tr27:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+// line 34 "actions.rl"
+
+
+		label = p
+	
+	goto st11
+tr33:
+// line 34 "actions.rl"
+
+
+		label = p
+	
+	goto st11
+tr50:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st11
+	st11:
+		if p++; p == pe {
+			goto _test_eof11
+		}
+	st_case_11:
+// line 740 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st11
+		case 62:
+			goto st12
+		case 92:
+			goto st14
+		case 95:
+			goto st11
+		case 126:
+			goto st11
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st11
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st11
+				}
+			case data[p] >= 97:
+				goto st11
+			}
+		default:
+			goto st11
+		}
+		goto tr0
+tr51:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st12
+	st12:
+		if p++; p == pe {
+			goto _test_eof12
+		}
+	st_case_12:
+// line 783 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr38
+		case 32:
+			goto tr38
+		case 46:
+			goto tr39
+		}
+		goto tr0
+tr38:
+// line 62 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isEscaped)
+		isEscaped = false
+	
+	goto st13
+	st13:
+		if p++; p == pe {
+			goto _test_eof13
+		}
+	st_case_13:
+// line 809 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st13
+		case 32:
+			goto st13
+		case 46:
+			goto st88
+		}
+		goto tr0
+tr52:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st14
+	st14:
+		if p++; p == pe {
+			goto _test_eof14
+		}
+	st_case_14:
+// line 831 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st15
+		case 117:
+			goto st19
+		}
+		goto tr0
+	st15:
+		if p++; p == pe {
+			goto _test_eof15
+		}
+	st_case_15:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st16
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st16
+			}
+		default:
+			goto st16
+		}
+		goto tr0
+	st16:
+		if p++; p == pe {
+			goto _test_eof16
+		}
+	st_case_16:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st17
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st17
+			}
+		default:
+			goto st17
+		}
+		goto tr0
+	st17:
+		if p++; p == pe {
+			goto _test_eof17
+		}
+	st_case_17:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st18
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st18
+			}
+		default:
+			goto st18
+		}
+		goto tr0
+	st18:
+		if p++; p == pe {
+			goto _test_eof18
+		}
+	st_case_18:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st19
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st19
+			}
+		default:
+			goto st19
+		}
+		goto tr0
+	st19:
+		if p++; p == pe {
+			goto _test_eof19
+		}
+	st_case_19:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st20
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st20
+			}
+		default:
+			goto st20
+		}
+		goto tr0
+	st20:
+		if p++; p == pe {
+			goto _test_eof20
+		}
+	st_case_20:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st21
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st21
+			}
+		default:
+			goto st21
+		}
+		goto tr0
+	st21:
+		if p++; p == pe {
+			goto _test_eof21
+		}
+	st_case_21:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st22
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st22
+			}
+		default:
+			goto st22
+		}
+		goto tr0
+	st22:
+		if p++; p == pe {
+			goto _test_eof22
+		}
+	st_case_22:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st23
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st23
+			}
+		default:
+			goto st23
+		}
+		goto tr0
+	st23:
+		if p++; p == pe {
+			goto _test_eof23
+		}
+	st_case_23:
+		switch data[p] {
+		case 33:
+			goto tr50
+		case 62:
+			goto tr51
+		case 92:
+			goto tr52
+		case 95:
+			goto tr50
+		case 126:
+			goto tr50
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr50
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr50
+				}
+			case data[p] >= 97:
+				goto tr50
+			}
+		default:
+			goto tr50
+		}
+		goto tr0
+tr30:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+// line 34 "actions.rl"
+
+
+		label = p
+	
+	goto st24
+tr34:
+// line 34 "actions.rl"
+
+
+		label = p
+	
+	goto st24
+	st24:
+		if p++; p == pe {
+			goto _test_eof24
+		}
+	st_case_24:
+// line 1046 "parse.go"
+		if data[p] == 58 {
+			goto st25
+		}
+		goto tr0
+	st25:
+		if p++; p == pe {
+			goto _test_eof25
+		}
+	st_case_25:
+		if data[p] == 95 {
+			goto st26
+		}
+		switch {
+		case data[p] < 895:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st26
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st26
+					}
+				case data[p] > 767:
+					if 880 <= data[p] && data[p] <= 893 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		case data[p] > 8191:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8204 <= data[p] && data[p] <= 8205 {
+						goto st26
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st26
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		default:
+			goto st26
+		}
+		goto tr0
+	st26:
+		if p++; p == pe {
+			goto _test_eof26
+		}
+	st_case_26:
+		switch data[p] {
+		case 9:
+			goto tr38
+		case 32:
+			goto tr38
+		case 45:
+			goto st26
+		case 46:
+			goto tr55
+		case 95:
+			goto st26
+		case 183:
+			goto st26
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st26
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st26
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st26
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st26
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		default:
+			goto st26
+		}
+		goto tr0
+tr55:
+// line 62 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isEscaped)
+		isEscaped = false
+	
+	goto st90
+	st90:
+		if p++; p == pe {
+			goto _test_eof90
+		}
+	st_case_90:
+// line 1228 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st88
+		case 32:
+			goto st88
+		case 35:
+			goto tr127
+		case 45:
+			goto st26
+		case 46:
+			goto st27
+		case 95:
+			goto st26
+		case 183:
+			goto st26
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st26
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st26
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st26
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st26
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		default:
+			goto st26
+		}
+		goto st0
+	st27:
+		if p++; p == pe {
+			goto _test_eof27
+		}
+	st_case_27:
+		switch data[p] {
+		case 45:
+			goto st26
+		case 46:
+			goto st27
+		case 95:
+			goto st26
+		case 183:
+			goto st26
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st26
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st26
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st26
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st26
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st26
+					}
+				default:
+					goto st26
+				}
+			default:
+				goto st26
+			}
+		default:
+			goto st26
+		}
+		goto tr0
+	st28:
+		if p++; p == pe {
+			goto _test_eof28
+		}
+	st_case_28:
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st29
+			}
+		case data[p] >= 65:
+			goto st29
+		}
+		goto tr0
+	st29:
+		if p++; p == pe {
+			goto _test_eof29
+		}
+	st_case_29:
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 45:
+			goto st30
+		case 46:
+			goto tr26
+		case 60:
+			goto tr27
+		case 95:
+			goto tr30
+		}
+		switch {
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st29
+			}
+		case data[p] >= 65:
+			goto st29
+		}
+		goto tr0
+	st30:
+		if p++; p == pe {
+			goto _test_eof30
+		}
+	st_case_30:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st31
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st31
+			}
+		default:
+			goto st31
+		}
+		goto tr0
+	st31:
+		if p++; p == pe {
+			goto _test_eof31
+		}
+	st_case_31:
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 45:
+			goto st30
+		case 46:
+			goto tr26
+		case 60:
+			goto tr27
+		case 95:
+			goto tr30
+		}
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st31
+			}
+		case data[p] > 90:
+			if 97 <= data[p] && data[p] <= 122 {
+				goto st31
+			}
+		default:
+			goto st31
+		}
+		goto tr0
+	st32:
+		if p++; p == pe {
+			goto _test_eof32
+		}
+	st_case_32:
+		if data[p] == 94 {
+			goto st33
+		}
+		goto tr0
+	st33:
+		if p++; p == pe {
+			goto _test_eof33
+		}
+	st_case_33:
+		if data[p] == 60 {
+			goto st34
+		}
+		goto tr0
+tr16:
+// line 46 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isEscaped)
+		isEscaped = false
+	
+// line 30 "actions.rl"
+
+
+		object = p
+	
+	goto st34
+tr20:
+// line 30 "actions.rl"
+
+
+		object = p
+	
+	goto st34
+tr73:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st34
+	st34:
+		if p++; p == pe {
+			goto _test_eof34
+		}
+	st_case_34:
+// line 1539 "parse.go"
+		switch data[p] {
+		case 33:
+			goto st34
+		case 62:
+			goto st35
+		case 92:
+			goto st36
+		case 95:
+			goto st34
+		case 126:
+			goto st34
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto st34
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto st34
+				}
+			case data[p] >= 97:
+				goto st34
+			}
+		default:
+			goto st34
+		}
+		goto tr0
+tr74:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st35
+	st35:
+		if p++; p == pe {
+			goto _test_eof35
+		}
+	st_case_35:
+// line 1582 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 46:
+			goto tr26
+		case 60:
+			goto tr27
+		case 95:
+			goto tr30
+		}
+		goto tr0
+tr75:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st36
+	st36:
+		if p++; p == pe {
+			goto _test_eof36
+		}
+	st_case_36:
+// line 1608 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st37
+		case 117:
+			goto st41
+		}
+		goto tr0
+	st37:
+		if p++; p == pe {
+			goto _test_eof37
+		}
+	st_case_37:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st38
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st38
+			}
+		default:
+			goto st38
+		}
+		goto tr0
+	st38:
+		if p++; p == pe {
+			goto _test_eof38
+		}
+	st_case_38:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st39
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st39
+			}
+		default:
+			goto st39
+		}
+		goto tr0
+	st39:
+		if p++; p == pe {
+			goto _test_eof39
+		}
+	st_case_39:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st40
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st40
+			}
+		default:
+			goto st40
+		}
+		goto tr0
+	st40:
+		if p++; p == pe {
+			goto _test_eof40
+		}
+	st_case_40:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st41
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st41
+			}
+		default:
+			goto st41
+		}
+		goto tr0
+	st41:
+		if p++; p == pe {
+			goto _test_eof41
+		}
+	st_case_41:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st42
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st42
+			}
+		default:
+			goto st42
+		}
+		goto tr0
+	st42:
+		if p++; p == pe {
+			goto _test_eof42
+		}
+	st_case_42:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st43
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st43
+			}
+		default:
+			goto st43
+		}
+		goto tr0
+	st43:
+		if p++; p == pe {
+			goto _test_eof43
+		}
+	st_case_43:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st44
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st44
+			}
+		default:
+			goto st44
+		}
+		goto tr0
+	st44:
+		if p++; p == pe {
+			goto _test_eof44
+		}
+	st_case_44:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st45
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st45
+			}
+		default:
+			goto st45
+		}
+		goto tr0
+	st45:
+		if p++; p == pe {
+			goto _test_eof45
+		}
+	st_case_45:
+		switch data[p] {
+		case 33:
+			goto tr73
+		case 62:
+			goto tr74
+		case 92:
+			goto tr75
+		case 95:
+			goto tr73
+		case 126:
+			goto tr73
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr73
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr73
+				}
+			case data[p] >= 97:
+				goto tr73
+			}
+		default:
+			goto tr73
+		}
+		goto tr0
+tr81:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st46
+	st46:
+		if p++; p == pe {
+			goto _test_eof46
+		}
+	st_case_46:
+// line 1807 "parse.go"
+		switch data[p] {
+		case 34:
+			goto st47
+		case 39:
+			goto st47
+		case 85:
+			goto st48
+		case 92:
+			goto st47
+		case 98:
+			goto st47
+		case 102:
+			goto st47
+		case 110:
+			goto st47
+		case 114:
+			goto st47
+		case 116:
+			goto st47
+		case 117:
+			goto st52
+		}
+		goto tr0
+	st47:
+		if p++; p == pe {
+			goto _test_eof47
+		}
+	st_case_47:
+		switch data[p] {
+		case 34:
+			goto tr80
+		case 92:
+			goto tr81
+		}
+		switch {
+		case data[p] < 11:
+			if 0 <= data[p] && data[p] <= 9 {
+				goto tr79
+			}
+		case data[p] > 12:
+			if 14 <= data[p] && data[p] <= 1114111 {
+				goto tr79
+			}
+		default:
+			goto tr79
+		}
+		goto tr0
+	st48:
+		if p++; p == pe {
+			goto _test_eof48
+		}
+	st_case_48:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st49
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st49
+			}
+		default:
+			goto st49
+		}
+		goto tr0
+	st49:
+		if p++; p == pe {
+			goto _test_eof49
+		}
+	st_case_49:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st50
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st50
+			}
+		default:
+			goto st50
+		}
+		goto tr0
+	st50:
+		if p++; p == pe {
+			goto _test_eof50
+		}
+	st_case_50:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st51
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st51
+			}
+		default:
+			goto st51
+		}
+		goto tr0
+	st51:
+		if p++; p == pe {
+			goto _test_eof51
+		}
+	st_case_51:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st52
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st52
+			}
+		default:
+			goto st52
+		}
+		goto tr0
+	st52:
+		if p++; p == pe {
+			goto _test_eof52
+		}
+	st_case_52:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st53
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st53
+			}
+		default:
+			goto st53
+		}
+		goto tr0
+	st53:
+		if p++; p == pe {
+			goto _test_eof53
+		}
+	st_case_53:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st54
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st54
+			}
+		default:
+			goto st54
+		}
+		goto tr0
+	st54:
+		if p++; p == pe {
+			goto _test_eof54
+		}
+	st_case_54:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st55
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st55
+			}
+		default:
+			goto st55
+		}
+		goto tr0
+	st55:
+		if p++; p == pe {
+			goto _test_eof55
+		}
+	st_case_55:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st47
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st47
+			}
+		default:
+			goto st47
+		}
+		goto tr0
+tr17:
+// line 46 "actions.rl"
+
+
+		if predicate < 0 {
+			panic("unexpected parser state: predicate start not set")
+		}
+		q.Predicate = unEscape(data[predicate:p], isEscaped)
+		isEscaped = false
+	
+// line 30 "actions.rl"
+
+
+		object = p
+	
+	goto st56
+tr21:
+// line 30 "actions.rl"
+
+
+		object = p
+	
+	goto st56
+	st56:
+		if p++; p == pe {
+			goto _test_eof56
+		}
+	st_case_56:
+// line 2027 "parse.go"
+		if data[p] == 58 {
+			goto st57
+		}
+		goto tr0
+	st57:
+		if p++; p == pe {
+			goto _test_eof57
+		}
+	st_case_57:
+		if data[p] == 95 {
+			goto st58
+		}
+		switch {
+		case data[p] < 895:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st58
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st58
+					}
+				case data[p] > 767:
+					if 880 <= data[p] && data[p] <= 893 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		case data[p] > 8191:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8204 <= data[p] && data[p] <= 8205 {
+						goto st58
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st58
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		default:
+			goto st58
+		}
+		goto tr0
+	st58:
+		if p++; p == pe {
+			goto _test_eof58
+		}
+	st_case_58:
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 45:
+			goto st58
+		case 46:
+			goto tr90
+		case 60:
+			goto tr27
+		case 95:
+			goto tr91
+		case 183:
+			goto st58
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st58
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st58
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st58
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st58
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		default:
+			goto st58
+		}
+		goto tr0
+tr90:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+	goto st91
+	st91:
+		if p++; p == pe {
+			goto _test_eof91
+		}
+	st_case_91:
+// line 2211 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st88
+		case 32:
+			goto st88
+		case 35:
+			goto tr127
+		case 45:
+			goto st58
+		case 46:
+			goto st59
+		case 95:
+			goto st58
+		case 183:
+			goto st58
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st58
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st58
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st58
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st58
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		default:
+			goto st58
+		}
+		goto st0
+	st59:
+		if p++; p == pe {
+			goto _test_eof59
+		}
+	st_case_59:
+		switch data[p] {
+		case 45:
+			goto st58
+		case 46:
+			goto st59
+		case 95:
+			goto st58
+		case 183:
+			goto st58
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st58
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st58
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st58
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st58
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		default:
+			goto st58
+		}
+		goto tr0
+tr91:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+// line 34 "actions.rl"
+
+
+		label = p
+	
+	goto st60
+	st60:
+		if p++; p == pe {
+			goto _test_eof60
+		}
+	st_case_60:
+// line 2398 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 45:
+			goto st58
+		case 46:
+			goto tr90
+		case 58:
+			goto st61
+		case 60:
+			goto tr27
+		case 95:
+			goto tr91
+		case 183:
+			goto st58
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 57 {
+						goto st58
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st58
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st58
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st58
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st58
+					}
+				default:
+					goto st58
+				}
+			default:
+				goto st58
+			}
+		default:
+			goto st58
+		}
+		goto tr0
+	st61:
+		if p++; p == pe {
+			goto _test_eof61
+		}
+	st_case_61:
+		switch data[p] {
+		case 9:
+			goto tr25
+		case 32:
+			goto tr25
+		case 45:
+			goto st58
+		case 46:
+			goto tr90
+		case 60:
+			goto tr27
+		case 95:
+			goto tr95
+		case 183:
+			goto st58
+		}
+		switch {
+		case data[p] < 895:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st62
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st62
+					}
+				case data[p] > 767:
+					switch {
+					case data[p] > 879:
+						if 880 <= data[p] && data[p] <= 893 {
+							goto st62
+						}
+					case data[p] >= 768:
+						goto st58
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		case data[p] > 8191:
+			switch {
+			case data[p] < 11264:
+				switch {
+				case data[p] < 8255:
+					if 8204 <= data[p] && data[p] <= 8205 {
+						goto st62
+					}
+				case data[p] > 8256:
+					if 8304 <= data[p] && data[p] <= 8591 {
+						goto st62
+					}
+				default:
+					goto st58
+				}
+			case data[p] > 12271:
+				switch {
+				case data[p] < 63744:
+					if 12289 <= data[p] && data[p] <= 55295 {
+						goto st62
+					}
+				case data[p] > 64975:
+					switch {
+					case data[p] > 65533:
+						if 65536 <= data[p] && data[p] <= 983039 {
+							goto st62
+						}
+					case data[p] >= 65008:
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		default:
+			goto st62
+		}
+		goto tr0
+tr95:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+// line 34 "actions.rl"
+
+
+		label = p
+	
+	goto st62
+	st62:
+		if p++; p == pe {
+			goto _test_eof62
+		}
+	st_case_62:
+// line 2603 "parse.go"
+		switch data[p] {
+		case 9:
+			goto tr96
+		case 32:
+			goto tr96
+		case 45:
+			goto st62
+		case 46:
+			goto tr97
+		case 60:
+			goto tr27
+		case 95:
+			goto tr95
+		case 183:
+			goto st62
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st62
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st62
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st62
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st62
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		default:
+			goto st62
+		}
+		goto tr0
+tr97:
+// line 54 "actions.rl"
+
+
+		if object < 0 {
+			panic("unexpected parser state: object start not set")
+		}
+		q.Object = unEscape(data[object:p], isEscaped)
+		isEscaped = false
+	
+// line 62 "actions.rl"
+
+
+		if label < 0 {
+			panic("unexpected parser state: label start not set")
+		}
+		q.Label = unEscape(data[label:p], isEscaped)
+		isEscaped = false
+	
+	goto st92
+	st92:
+		if p++; p == pe {
+			goto _test_eof92
+		}
+	st_case_92:
+// line 2712 "parse.go"
+		switch data[p] {
+		case 9:
+			goto st88
+		case 32:
+			goto st88
+		case 35:
+			goto tr127
+		case 45:
+			goto st62
+		case 46:
+			goto st63
+		case 95:
+			goto st62
+		case 183:
+			goto st62
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st62
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st62
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st62
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st62
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		default:
+			goto st62
+		}
+		goto st0
+	st63:
+		if p++; p == pe {
+			goto _test_eof63
+		}
+	st_case_63:
+		switch data[p] {
+		case 45:
+			goto st62
+		case 46:
+			goto st63
+		case 95:
+			goto st62
+		case 183:
+			goto st62
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st62
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st62
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st62
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st62
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st62
+					}
+				default:
+					goto st62
+				}
+			default:
+				goto st62
+			}
+		default:
+			goto st62
+		}
+		goto tr0
+tr110:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st64
+	st64:
+		if p++; p == pe {
+			goto _test_eof64
+		}
+	st_case_64:
+// line 2890 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st65
+		case 117:
+			goto st69
+		}
+		goto tr0
+	st65:
+		if p++; p == pe {
+			goto _test_eof65
+		}
+	st_case_65:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st66
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st66
+			}
+		default:
+			goto st66
+		}
+		goto tr0
+	st66:
+		if p++; p == pe {
+			goto _test_eof66
+		}
+	st_case_66:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st67
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st67
+			}
+		default:
+			goto st67
+		}
+		goto tr0
+	st67:
+		if p++; p == pe {
+			goto _test_eof67
+		}
+	st_case_67:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st68
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st68
+			}
+		default:
+			goto st68
+		}
+		goto tr0
+	st68:
+		if p++; p == pe {
+			goto _test_eof68
+		}
+	st_case_68:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st69
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st69
+			}
+		default:
+			goto st69
+		}
+		goto tr0
+	st69:
+		if p++; p == pe {
+			goto _test_eof69
+		}
+	st_case_69:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st70
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st70
+			}
+		default:
+			goto st70
+		}
+		goto tr0
+	st70:
+		if p++; p == pe {
+			goto _test_eof70
+		}
+	st_case_70:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st71
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st71
+			}
+		default:
+			goto st71
+		}
+		goto tr0
+	st71:
+		if p++; p == pe {
+			goto _test_eof71
+		}
+	st_case_71:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st72
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st72
+			}
+		default:
+			goto st72
+		}
+		goto tr0
+	st72:
+		if p++; p == pe {
+			goto _test_eof72
+		}
+	st_case_72:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st73
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st73
+			}
+		default:
+			goto st73
+		}
+		goto tr0
+	st73:
+		if p++; p == pe {
+			goto _test_eof73
+		}
+	st_case_73:
+		switch data[p] {
+		case 33:
+			goto tr108
+		case 62:
+			goto tr109
+		case 92:
+			goto tr110
+		case 95:
+			goto tr108
+		case 126:
+			goto tr108
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr108
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr108
+				}
+			case data[p] >= 97:
+				goto tr108
+			}
+		default:
+			goto tr108
+		}
+		goto tr0
+tr122:
+// line 18 "actions.rl"
+
+
+		isEscaped = true
+	
+	goto st74
+	st74:
+		if p++; p == pe {
+			goto _test_eof74
+		}
+	st_case_74:
+// line 3089 "parse.go"
+		switch data[p] {
+		case 85:
+			goto st75
+		case 117:
+			goto st79
+		}
+		goto tr0
+	st75:
+		if p++; p == pe {
+			goto _test_eof75
+		}
+	st_case_75:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st76
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st76
+			}
+		default:
+			goto st76
+		}
+		goto tr0
+	st76:
+		if p++; p == pe {
+			goto _test_eof76
+		}
+	st_case_76:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st77
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st77
+			}
+		default:
+			goto st77
+		}
+		goto tr0
+	st77:
+		if p++; p == pe {
+			goto _test_eof77
+		}
+	st_case_77:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st78
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st78
+			}
+		default:
+			goto st78
+		}
+		goto tr0
+	st78:
+		if p++; p == pe {
+			goto _test_eof78
+		}
+	st_case_78:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st79
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st79
+			}
+		default:
+			goto st79
+		}
+		goto tr0
+	st79:
+		if p++; p == pe {
+			goto _test_eof79
+		}
+	st_case_79:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st80
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st80
+			}
+		default:
+			goto st80
+		}
+		goto tr0
+	st80:
+		if p++; p == pe {
+			goto _test_eof80
+		}
+	st_case_80:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st81
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st81
+			}
+		default:
+			goto st81
+		}
+		goto tr0
+	st81:
+		if p++; p == pe {
+			goto _test_eof81
+		}
+	st_case_81:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st82
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st82
+			}
+		default:
+			goto st82
+		}
+		goto tr0
+	st82:
+		if p++; p == pe {
+			goto _test_eof82
+		}
+	st_case_82:
+		switch {
+		case data[p] < 65:
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st83
+			}
+		case data[p] > 70:
+			if 97 <= data[p] && data[p] <= 102 {
+				goto st83
+			}
+		default:
+			goto st83
+		}
+		goto tr0
+	st83:
+		if p++; p == pe {
+			goto _test_eof83
+		}
+	st_case_83:
+		switch data[p] {
+		case 33:
+			goto tr120
+		case 62:
+			goto tr121
+		case 92:
+			goto tr122
+		case 95:
+			goto tr120
+		case 126:
+			goto tr120
+		}
+		switch {
+		case data[p] < 61:
+			if 35 <= data[p] && data[p] <= 59 {
+				goto tr120
+			}
+		case data[p] > 93:
+			switch {
+			case data[p] > 122:
+				if 128 <= data[p] && data[p] <= 1114111 {
+					goto tr120
+				}
+			case data[p] >= 97:
+				goto tr120
+			}
+		default:
+			goto tr120
+		}
+		goto tr0
+tr3:
+// line 22 "actions.rl"
+
+
+		subject = p
+	
+	goto st84
+	st84:
+		if p++; p == pe {
+			goto _test_eof84
+		}
+	st_case_84:
+// line 3288 "parse.go"
+		if data[p] == 58 {
+			goto st85
+		}
+		goto tr0
+	st85:
+		if p++; p == pe {
+			goto _test_eof85
+		}
+	st_case_85:
+		if data[p] == 95 {
+			goto st86
+		}
+		switch {
+		case data[p] < 895:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st86
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st86
+					}
+				case data[p] > 767:
+					if 880 <= data[p] && data[p] <= 893 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			default:
+				goto st86
+			}
+		case data[p] > 8191:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8204 <= data[p] && data[p] <= 8205 {
+						goto st86
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st86
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			default:
+				goto st86
+			}
+		default:
+			goto st86
+		}
+		goto tr0
+	st86:
+		if p++; p == pe {
+			goto _test_eof86
+		}
+	st_case_86:
+		switch data[p] {
+		case 9:
+			goto tr7
+		case 32:
+			goto tr7
+		case 45:
+			goto st86
+		case 46:
+			goto st87
+		case 60:
+			goto tr8
+		case 95:
+			goto st86
+		case 183:
+			goto st86
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st86
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st86
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			default:
+				goto st86
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st86
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st86
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			default:
+				goto st86
+			}
+		default:
+			goto st86
+		}
+		goto tr0
+	st87:
+		if p++; p == pe {
+			goto _test_eof87
+		}
+	st_case_87:
+		switch data[p] {
+		case 45:
+			goto st86
+		case 46:
+			goto st87
+		case 95:
+			goto st86
+		case 183:
+			goto st86
+		}
+		switch {
+		case data[p] < 8204:
+			switch {
+			case data[p] < 192:
+				switch {
+				case data[p] < 65:
+					if 48 <= data[p] && data[p] <= 58 {
+						goto st86
+					}
+				case data[p] > 90:
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			case data[p] > 214:
+				switch {
+				case data[p] < 248:
+					if 216 <= data[p] && data[p] <= 246 {
+						goto st86
+					}
+				case data[p] > 893:
+					if 895 <= data[p] && data[p] <= 8191 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			default:
+				goto st86
+			}
+		case data[p] > 8205:
+			switch {
+			case data[p] < 12289:
+				switch {
+				case data[p] < 8304:
+					if 8255 <= data[p] && data[p] <= 8256 {
+						goto st86
+					}
+				case data[p] > 8591:
+					if 11264 <= data[p] && data[p] <= 12271 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			case data[p] > 55295:
+				switch {
+				case data[p] < 65008:
+					if 63744 <= data[p] && data[p] <= 64975 {
+						goto st86
+					}
+				case data[p] > 65533:
+					if 65536 <= data[p] && data[p] <= 983039 {
+						goto st86
+					}
+				default:
+					goto st86
+				}
+			default:
+				goto st86
+			}
+		default:
+			goto st86
+		}
+		goto tr0
+	st_out:
+	_test_eof1: cs = 1; goto _test_eof
+	_test_eof2: cs = 2; goto _test_eof
+	_test_eof3: cs = 3; goto _test_eof
+	_test_eof4: cs = 4; goto _test_eof
+	_test_eof5: cs = 5; goto _test_eof
+	_test_eof6: cs = 6; goto _test_eof
+	_test_eof7: cs = 7; goto _test_eof
+	_test_eof8: cs = 8; goto _test_eof
+	_test_eof9: cs = 9; goto _test_eof
+	_test_eof10: cs = 10; goto _test_eof
+	_test_eof88: cs = 88; goto _test_eof
+	_test_eof89: cs = 89; goto _test_eof
+	_test_eof11: cs = 11; goto _test_eof
+	_test_eof12: cs = 12; goto _test_eof
+	_test_eof13: cs = 13; goto _test_eof
+	_test_eof14: cs = 14; goto _test_eof
+	_test_eof15: cs = 15; goto _test_eof
+	_test_eof16: cs = 16; goto _test_eof
+	_test_eof17: cs = 17; goto _test_eof
+	_test_eof18: cs = 18; goto _test_eof
+	_test_eof19: cs = 19; goto _test_eof
+	_test_eof20: cs = 20; goto _test_eof
+	_test_eof21: cs = 21; goto _test_eof
+	_test_eof22: cs = 22; goto _test_eof
+	_test_eof23: cs = 23; goto _test_eof
+	_test_eof24: cs = 24; goto _test_eof
+	_test_eof25: cs = 25; goto _test_eof
+	_test_eof26: cs = 26; goto _test_eof
+	_test_eof90: cs = 90; goto _test_eof
+	_test_eof27: cs = 27; goto _test_eof
+	_test_eof28: cs = 28; goto _test_eof
+	_test_eof29: cs = 29; goto _test_eof
+	_test_eof30: cs = 30; goto _test_eof
+	_test_eof31: cs = 31; goto _test_eof
+	_test_eof32: cs = 32; goto _test_eof
+	_test_eof33: cs = 33; goto _test_eof
+	_test_eof34: cs = 34; goto _test_eof
+	_test_eof35: cs = 35; goto _test_eof
+	_test_eof36: cs = 36; goto _test_eof
+	_test_eof37: cs = 37; goto _test_eof
+	_test_eof38: cs = 38; goto _test_eof
+	_test_eof39: cs = 39; goto _test_eof
+	_test_eof40: cs = 40; goto _test_eof
+	_test_eof41: cs = 41; goto _test_eof
+	_test_eof42: cs = 42; goto _test_eof
+	_test_eof43: cs = 43; goto _test_eof
+	_test_eof44: cs = 44; goto _test_eof
+	_test_eof45: cs = 45; goto _test_eof
+	_test_eof46: cs = 46; goto _test_eof
+	_test_eof47: cs = 47; goto _test_eof
+	_test_eof48: cs = 48; goto _test_eof
+	_test_eof49: cs = 49; goto _test_eof
+	_test_eof50: cs = 50; goto _test_eof
+	_test_eof51: cs = 51; goto _test_eof
+	_test_eof52: cs = 52; goto _test_eof
+	_test_eof53: cs = 53; goto _test_eof
+	_test_eof54: cs = 54; goto _test_eof
+	_test_eof55: cs = 55; goto _test_eof
+	_test_eof56: cs = 56; goto _test_eof
+	_test_eof57: cs = 57; goto _test_eof
+	_test_eof58: cs = 58; goto _test_eof
+	_test_eof91: cs = 91; goto _test_eof
+	_test_eof59: cs = 59; goto _test_eof
+	_test_eof60: cs = 60; goto _test_eof
+	_test_eof61: cs = 61; goto _test_eof
+	_test_eof62: cs = 62; goto _test_eof
+	_test_eof92: cs = 92; goto _test_eof
+	_test_eof63: cs = 63; goto _test_eof
+	_test_eof64: cs = 64; goto _test_eof
+	_test_eof65: cs = 65; goto _test_eof
+	_test_eof66: cs = 66; goto _test_eof
+	_test_eof67: cs = 67; goto _test_eof
+	_test_eof68: cs = 68; goto _test_eof
+	_test_eof69: cs = 69; goto _test_eof
+	_test_eof70: cs = 70; goto _test_eof
+	_test_eof71: cs = 71; goto _test_eof
+	_test_eof72: cs = 72; goto _test_eof
+	_test_eof73: cs = 73; goto _test_eof
+	_test_eof74: cs = 74; goto _test_eof
+	_test_eof75: cs = 75; goto _test_eof
+	_test_eof76: cs = 76; goto _test_eof
+	_test_eof77: cs = 77; goto _test_eof
+	_test_eof78: cs = 78; goto _test_eof
+	_test_eof79: cs = 79; goto _test_eof
+	_test_eof80: cs = 80; goto _test_eof
+	_test_eof81: cs = 81; goto _test_eof
+	_test_eof82: cs = 82; goto _test_eof
+	_test_eof83: cs = 83; goto _test_eof
+	_test_eof84: cs = 84; goto _test_eof
+	_test_eof85: cs = 85; goto _test_eof
+	_test_eof86: cs = 86; goto _test_eof
+	_test_eof87: cs = 87; goto _test_eof
+
+	_test_eof: {}
+	if p == eof {
+		switch cs {
+		case 89:
+// line 70 "actions.rl"
+
+
+		return q, nil
+	
+		case 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87:
+// line 77 "actions.rl"
+
+
+		if p < len(data) {
+			if r := data[p]; r < unicode.MaxASCII {
+				return q, fmt.Errorf("%v: unexpected rune %q at %d", quad.ErrInvalid, data[p], p)
+			} else {
+				return q, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", quad.ErrInvalid, data[p], data[p], p)
+			}
+		}
+		return q, quad.ErrIncomplete
+	
+		case 88, 90, 91, 92:
+// line 74 "actions.rl"
+
+
+	
+// line 70 "actions.rl"
+
+
+		return q, nil
+	
+// line 3664 "parse.go"
+		}
+	}
+
+	_out: {}
+	}
+
+// line 60 "parse.rl"
+
+	return quad.Quad{}, quad.ErrInvalid
+}
diff --git a/vendor/github.com/google/cayley/quad/nquads/parse.rl b/vendor/github.com/google/cayley/quad/nquads/parse.rl
new file mode 100644
index 00000000..ce5e6c92
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/nquads/parse.rl
@@ -0,0 +1,62 @@
+// GO SOURCE FILE MACHINE GENERATED BY RAGEL; DO NOT EDIT
+
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package nquads
+
+import (
+	"fmt"
+	"unicode"
+
+	"github.com/google/cayley/quad"
+)
+
+%%{
+	machine quads;
+
+	include "actions.rl";
+
+	include "nquads.rl";
+
+	write data;
+}%%
+
+// Parse returns a valid quad.Quad or a non-nil error. Parse does
+// handle comments except where the comment placement does not prevent
+// a complete valid quad.Quad from being defined.
+func Parse(statement string) (quad.Quad, error) {
+	data := []rune(statement)
+
+	var (
+		cs, p int
+		pe    = len(data)
+		eof   = pe
+
+		subject   = -1
+		predicate = -1
+		object    = -1
+		label     = -1
+
+		isEscaped bool
+
+		q quad.Quad
+	)
+
+	%%write init;
+
+	%%write exec;
+
+	return quad.Quad{}, quad.ErrInvalid
+}
diff --git a/vendor/github.com/google/cayley/quad/ntriple_tests.tar.gz b/vendor/github.com/google/cayley/quad/ntriple_tests.tar.gz
new file mode 100644
index 00000000..5e2ba801
Binary files /dev/null and b/vendor/github.com/google/cayley/quad/ntriple_tests.tar.gz differ
diff --git a/vendor/github.com/google/cayley/quad/quad.go b/vendor/github.com/google/cayley/quad/quad.go
new file mode 100644
index 00000000..62e22cac
--- /dev/null
+++ b/vendor/github.com/google/cayley/quad/quad.go
@@ -0,0 +1,141 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package quad defines quad and triple handling.
+package quad
+
+// Defines the struct which makes the QuadStore possible -- the quad.
+//
+// At its heart, it consists of three fields -- Subject, Predicate, and Object.
+// Three IDs that relate to each other. That's all there is to it. The quads
+// are the links in the graph, and the existence of node IDs is defined by the
+// fact that some quad in the graph mentions them.
+//
+// This means that a complete representation of the graph is equivalent to a
+// list of quads. The rest is just indexing for speed.
+//
+// Adding fields to the quad is not to be taken lightly. You'll see I mention
+// label, but don't as yet use it in any backing store. In general, there
+// can be features that can be turned on or off for any store, but I haven't
+// decided how to allow/disallow them yet. Another such example would be to add
+// a forward and reverse index field -- forward being "order the list of
+// objects pointed at by this subject with this predicate" such as first and
+// second children, top billing, what have you.
+//
+// There will never be that much in this file except for the definition, but
+// the consequences are not to be taken lightly. But do suggest cool features!
+
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	ErrInvalid    = errors.New("invalid N-Quad")
+	ErrIncomplete = errors.New("incomplete N-Quad")
+)
+
+// Our quad struct, used throughout.
+type Quad struct {
+	Subject   string `json:"subject"`
+	Predicate string `json:"predicate"`
+	Object    string `json:"object"`
+	Label     string `json:"label,omitempty"`
+}
+
+// Direction specifies an edge's type.
+type Direction byte
+
+// List of the valid directions of a quad.
+const (
+	Any Direction = iota
+	Subject
+	Predicate
+	Object
+	Label
+)
+
+var Directions = []Direction{Subject, Predicate, Object, Label}
+
+func (d Direction) Prefix() byte {
+	switch d {
+	case Any:
+		return 'a'
+	case Subject:
+		return 's'
+	case Predicate:
+		return 'p'
+	case Label:
+		return 'c'
+	case Object:
+		return 'o'
+	default:
+		return '\x00'
+	}
+}
+
+func (d Direction) String() string {
+	switch d {
+	case Any:
+		return "any"
+	case Subject:
+		return "subject"
+	case Predicate:
+		return "predicate"
+	case Label:
+		return "label"
+	case Object:
+		return "object"
+	default:
+		return fmt.Sprint("illegal direction:", byte(d))
+	}
+}
+
+// Per-field accessor for quads.
+func (q Quad) Get(d Direction) string {
+	switch d {
+	case Subject:
+		return q.Subject
+	case Predicate:
+		return q.Predicate
+	case Label:
+		return q.Label
+	case Object:
+		return q.Object
+	default:
+		panic(d.String())
+	}
+}
+
+// Pretty-prints a quad.
+func (q Quad) String() string {
+	return fmt.Sprintf("%s -- %s -> %s", q.Subject, q.Predicate, q.Object)
+}
+
+func (q Quad) IsValid() bool {
+	return q.Subject != "" && q.Predicate != "" && q.Object != ""
+}
+
+// Prints a quad in N-Quad format.
+func (q Quad) NQuad() string {
+	if q.Label == "" {
+		//TODO(barakmich): Proper escaping.
+		return fmt.Sprintf("%s %s %s .", q.Subject, q.Predicate, q.Object)
+	}
+	return fmt.Sprintf("%s %s %s %s .", q.Subject, q.Predicate, q.Object, q.Label)
+}
+
+type Unmarshaler interface {
+	Unmarshal() (Quad, error)
+}
diff --git a/vendor/github.com/google/cayley/query/gremlin/build_iterator.go b/vendor/github.com/google/cayley/query/gremlin/build_iterator.go
new file mode 100644
index 00000000..511a83ee
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/gremlin/build_iterator.go
@@ -0,0 +1,251 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gremlin
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/barakmich/glog"
+	"github.com/robertkrimen/otto"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/graph/path"
+)
+
+func propertiesOf(obj *otto.Object, name string) []string {
+	val, _ := obj.Get(name)
+	if val.IsUndefined() {
+		return nil
+	}
+	export, _ := val.Export()
+	return export.([]string)
+}
+
+func buildIteratorTree(obj *otto.Object, qs graph.QuadStore) graph.Iterator {
+	if !isVertexChain(obj) {
+		return iterator.NewNull()
+	}
+	path := buildPathFromObject(obj)
+	if path == nil {
+		return iterator.NewNull()
+	}
+	return path.BuildIteratorOn(qs)
+}
+
+func getFirstArgAsVertexChain(obj *otto.Object) *otto.Object {
+	arg, _ := obj.Get("_gremlin_values")
+	firstArg, _ := arg.Object().Get("0")
+	if !isVertexChain(firstArg.Object()) {
+		return nil
+	}
+	return firstArg.Object()
+}
+
+func getFirstArgAsMorphismChain(obj *otto.Object) *otto.Object {
+	arg, _ := obj.Get("_gremlin_values")
+	firstArg, _ := arg.Object().Get("0")
+	if isVertexChain(firstArg.Object()) {
+		return nil
+	}
+	return firstArg.Object()
+}
+
+func buildPathFromObject(obj *otto.Object) *path.Path {
+	var p *path.Path
+	val, _ := obj.Get("_gremlin_type")
+	stringArgs := propertiesOf(obj, "string_args")
+	gremlinType := val.String()
+	if prev, _ := obj.Get("_gremlin_prev"); !prev.IsObject() {
+		switch gremlinType {
+		case "vertex":
+			return path.StartMorphism(stringArgs...)
+		case "morphism":
+			return path.StartMorphism()
+		default:
+			panic("No base gremlin path other than 'vertex' or 'morphism'")
+		}
+	} else {
+		p = buildPathFromObject(prev.Object())
+	}
+	if p == nil {
+		return nil
+	}
+	switch gremlinType {
+	case "Is":
+		return p.Is(stringArgs...)
+	case "In":
+		preds, tags, ok := getViaData(obj)
+		if !ok {
+			return nil
+		}
+		return p.InWithTags(tags, preds...)
+	case "Out":
+		preds, tags, ok := getViaData(obj)
+		if !ok {
+			return nil
+		}
+		return p.OutWithTags(tags, preds...)
+	case "Both":
+		preds, _, ok := getViaData(obj)
+		if !ok {
+			return nil
+		}
+		return p.Both(preds...)
+	case "Follow":
+		subobj := getFirstArgAsMorphismChain(obj)
+		if subobj == nil {
+			return nil
+		}
+		return p.Follow(buildPathFromObject(subobj))
+	case "FollowR":
+		subobj := getFirstArgAsMorphismChain(obj)
+		if subobj == nil {
+			return nil
+		}
+		return p.FollowReverse(buildPathFromObject(subobj))
+	case "And", "Intersect":
+		subobj := getFirstArgAsVertexChain(obj)
+		if subobj == nil {
+			return nil
+		}
+		return p.And(buildPathFromObject(subobj))
+	case "Union", "Or":
+		subobj := getFirstArgAsVertexChain(obj)
+		if subobj == nil {
+			return nil
+		}
+		return p.Or(buildPathFromObject(subobj))
+	case "Back":
+		if len(stringArgs) != 1 {
+			return nil
+		}
+		return p.Back(stringArgs[0])
+	case "Tag", "As":
+		return p.Tag(stringArgs...)
+	case "Has":
+		if len(stringArgs) < 2 {
+			return nil
+		}
+		return p.Has(stringArgs[0], stringArgs[1:]...)
+	case "Save", "SaveR":
+		if len(stringArgs) > 2 || len(stringArgs) == 0 {
+			return nil
+		}
+		tag := stringArgs[0]
+		if len(stringArgs) == 2 {
+			tag = stringArgs[1]
+		}
+		if gremlinType == "SaveR" {
+			return p.SaveReverse(stringArgs[0], tag)
+		}
+		return p.Save(stringArgs[0], tag)
+	case "Except", "Difference":
+		subobj := getFirstArgAsVertexChain(obj)
+		if subobj == nil {
+			return nil
+		}
+		return p.Except(buildPathFromObject(subobj))
+	case "InPredicates":
+		return p.InPredicates()
+	case "OutPredicates":
+		return p.OutPredicates()
+	default:
+		panic(fmt.Sprint("Unimplemented Gremlin function", gremlinType))
+	}
+}
+
+func stringsFrom(obj *otto.Object) []string {
+	var output []string
+	lengthValue, _ := obj.Get("length")
+	length, _ := lengthValue.ToInteger()
+	ulength := uint32(length)
+	for i := uint32(0); i < ulength; i++ {
+		name := strconv.FormatInt(int64(i), 10)
+		value, err := obj.Get(name)
+		if err != nil || !value.IsString() {
+			continue
+		}
+		output = append(output, value.String())
+	}
+	return output
+}
+
+func buildPathFromValue(val otto.Value) (out []interface{}) {
+	if val.IsNull() || val.IsUndefined() {
+		return nil
+	}
+	if val.IsPrimitive() {
+		thing, _ := val.Export()
+		switch v := thing.(type) {
+		case string:
+			out = append(out, v)
+			return
+		default:
+			glog.Errorln("Trying to build unknown primitive value.")
+		}
+	}
+	switch val.Class() {
+	case "Object":
+		out = append(out, buildPathFromObject(val.Object()))
+		return
+	case "Array":
+		// Had better be an array of strings
+		for _, x := range stringsFrom(val.Object()) {
+			out = append(out, x)
+		}
+		return
+	case "Number":
+		fallthrough
+	case "Boolean":
+		fallthrough
+	case "Date":
+		fallthrough
+	case "String":
+		out = append(out, val.String())
+		return
+	default:
+		glog.Errorln("Trying to handle unsupported Javascript value.")
+		return nil
+	}
+}
+
+func getViaData(obj *otto.Object) (predicates []interface{}, tags []string, ok bool) {
+	argList, _ := obj.Get("_gremlin_values")
+	if argList.Class() != "GoArray" {
+		glog.Errorln("How is arglist not an array? Return nothing.", argList.Class())
+		return nil, nil, false
+	}
+	argArray := argList.Object()
+	lengthVal, _ := argArray.Get("length")
+	length, _ := lengthVal.ToInteger()
+	if length == 0 {
+		predicates = []interface{}{}
+	} else {
+		zero, _ := argArray.Get("0")
+		predicates = buildPathFromValue(zero)
+	}
+	if length >= 2 {
+		one, _ := argArray.Get("1")
+		if one.IsString() {
+			tags = append(tags, one.String())
+		} else if one.Class() == "Array" {
+			tags = stringsFrom(one.Object())
+		}
+	}
+	ok = true
+	return
+}
diff --git a/vendor/github.com/google/cayley/query/gremlin/environ.go b/vendor/github.com/google/cayley/query/gremlin/environ.go
new file mode 100644
index 00000000..48e6069c
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/gremlin/environ.go
@@ -0,0 +1,120 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gremlin
+
+// Builds a new Gremlin environment pointing at a session.
+
+import (
+	"sync"
+
+	"github.com/barakmich/glog"
+	"github.com/robertkrimen/otto"
+
+	"github.com/google/cayley/graph"
+)
+
+type worker struct {
+	qs  graph.QuadStore
+	env *otto.Otto
+	sync.Mutex
+
+	results chan interface{}
+	shape   map[string]interface{}
+
+	count int
+	limit int
+
+	kill <-chan struct{}
+}
+
+func newWorker(qs graph.QuadStore) *worker {
+	env := otto.New()
+	wk := &worker{
+		qs:    qs,
+		env:   env,
+		limit: -1,
+	}
+	graph, _ := env.Object("graph = {}")
+	env.Run("g = graph")
+
+	graph.Set("Vertex", func(call otto.FunctionCall) otto.Value {
+		call.Otto.Run("var out = {}")
+		out, err := call.Otto.Object("out")
+		if err != nil {
+			glog.Error(err.Error())
+			return otto.TrueValue()
+		}
+		out.Set("_gremlin_type", "vertex")
+		args := argsOf(call)
+		if len(args) > 0 {
+			out.Set("string_args", args)
+		}
+		wk.embedTraversals(env, out)
+		wk.embedFinals(env, out)
+		return out.Value()
+	})
+	env.Run("graph.V = graph.Vertex")
+
+	graph.Set("Morphism", func(call otto.FunctionCall) otto.Value {
+		call.Otto.Run("var out = {}")
+		out, _ := call.Otto.Object("out")
+		out.Set("_gremlin_type", "morphism")
+		wk.embedTraversals(env, out)
+		return out.Value()
+	})
+	env.Run("graph.M = graph.Morphism")
+
+	graph.Set("Emit", func(call otto.FunctionCall) otto.Value {
+		value := call.Argument(0)
+		if value.IsDefined() {
+			wk.send(&Result{val: &value})
+		}
+		return otto.NullValue()
+	})
+
+	return wk
+}
+
+func (wk *worker) wantShape() bool {
+	return wk.shape != nil
+}
+
+func argsOf(call otto.FunctionCall) []string {
+	var out []string
+	for _, arg := range call.ArgumentList {
+		if arg.IsString() {
+			out = append(out, arg.String())
+		}
+		if arg.IsObject() && arg.Class() == "Array" {
+			obj, _ := arg.Export()
+			for _, x := range obj.([]interface{}) {
+				out = append(out, x.(string))
+			}
+		}
+	}
+	return out
+}
+
+func isVertexChain(obj *otto.Object) bool {
+	val, _ := obj.Get("_gremlin_type")
+	if val.String() == "vertex" {
+		return true
+	}
+	val, _ = obj.Get("_gremlin_prev")
+	if val.IsObject() {
+		return isVertexChain(val.Object())
+	}
+	return false
+}
diff --git a/vendor/github.com/google/cayley/query/gremlin/finals.go b/vendor/github.com/google/cayley/query/gremlin/finals.go
new file mode 100644
index 00000000..0631d41e
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/gremlin/finals.go
@@ -0,0 +1,321 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gremlin
+
+import (
+	"encoding/json"
+
+	"github.com/barakmich/glog"
+	"github.com/robertkrimen/otto"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+)
+
+const TopResultTag = "id"
+
+func (wk *worker) embedFinals(env *otto.Otto, obj *otto.Object) {
+	obj.Set("All", wk.allFunc(env, obj))
+	obj.Set("GetLimit", wk.limitFunc(env, obj))
+	obj.Set("ToArray", wk.toArrayFunc(env, obj, false))
+	obj.Set("ToValue", wk.toValueFunc(env, obj, false))
+	obj.Set("TagArray", wk.toArrayFunc(env, obj, true))
+	obj.Set("TagValue", wk.toValueFunc(env, obj, true))
+	obj.Set("Map", wk.mapFunc(env, obj))
+	obj.Set("ForEach", wk.mapFunc(env, obj))
+}
+
+func (wk *worker) allFunc(env *otto.Otto, obj *otto.Object) func(otto.FunctionCall) otto.Value {
+	return func(call otto.FunctionCall) otto.Value {
+		it := buildIteratorTree(obj, wk.qs)
+		it.Tagger().Add(TopResultTag)
+		wk.limit = -1
+		wk.count = 0
+		wk.runIterator(it)
+		return otto.NullValue()
+	}
+}
+
+func (wk *worker) limitFunc(env *otto.Otto, obj *otto.Object) func(otto.FunctionCall) otto.Value {
+	return func(call otto.FunctionCall) otto.Value {
+		if len(call.ArgumentList) > 0 {
+			limitVal, _ := call.Argument(0).ToInteger()
+			it := buildIteratorTree(obj, wk.qs)
+			it.Tagger().Add(TopResultTag)
+			wk.limit = int(limitVal)
+			wk.count = 0
+			wk.runIterator(it)
+		}
+		return otto.NullValue()
+	}
+}
+
+func (wk *worker) toArrayFunc(env *otto.Otto, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value {
+	return func(call otto.FunctionCall) otto.Value {
+		it := buildIteratorTree(obj, wk.qs)
+		it.Tagger().Add(TopResultTag)
+		limit := -1
+		if len(call.ArgumentList) > 0 {
+			limitParsed, _ := call.Argument(0).ToInteger()
+			limit = int(limitParsed)
+		}
+		var val otto.Value
+		var err error
+		if !withTags {
+			array := wk.runIteratorToArrayNoTags(it, limit)
+			val, err = call.Otto.ToValue(array)
+		} else {
+			array := wk.runIteratorToArray(it, limit)
+			val, err = call.Otto.ToValue(array)
+		}
+
+		if err != nil {
+			glog.Error(err)
+			return otto.NullValue()
+		}
+		return val
+	}
+}
+
+func (wk *worker) toValueFunc(env *otto.Otto, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value {
+	return func(call otto.FunctionCall) otto.Value {
+		it := buildIteratorTree(obj, wk.qs)
+		it.Tagger().Add(TopResultTag)
+		limit := 1
+		var val otto.Value
+		var err error
+		if !withTags {
+			array := wk.runIteratorToArrayNoTags(it, limit)
+			if len(array) < 1 {
+				return otto.NullValue()
+			}
+			val, err = call.Otto.ToValue(array[0])
+		} else {
+			array := wk.runIteratorToArray(it, limit)
+			if len(array) < 1 {
+				return otto.NullValue()
+			}
+			val, err = call.Otto.ToValue(array[0])
+		}
+		if err != nil {
+			glog.Error(err)
+			return otto.NullValue()
+		}
+		return val
+	}
+}
+
+func (wk *worker) mapFunc(env *otto.Otto, obj *otto.Object) func(otto.FunctionCall) otto.Value {
+	return func(call otto.FunctionCall) otto.Value {
+		it := buildIteratorTree(obj, wk.qs)
+		it.Tagger().Add(TopResultTag)
+		limit := -1
+		if len(call.ArgumentList) == 0 {
+			return otto.NullValue()
+		}
+		callback := call.Argument(len(call.ArgumentList) - 1)
+		if len(call.ArgumentList) > 1 {
+			limitParsed, _ := call.Argument(0).ToInteger()
+			limit = int(limitParsed)
+		}
+		wk.runIteratorWithCallback(it, callback, call, limit)
+		return otto.NullValue()
+	}
+}
+
+func (wk *worker) tagsToValueMap(m map[string]graph.Value) map[string]string {
+	outputMap := make(map[string]string)
+	for k, v := range m {
+		outputMap[k] = wk.qs.NameOf(v)
+	}
+	return outputMap
+}
+
+func (wk *worker) runIteratorToArray(it graph.Iterator, limit int) []map[string]string {
+	output := make([]map[string]string, 0)
+	n := 0
+	it, _ = it.Optimize()
+	for {
+		select {
+		case <-wk.kill:
+			return nil
+		default:
+		}
+		if !graph.Next(it) {
+			break
+		}
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+		output = append(output, wk.tagsToValueMap(tags))
+		n++
+		if limit >= 0 && n >= limit {
+			break
+		}
+		for it.NextPath() {
+			select {
+			case <-wk.kill:
+				return nil
+			default:
+			}
+			tags := make(map[string]graph.Value)
+			it.TagResults(tags)
+			output = append(output, wk.tagsToValueMap(tags))
+			n++
+			if limit >= 0 && n >= limit {
+				break
+			}
+		}
+	}
+	it.Close()
+	return output
+}
+
+func (wk *worker) runIteratorToArrayNoTags(it graph.Iterator, limit int) []string {
+	output := make([]string, 0)
+	n := 0
+	it, _ = it.Optimize()
+	for {
+		select {
+		case <-wk.kill:
+			return nil
+		default:
+		}
+		if !graph.Next(it) {
+			break
+		}
+		output = append(output, wk.qs.NameOf(it.Result()))
+		n++
+		if limit >= 0 && n >= limit {
+			break
+		}
+	}
+	it.Close()
+	return output
+}
+
+func (wk *worker) runIteratorWithCallback(it graph.Iterator, callback otto.Value, this otto.FunctionCall, limit int) {
+	n := 0
+	it, _ = it.Optimize()
+	if glog.V(2) {
+		b, err := json.MarshalIndent(it.Describe(), "", "  ")
+		if err != nil {
+			glog.V(2).Infof("failed to format description: %v", err)
+		} else {
+			glog.V(2).Infof("%s", b)
+		}
+	}
+	for {
+		select {
+		case <-wk.kill:
+			return
+		default:
+		}
+		if !graph.Next(it) {
+			break
+		}
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+		val, _ := this.Otto.ToValue(wk.tagsToValueMap(tags))
+		val, _ = callback.Call(this.This, val)
+		n++
+		if limit >= 0 && n >= limit {
+			break
+		}
+		for it.NextPath() {
+			select {
+			case <-wk.kill:
+				return
+			default:
+			}
+			tags := make(map[string]graph.Value)
+			it.TagResults(tags)
+			val, _ := this.Otto.ToValue(wk.tagsToValueMap(tags))
+			val, _ = callback.Call(this.This, val)
+			n++
+			if limit >= 0 && n >= limit {
+				break
+			}
+		}
+	}
+	it.Close()
+}
+
+func (wk *worker) send(r *Result) bool {
+	if wk.limit >= 0 && wk.limit == wk.count {
+		return false
+	}
+	select {
+	case <-wk.kill:
+		return false
+	default:
+	}
+	if wk.results != nil {
+		wk.results <- r
+		wk.count++
+		if wk.limit >= 0 && wk.limit == wk.count {
+			return false
+		}
+		return true
+	}
+	return false
+}
+
+func (wk *worker) runIterator(it graph.Iterator) {
+	if wk.wantShape() {
+		iterator.OutputQueryShapeForIterator(it, wk.qs, wk.shape)
+		return
+	}
+	it, _ = it.Optimize()
+	if glog.V(2) {
+		b, err := json.MarshalIndent(it.Describe(), "", "  ")
+		if err != nil {
+			glog.V(2).Infof("failed to format description: %v", err)
+		} else {
+			glog.V(2).Infof("%s", b)
+		}
+	}
+	for {
+		select {
+		case <-wk.kill:
+			return
+		default:
+		}
+		if !graph.Next(it) {
+			break
+		}
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+		if !wk.send(&Result{actualResults: tags}) {
+			break
+		}
+		for it.NextPath() {
+			select {
+			case <-wk.kill:
+				return
+			default:
+			}
+			tags := make(map[string]graph.Value)
+			it.TagResults(tags)
+			if !wk.send(&Result{actualResults: tags}) {
+				break
+			}
+		}
+	}
+	if glog.V(2) {
+		bytes, _ := json.MarshalIndent(graph.DumpStats(it), "", "  ")
+		glog.V(2).Infoln(string(bytes))
+	}
+	it.Close()
+}
diff --git a/vendor/github.com/google/cayley/query/gremlin/session.go b/vendor/github.com/google/cayley/query/gremlin/session.go
new file mode 100644
index 00000000..958b5c6f
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/gremlin/session.go
@@ -0,0 +1,266 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gremlin
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/robertkrimen/otto"
+	// Provide underscore JS library.
+	_ "github.com/robertkrimen/otto/underscore"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/query"
+)
+
+var ErrKillTimeout = errors.New("query timed out")
+
+type Session struct {
+	qs graph.QuadStore
+
+	wk      *worker
+	script  *otto.Script
+	persist *otto.Otto
+
+	timeout time.Duration
+	kill    chan struct{}
+
+	debug      bool
+	dataOutput []interface{}
+
+	err error
+}
+
+func NewSession(qs graph.QuadStore, timeout time.Duration, persist bool) *Session {
+	g := Session{
+		qs:      qs,
+		wk:      newWorker(qs),
+		timeout: timeout,
+	}
+	if persist {
+		g.persist = g.wk.env
+	}
+	return &g
+}
+
+type Result struct {
+	metaresult    bool
+	err           error
+	val           *otto.Value
+	actualResults map[string]graph.Value
+}
+
+func (s *Session) Debug(ok bool) {
+	s.debug = ok
+}
+
+func (s *Session) ShapeOf(query string) (interface{}, error) {
+	// TODO(kortschak) It would be nice to be able
+	// to return an error for bad queries here.
+	s.wk.shape = make(map[string]interface{})
+	s.wk.env.Run(query)
+	out := s.wk.shape
+	s.wk.shape = nil
+	return out, nil
+}
+
+func (s *Session) Parse(input string) (query.ParseResult, error) {
+	script, err := s.wk.env.Compile("", input)
+	if err != nil {
+		return query.ParseFail, err
+	}
+	s.script = script
+	return query.Parsed, nil
+}
+
+func (s *Session) runUnsafe(input interface{}) (otto.Value, error) {
+	wk := s.wk
+	defer func() {
+		if r := recover(); r != nil {
+			if r == ErrKillTimeout {
+				s.err = ErrKillTimeout
+				wk.env = s.persist
+				return
+			}
+			panic(r)
+		}
+	}()
+
+	// Use buffered chan to prevent blocking.
+	wk.env.Interrupt = make(chan func(), 1)
+	s.kill = make(chan struct{})
+	wk.kill = s.kill
+
+	done := make(chan struct{})
+	defer close(done)
+	if s.timeout >= 0 {
+		go func() {
+			time.Sleep(s.timeout)
+			select {
+			case <-done:
+			default:
+				close(s.kill)
+				wk.Lock()
+				if wk.env != nil {
+					wk.env.Interrupt <- func() {
+						panic(ErrKillTimeout)
+					}
+				}
+				wk.Unlock()
+			}
+		}()
+	}
+
+	wk.Lock()
+	env := wk.env
+	wk.Unlock()
+	return env.Run(input)
+}
+
+func (s *Session) Execute(input string, out chan interface{}, _ int) {
+	defer close(out)
+	s.err = nil
+	s.wk.results = out
+	var err error
+	var value otto.Value
+	if s.script == nil {
+		value, err = s.runUnsafe(input)
+	} else {
+		value, err = s.runUnsafe(s.script)
+	}
+	out <- &Result{
+		metaresult: true,
+		err:        err,
+		val:        &value,
+	}
+	s.wk.results = nil
+	s.script = nil
+	s.wk.Lock()
+	s.wk.env = s.persist
+	s.wk.Unlock()
+}
+
+func (s *Session) Format(result interface{}) string {
+	data := result.(*Result)
+	if data.metaresult {
+		if data.err != nil {
+			return fmt.Sprintf("Error: %v\n", data.err)
+		}
+		if data.val != nil {
+			s, _ := data.val.Export()
+			if data.val.IsObject() {
+				typeVal, _ := data.val.Object().Get("_gremlin_type")
+				if !typeVal.IsUndefined() {
+					s = "[internal Iterator]"
+				}
+			}
+			return fmt.Sprintln("=>", s)
+		}
+		return ""
+	}
+	var out string
+	out = fmt.Sprintln("****")
+	if data.val == nil {
+		tags := data.actualResults
+		tagKeys := make([]string, len(tags))
+		i := 0
+		for k := range tags {
+			tagKeys[i] = k
+			i++
+		}
+		sort.Strings(tagKeys)
+		for _, k := range tagKeys {
+			if k == "$_" {
+				continue
+			}
+			out += fmt.Sprintf("%s : %s\n", k, s.qs.NameOf(tags[k]))
+		}
+	} else {
+		if data.val.IsObject() {
+			export, _ := data.val.Export()
+			switch export := export.(type) {
+			case map[string]string:
+				for k, v := range export {
+					out += fmt.Sprintf("%s : %s\n", k, v)
+				}
+			case map[string]interface{}:
+				for k, v := range export {
+					out += fmt.Sprintf("%s : %v\n", k, v)
+				}
+			default:
+				panic(fmt.Sprintf("unexpected type: %T", export))
+			}
+		} else {
+			strVersion, _ := data.val.ToString()
+			out += fmt.Sprintf("%s\n", strVersion)
+		}
+	}
+	return out
+}
+
+// Web stuff
+func (s *Session) Collate(result interface{}) {
+	data := result.(*Result)
+	if !data.metaresult {
+		if data.val == nil {
+			obj := make(map[string]string)
+			tags := data.actualResults
+			var tagKeys []string
+			for k := range tags {
+				tagKeys = append(tagKeys, k)
+			}
+			sort.Strings(tagKeys)
+			for _, k := range tagKeys {
+				name := s.qs.NameOf(tags[k])
+				if name != "" {
+					obj[k] = name
+				} else {
+					delete(obj, k)
+				}
+			}
+			if len(obj) != 0 {
+				s.dataOutput = append(s.dataOutput, obj)
+			}
+		} else {
+			if data.val.IsObject() {
+				export, _ := data.val.Export()
+				s.dataOutput = append(s.dataOutput, export)
+			} else {
+				strVersion, _ := data.val.ToString()
+				s.dataOutput = append(s.dataOutput, strVersion)
+			}
+		}
+	}
+}
+
+func (s *Session) Results() (interface{}, error) {
+	defer s.Clear()
+	if s.err != nil {
+		return nil, s.err
+	}
+	select {
+	case <-s.kill:
+		return nil, ErrKillTimeout
+	default:
+		return s.dataOutput, nil
+	}
+}
+
+func (s *Session) Clear() {
+	s.dataOutput = nil
+}
diff --git a/vendor/github.com/google/cayley/query/gremlin/traversals.go b/vendor/github.com/google/cayley/query/gremlin/traversals.go
new file mode 100644
index 00000000..b5304e43
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/gremlin/traversals.go
@@ -0,0 +1,80 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gremlin
+
+// Adds special traversal functions to JS Gremlin objects. Most of these just build the chain of objects, and won't often need the session.
+
+import (
+	"github.com/barakmich/glog"
+	"github.com/robertkrimen/otto"
+)
+
+var traversals = []string{
+	"In",
+	"Out",
+	"Is",
+	"Both",
+	"Follow",
+	"FollowR",
+	"And",
+	"Intersect",
+	"Union",
+	"Or",
+	"Back",
+	"Tag",
+	"As",
+	"Has",
+	"Save",
+	"SaveR",
+	"Except",
+	"Difference",
+	"InPredicates",
+	"OutPredicates",
+}
+
+func (wk *worker) embedTraversals(env *otto.Otto, obj *otto.Object) {
+	for _, t := range traversals {
+		obj.Set(t, wk.gremlinFunc(t, obj, env))
+	}
+}
+
+func (wk *worker) gremlinFunc(kind string, prev *otto.Object, env *otto.Otto) func(otto.FunctionCall) otto.Value {
+	return func(call otto.FunctionCall) otto.Value {
+		call.Otto.Run("var out = {}")
+		out, _ := call.Otto.Object("out")
+		out.Set("_gremlin_type", kind)
+		out.Set("_gremlin_values", call.ArgumentList)
+		out.Set("_gremlin_prev", prev)
+		args := argsOf(call)
+		if len(args) > 0 {
+			out.Set("string_args", args)
+		}
+		wk.embedTraversals(env, out)
+		if isVertexChain(call.This.Object()) {
+			wk.embedFinals(env, out)
+		}
+		return out.Value()
+	}
+}
+
+func debugChain(obj *otto.Object) bool {
+	val, _ := obj.Get("_gremlin_type")
+	glog.V(2).Infoln(val)
+	val, _ = obj.Get("_gremlin_prev")
+	if val.IsObject() {
+		return debugChain(val.Object())
+	}
+	return false
+}
diff --git a/vendor/github.com/google/cayley/query/mql/build_iterator.go b/vendor/github.com/google/cayley/query/mql/build_iterator.go
new file mode 100644
index 00000000..57ab8afd
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/mql/build_iterator.go
@@ -0,0 +1,190 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mql
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+func (q *Query) buildFixed(s string) graph.Iterator {
+	f := q.ses.qs.FixedIterator()
+	f.Add(q.ses.qs.ValueOf(s))
+	return f
+}
+
+func (q *Query) buildResultIterator(path Path) graph.Iterator {
+	all := q.ses.qs.NodesAllIterator()
+	all.Tagger().Add(string(path))
+	return all
+}
+
+func (q *Query) BuildIteratorTree(query interface{}) {
+	q.isRepeated = make(map[Path]bool)
+	q.queryStructure = make(map[Path]map[string]interface{})
+	q.queryResult = make(map[ResultPath]map[string]interface{})
+	q.queryResult[""] = make(map[string]interface{})
+
+	var isOptional bool
+	q.it, isOptional, q.err = q.buildIteratorTreeInternal(query, NewPath())
+	if isOptional {
+		q.err = errors.New("optional iterator at the top level")
+	}
+}
+
+func (q *Query) buildIteratorTreeInternal(query interface{}, path Path) (it graph.Iterator, optional bool, err error) {
+	err = nil
+	optional = false
+	switch t := query.(type) {
+	case bool:
+		// for JSON booleans
+		// Treat the bool as a string and call it a day.
+		// Things which are really bool-like are special cases and will be dealt with separately.
+		if t {
+			it = q.buildFixed("true")
+		}
+		it = q.buildFixed("false")
+	case float64:
+		// for JSON numbers
+		// Damn you, Javascript, and your lack of integer values.
+		if math.Floor(t) == t {
+			// Treat it like an integer.
+			it = q.buildFixed(fmt.Sprintf("%0.f", t))
+		} else {
+			it = q.buildFixed(fmt.Sprintf("%f", t))
+		}
+	case string:
+		// for JSON strings
+		it = q.buildFixed(t)
+	case []interface{}:
+		// for JSON arrays
+		q.isRepeated[path] = true
+		if len(t) == 0 {
+			it = q.buildResultIterator(path)
+			optional = true
+		} else if len(t) == 1 {
+			it, optional, err = q.buildIteratorTreeInternal(t[0], path)
+		} else {
+			err = fmt.Errorf("multiple fields at location root %s", path.DisplayString())
+		}
+	case map[string]interface{}:
+		// for JSON objects
+		it, err = q.buildIteratorTreeMapInternal(t, path)
+	case nil:
+		it = q.buildResultIterator(path)
+		optional = true
+	default:
+		err = fmt.Errorf("Unknown JSON type: %T")
+	}
+	if err != nil {
+		return nil, false, err
+	}
+	it.Tagger().Add(string(path))
+	return it, optional, nil
+}
+
+func (q *Query) buildIteratorTreeMapInternal(query map[string]interface{}, path Path) (graph.Iterator, error) {
+	it := iterator.NewAnd(q.ses.qs)
+	it.AddSubIterator(q.ses.qs.NodesAllIterator())
+	var err error
+	err = nil
+	outputStructure := make(map[string]interface{})
+	for key, subquery := range query {
+		optional := false
+		outputStructure[key] = nil
+		reverse := false
+		pred := key
+		if strings.HasPrefix(pred, "@") {
+			i := strings.Index(pred, ":")
+			if i != -1 {
+				pred = pred[(i + 1):]
+			}
+		}
+		if strings.HasPrefix(pred, "!") {
+			reverse = true
+			pred = strings.TrimPrefix(pred, "!")
+		}
+
+		// Other special constructs here
+		var subit graph.Iterator
+		if key == "id" {
+			subit, optional, err = q.buildIteratorTreeInternal(subquery, path.Follow(key))
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			var builtIt graph.Iterator
+			builtIt, optional, err = q.buildIteratorTreeInternal(subquery, path.Follow(key))
+			if err != nil {
+				return nil, err
+			}
+			subAnd := iterator.NewAnd(q.ses.qs)
+			predFixed := q.ses.qs.FixedIterator()
+			predFixed.Add(q.ses.qs.ValueOf(pred))
+			subAnd.AddSubIterator(iterator.NewLinksTo(q.ses.qs, predFixed, quad.Predicate))
+			if reverse {
+				lto := iterator.NewLinksTo(q.ses.qs, builtIt, quad.Subject)
+				subAnd.AddSubIterator(lto)
+				hasa := iterator.NewHasA(q.ses.qs, subAnd, quad.Object)
+				subit = hasa
+			} else {
+				lto := iterator.NewLinksTo(q.ses.qs, builtIt, quad.Object)
+				subAnd.AddSubIterator(lto)
+				hasa := iterator.NewHasA(q.ses.qs, subAnd, quad.Subject)
+				subit = hasa
+			}
+		}
+		if optional {
+			it.AddSubIterator(iterator.NewOptional(subit))
+		} else {
+			it.AddSubIterator(subit)
+		}
+	}
+	if err != nil {
+		return nil, err
+	}
+	q.queryStructure[path] = outputStructure
+	return it, nil
+}
+
+type byRecordLength []ResultPath
+
+func (p byRecordLength) Len() int {
+	return len(p)
+}
+
+func (p byRecordLength) Less(i, j int) bool {
+	iLen := len(strings.Split(string(p[i]), "\x30"))
+	jLen := len(strings.Split(string(p[j]), "\x30"))
+	if iLen < jLen {
+		return true
+	}
+	if iLen == jLen {
+		if len(string(p[i])) < len(string(p[j])) {
+			return true
+		}
+	}
+	return false
+}
+
+func (p byRecordLength) Swap(i, j int) {
+	p[i], p[j] = p[j], p[i]
+}
diff --git a/vendor/github.com/google/cayley/query/mql/fill.go b/vendor/github.com/google/cayley/query/mql/fill.go
new file mode 100644
index 00000000..cc279e93
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/mql/fill.go
@@ -0,0 +1,118 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mql
+
+import (
+	"sort"
+
+	"github.com/google/cayley/graph"
+)
+
+func (q *Query) treeifyResult(tags map[string]graph.Value) map[ResultPath]string {
+	// Transform the map into something a little more interesting.
+	results := make(map[Path]string)
+	for k, v := range tags {
+		if v == nil {
+			continue
+		}
+		results[Path(k)] = q.ses.qs.NameOf(v)
+	}
+	resultPaths := make(map[ResultPath]string)
+	for k, v := range results {
+		resultPaths[k.ToResultPathFromMap(results)] = v
+	}
+
+	paths := make([]ResultPath, 0, len(resultPaths))
+	for path := range resultPaths {
+		paths = append(paths, path)
+	}
+	sort.Sort(byRecordLength(paths))
+
+	// Build Structure
+	for _, path := range paths {
+		currentPath := path.getPath()
+		value := resultPaths[path]
+		namePath := path.AppendValue(value)
+		if _, ok := q.queryResult[namePath]; !ok {
+			targetPath, key := path.splitLastPath()
+			if path == "" {
+				targetPath, key = "", value
+				if _, ok := q.queryResult[""][value]; !ok {
+					q.resultOrder = append(q.resultOrder, value)
+				}
+			}
+			if _, ok := q.queryStructure[currentPath]; ok {
+				// If there's substructure, then copy that in.
+				newStruct := q.copyPathStructure(currentPath)
+				if q.isRepeated[currentPath] && currentPath != "" {
+					switch t := q.queryResult[targetPath][key].(type) {
+					case nil:
+						x := make([]interface{}, 0)
+						x = append(x, newStruct)
+						q.queryResult[targetPath][key] = x
+						q.queryResult[namePath] = newStruct
+					case []interface{}:
+						q.queryResult[targetPath][key] = append(t, newStruct)
+						q.queryResult[namePath] = newStruct
+					}
+
+				} else {
+					q.queryResult[namePath] = newStruct
+					q.queryResult[targetPath][key] = newStruct
+				}
+			}
+		}
+	}
+
+	// Fill values
+	for _, path := range paths {
+		currentPath := path.getPath()
+		value, ok := resultPaths[path]
+		if !ok {
+			continue
+		}
+		namePath := path.AppendValue(value)
+		if _, ok := q.queryStructure[currentPath]; ok {
+			// We're dealing with ids.
+			if _, ok := q.queryResult[namePath]["id"]; ok {
+				q.queryResult[namePath]["id"] = value
+			}
+		} else {
+			// Just a value.
+			targetPath, key := path.splitLastPath()
+			if q.isRepeated[currentPath] {
+				switch t := q.queryResult[targetPath][key].(type) {
+				case nil:
+					x := make([]interface{}, 0)
+					x = append(x, value)
+					q.queryResult[targetPath][key] = x
+				case []interface{}:
+					q.queryResult[targetPath][key] = append(t, value)
+				}
+
+			} else {
+				q.queryResult[targetPath][key] = value
+			}
+		}
+	}
+
+	return resultPaths
+}
+
+func (q *Query) buildResults() {
+	for _, v := range q.resultOrder {
+		q.results = append(q.results, q.queryResult[""][v])
+	}
+}
diff --git a/vendor/github.com/google/cayley/query/mql/query.go b/vendor/github.com/google/cayley/query/mql/query.go
new file mode 100644
index 00000000..f68165cc
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/mql/query.go
@@ -0,0 +1,113 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mql
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/google/cayley/graph"
+)
+
+type (
+	Path       string
+	ResultPath string
+)
+
+type Query struct {
+	ses            *Session
+	it             graph.Iterator
+	isRepeated     map[Path]bool
+	queryStructure map[Path]map[string]interface{}
+	queryResult    map[ResultPath]map[string]interface{}
+	results        []interface{}
+	resultOrder    []string
+	err            error
+}
+
+func (q *Query) isError() bool {
+	return q.err != nil
+}
+
+func (q *Query) copyPathStructure(path Path) map[string]interface{} {
+	output := make(map[string]interface{})
+	for k, v := range q.queryStructure[path] {
+		output[k] = v
+	}
+	return output
+}
+
+func NewPath() Path {
+	return ""
+}
+func (p Path) Follow(s string) Path {
+	return Path(fmt.Sprintf("%s\x1E%s", p, s))
+}
+
+func (p Path) DisplayString() string {
+	return strings.Replace(string(p), "\x1E", ".", -1)
+}
+
+func NewResultPath() ResultPath {
+	return ""
+}
+
+func (p ResultPath) FollowPath(followPiece string, value string) ResultPath {
+	if string(p) == "" {
+		return ResultPath(fmt.Sprintf("%s\x1E%s", value, followPiece))
+	}
+	return ResultPath(fmt.Sprintf("%s\x1E%s\x1E%s", p, value, followPiece))
+}
+
+func (p ResultPath) getPath() Path {
+	out := NewPath()
+	pathPieces := strings.Split(string(p), "\x1E")
+	for len(pathPieces) > 1 {
+		a := pathPieces[1]
+		pathPieces = pathPieces[2:]
+		out = out.Follow(a)
+	}
+	return out
+}
+
+func (p ResultPath) splitLastPath() (ResultPath, string) {
+	pathPieces := strings.Split(string(p), "\x1E")
+	return ResultPath(strings.Join(pathPieces[:len(pathPieces)-1], "\x1E")), pathPieces[len(pathPieces)-1]
+}
+
+func (p ResultPath) AppendValue(value string) ResultPath {
+	if string(p) == "" {
+		return ResultPath(value)
+	}
+	return ResultPath(fmt.Sprintf("%s\x1E%s", p, value))
+}
+
+func (p Path) ToResultPathFromMap(resultMap map[Path]string) ResultPath {
+	output := NewResultPath()
+	pathPieces := strings.Split(string(p), "\x1E")[1:]
+	pathSoFar := NewPath()
+	for _, piece := range pathPieces {
+		output = output.FollowPath(piece, resultMap[pathSoFar])
+		pathSoFar = pathSoFar.Follow(piece)
+	}
+	return output
+}
+
+func NewQuery(ses *Session) *Query {
+	var q Query
+	q.ses = ses
+	q.err = nil
+	return &q
+}
diff --git a/vendor/github.com/google/cayley/query/mql/session.go b/vendor/github.com/google/cayley/query/mql/session.go
new file mode 100644
index 00000000..a7442f41
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/mql/session.go
@@ -0,0 +1,144 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mql
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+
+	"github.com/barakmich/glog"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/query"
+)
+
+type Session struct {
+	qs           graph.QuadStore
+	currentQuery *Query
+	debug        bool
+}
+
+func NewSession(qs graph.QuadStore) *Session {
+	var m Session
+	m.qs = qs
+	return &m
+}
+
+func (s *Session) Debug(ok bool) {
+	s.debug = ok
+}
+
+func (s *Session) ShapeOf(query string) (interface{}, error) {
+	var mqlQuery interface{}
+	err := json.Unmarshal([]byte(query), &mqlQuery)
+	if err != nil {
+		return nil, err
+	}
+	s.currentQuery = NewQuery(s)
+	s.currentQuery.BuildIteratorTree(mqlQuery)
+	output := make(map[string]interface{})
+	iterator.OutputQueryShapeForIterator(s.currentQuery.it, s.qs, output)
+	nodes := make([]iterator.Node, 0)
+	for _, n := range output["nodes"].([]iterator.Node) {
+		n.Tags = nil
+		nodes = append(nodes, n)
+	}
+	output["nodes"] = nodes
+	return output, nil
+}
+
+func (s *Session) Parse(input string) (query.ParseResult, error) {
+	var x interface{}
+	err := json.Unmarshal([]byte(input), &x)
+	if err != nil {
+		return query.ParseFail, err
+	}
+	return query.Parsed, nil
+}
+
+func (s *Session) Execute(input string, c chan interface{}, _ int) {
+	defer close(c)
+	var mqlQuery interface{}
+	err := json.Unmarshal([]byte(input), &mqlQuery)
+	if err != nil {
+		return
+	}
+	s.currentQuery = NewQuery(s)
+	s.currentQuery.BuildIteratorTree(mqlQuery)
+	if s.currentQuery.isError() {
+		return
+	}
+	it, _ := s.currentQuery.it.Optimize()
+	if glog.V(2) {
+		b, err := json.MarshalIndent(it.Describe(), "", "  ")
+		if err != nil {
+			glog.Infof("failed to format description: %v", err)
+		} else {
+			glog.Infof("%s", b)
+		}
+	}
+	for graph.Next(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+		c <- tags
+		for it.NextPath() == true {
+			tags := make(map[string]graph.Value)
+			it.TagResults(tags)
+			c <- tags
+		}
+	}
+}
+
+func (s *Session) Format(result interface{}) string {
+	tags := result.(map[string]graph.Value)
+	out := fmt.Sprintln("****")
+	tagKeys := make([]string, len(tags))
+	s.currentQuery.treeifyResult(tags)
+	s.currentQuery.buildResults()
+	r, _ := json.MarshalIndent(s.currentQuery.results, "", " ")
+	fmt.Println(string(r))
+	i := 0
+	for k := range tags {
+		tagKeys[i] = string(k)
+		i++
+	}
+	sort.Strings(tagKeys)
+	for _, k := range tagKeys {
+		if k == "$_" {
+			continue
+		}
+		out += fmt.Sprintf("%s : %s\n", k, s.qs.NameOf(tags[k]))
+	}
+	return out
+}
+
+func (s *Session) Collate(result interface{}) {
+	s.currentQuery.treeifyResult(result.(map[string]graph.Value))
+}
+
+func (s *Session) Results() (interface{}, error) {
+	s.currentQuery.buildResults()
+	if s.currentQuery.isError() {
+		return nil, s.currentQuery.err
+	}
+	return s.currentQuery.results, nil
+}
+
+func (s *Session) Clear() {
+	// Since we create a new Query underneath every query, clearing isn't necessary.
+	return
+}
diff --git a/vendor/github.com/google/cayley/query/session.go b/vendor/github.com/google/cayley/query/session.go
new file mode 100644
index 00000000..3b965dcf
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/session.go
@@ -0,0 +1,44 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package query
+
+// Defines the graph session interface general to all query languages.
+
+type ParseResult int
+
+const (
+	Parsed ParseResult = iota
+	ParseMore
+	ParseFail
+)
+
+type Session interface {
+	// Return whether the string is a valid expression.
+	Parse(string) (ParseResult, error)
+	Execute(string, chan interface{}, int)
+	Format(interface{}) string
+	Debug(bool)
+}
+
+type HTTP interface {
+	// Return whether the string is a valid expression.
+	Parse(string) (ParseResult, error)
+	// Runs the query and returns individual results on the channel.
+	Execute(string, chan interface{}, int)
+	ShapeOf(string) (interface{}, error)
+	Collate(interface{})
+	Results() (interface{}, error)
+	Clear()
+}
diff --git a/vendor/github.com/google/cayley/query/sexp/parser.go b/vendor/github.com/google/cayley/query/sexp/parser.go
new file mode 100644
index 00000000..6f3adbc1
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/sexp/parser.go
@@ -0,0 +1,272 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sexp
+
+import (
+	"github.com/badgerodon/peg"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/graph/iterator"
+	"github.com/google/cayley/quad"
+)
+
+func BuildIteratorTreeForQuery(qs graph.QuadStore, query string) graph.Iterator {
+	tree := parseQuery(query)
+	return buildIteratorTree(tree, qs)
+}
+
+func ParseString(input string) string {
+	return parseQuery(input).String()
+}
+
+func parseQuery(input string) *peg.ExpressionTree {
+	parser := peg.NewParser()
+
+	start := parser.NonTerminal("Start")
+	whitespace := parser.NonTerminal("Whitespace")
+	quotedString := parser.NonTerminal("QuotedString")
+	rootConstraint := parser.NonTerminal("RootConstraint")
+
+	constraint := parser.NonTerminal("Constraint")
+	colonIdentifier := parser.NonTerminal("ColonIdentifier")
+	variable := parser.NonTerminal("Variable")
+	identifier := parser.NonTerminal("Identifier")
+	fixedNode := parser.NonTerminal("FixedNode")
+	nodeIdent := parser.NonTerminal("NodeIdentifier")
+	predIdent := parser.NonTerminal("PredIdentifier")
+	reverse := parser.NonTerminal("Reverse")
+	predKeyword := parser.NonTerminal("PredicateKeyword")
+	optional := parser.NonTerminal("OptionalKeyword")
+
+	start.Expression = rootConstraint
+
+	whitespace.Expression = parser.OneOrMore(
+		parser.OrderedChoice(
+			parser.Terminal(' '),
+			parser.Terminal('\t'),
+			parser.Terminal('\n'),
+			parser.Terminal('\r'),
+		),
+	)
+
+	quotedString.Expression = parser.Sequence(
+		parser.Terminal('"'),
+		parser.OneOrMore(
+			parser.OrderedChoice(
+				parser.Range('0', '9'),
+				parser.Range('a', 'z'),
+				parser.Range('A', 'Z'),
+				parser.Terminal('_'),
+				parser.Terminal('/'),
+				parser.Terminal(':'),
+				parser.Terminal(' '),
+				parser.Terminal('\''),
+			),
+		),
+		parser.Terminal('"'),
+	)
+
+	predKeyword.Expression = parser.OrderedChoice(
+		optional,
+	)
+
+	optional.Expression = parser.Sequence(
+		parser.Terminal('o'),
+		parser.Terminal('p'),
+		parser.Terminal('t'),
+		parser.Terminal('i'),
+		parser.Terminal('o'),
+		parser.Terminal('n'),
+		parser.Terminal('a'),
+		parser.Terminal('l'),
+	)
+
+	identifier.Expression = parser.OneOrMore(
+		parser.OrderedChoice(
+			parser.Range('0', '9'),
+			parser.Range('a', 'z'),
+			parser.Range('A', 'Z'),
+			parser.Terminal('_'),
+			parser.Terminal('.'),
+			parser.Terminal('/'),
+			parser.Terminal(':'),
+			parser.Terminal('#'),
+		),
+	)
+
+	reverse.Expression = parser.Terminal('!')
+
+	variable.Expression = parser.Sequence(
+		parser.Terminal('$'),
+		identifier,
+	)
+
+	colonIdentifier.Expression = parser.Sequence(
+		parser.Terminal(':'),
+		identifier,
+	)
+
+	fixedNode.Expression = parser.OrderedChoice(
+		colonIdentifier,
+		quotedString,
+	)
+
+	nodeIdent.Expression = parser.OrderedChoice(
+		variable,
+		fixedNode,
+	)
+
+	predIdent.Expression = parser.Sequence(
+		parser.Optional(reverse),
+		parser.OrderedChoice(
+			nodeIdent,
+			constraint,
+		),
+	)
+
+	constraint.Expression = parser.Sequence(
+		parser.Terminal('('),
+		parser.Optional(whitespace),
+		predIdent,
+		parser.Optional(whitespace),
+		parser.Optional(predKeyword),
+		parser.Optional(whitespace),
+		parser.OrderedChoice(
+			nodeIdent,
+			rootConstraint,
+		),
+		parser.Optional(whitespace),
+		parser.Terminal(')'),
+	)
+
+	rootConstraint.Expression = parser.Sequence(
+		parser.Terminal('('),
+		parser.Optional(whitespace),
+		nodeIdent,
+		parser.Optional(whitespace),
+		parser.ZeroOrMore(parser.Sequence(
+			constraint,
+			parser.Optional(whitespace),
+		)),
+		parser.Terminal(')'),
+	)
+
+	tree := parser.Parse(input)
+	return tree
+}
+
+func getIdentString(tree *peg.ExpressionTree) string {
+	out := ""
+	if len(tree.Children) > 0 {
+		for _, child := range tree.Children {
+			out += getIdentString(child)
+		}
+	} else {
+		if tree.Value != '"' {
+			out += string(tree.Value)
+		}
+	}
+	return out
+}
+
+func buildIteratorTree(tree *peg.ExpressionTree, qs graph.QuadStore) graph.Iterator {
+	switch tree.Name {
+	case "Start":
+		return buildIteratorTree(tree.Children[0], qs)
+	case "NodeIdentifier":
+		var out graph.Iterator
+		nodeID := getIdentString(tree)
+		if tree.Children[0].Name == "Variable" {
+			allIt := qs.NodesAllIterator()
+			allIt.Tagger().Add(nodeID)
+			out = allIt
+		} else {
+			n := nodeID
+			if tree.Children[0].Children[0].Name == "ColonIdentifier" {
+				n = nodeID[1:]
+			}
+			fixed := qs.FixedIterator()
+			fixed.Add(qs.ValueOf(n))
+			out = fixed
+		}
+		return out
+	case "PredIdentifier":
+		i := 0
+		if tree.Children[0].Name == "Reverse" {
+			//Taken care of below
+			i++
+		}
+		it := buildIteratorTree(tree.Children[i], qs)
+		lto := iterator.NewLinksTo(qs, it, quad.Predicate)
+		return lto
+	case "RootConstraint":
+		constraintCount := 0
+		and := iterator.NewAnd(qs)
+		for _, c := range tree.Children {
+			switch c.Name {
+			case "NodeIdentifier":
+				fallthrough
+			case "Constraint":
+				it := buildIteratorTree(c, qs)
+				and.AddSubIterator(it)
+				constraintCount++
+				continue
+			default:
+				continue
+			}
+		}
+		return and
+	case "Constraint":
+		var hasa *iterator.HasA
+		topLevelDir := quad.Subject
+		subItDir := quad.Object
+		subAnd := iterator.NewAnd(qs)
+		isOptional := false
+		for _, c := range tree.Children {
+			switch c.Name {
+			case "PredIdentifier":
+				if c.Children[0].Name == "Reverse" {
+					topLevelDir = quad.Object
+					subItDir = quad.Subject
+				}
+				it := buildIteratorTree(c, qs)
+				subAnd.AddSubIterator(it)
+				continue
+			case "PredicateKeyword":
+				switch c.Children[0].Name {
+				case "OptionalKeyword":
+					isOptional = true
+				}
+			case "NodeIdentifier":
+				fallthrough
+			case "RootConstraint":
+				it := buildIteratorTree(c, qs)
+				l := iterator.NewLinksTo(qs, it, subItDir)
+				subAnd.AddSubIterator(l)
+				continue
+			default:
+				continue
+			}
+		}
+		hasa = iterator.NewHasA(qs, subAnd, topLevelDir)
+		if isOptional {
+			optional := iterator.NewOptional(hasa)
+			return optional
+		}
+		return hasa
+	default:
+		return &iterator.Null{}
+	}
+}
diff --git a/vendor/github.com/google/cayley/query/sexp/session.go b/vendor/github.com/google/cayley/query/sexp/session.go
new file mode 100644
index 00000000..c4de301f
--- /dev/null
+++ b/vendor/github.com/google/cayley/query/sexp/session.go
@@ -0,0 +1,124 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sexp
+
+// Defines a running session of the sexp query language.
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sort"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/query"
+)
+
+type Session struct {
+	qs    graph.QuadStore
+	debug bool
+}
+
+func NewSession(qs graph.QuadStore) *Session {
+	var s Session
+	s.qs = qs
+	return &s
+}
+
+func (s *Session) Debug(ok bool) {
+	s.debug = ok
+}
+
+func (s *Session) Parse(input string) (query.ParseResult, error) {
+	var parenDepth int
+	for i, x := range input {
+		if x == '(' {
+			parenDepth++
+		}
+		if x == ')' {
+			parenDepth--
+			if parenDepth < 0 {
+				min := 0
+				if (i - 10) > min {
+					min = i - 10
+				}
+				return query.ParseFail, fmt.Errorf("too many close parentheses at char %d: %s", i, input[min:i])
+			}
+		}
+	}
+	if parenDepth > 0 {
+		return query.ParseMore, nil
+	}
+	if len(ParseString(input)) > 0 {
+		return query.Parsed, nil
+	}
+	return query.ParseFail, errors.New("invalid syntax")
+}
+
+func (s *Session) Execute(input string, out chan interface{}, limit int) {
+	it := BuildIteratorTreeForQuery(s.qs, input)
+	newIt, changed := it.Optimize()
+	if changed {
+		it = newIt
+	}
+
+	if s.debug {
+		b, err := json.MarshalIndent(it.Describe(), "", "  ")
+		if err != nil {
+			fmt.Printf("failed to format description: %v", err)
+		} else {
+			fmt.Printf("%s", b)
+		}
+	}
+	nResults := 0
+	for graph.Next(it) {
+		tags := make(map[string]graph.Value)
+		it.TagResults(tags)
+		out <- &tags
+		nResults++
+		if nResults > limit && limit != -1 {
+			break
+		}
+		for it.NextPath() == true {
+			tags := make(map[string]graph.Value)
+			it.TagResults(tags)
+			out <- &tags
+			nResults++
+			if nResults > limit && limit != -1 {
+				break
+			}
+		}
+	}
+	close(out)
+}
+
+func (s *Session) Format(result interface{}) string {
+	out := fmt.Sprintln("****")
+	tags := result.(map[string]graph.Value)
+	tagKeys := make([]string, len(tags))
+	i := 0
+	for k := range tags {
+		tagKeys[i] = k
+		i++
+	}
+	sort.Strings(tagKeys)
+	for _, k := range tagKeys {
+		if k == "$_" {
+			continue
+		}
+		out += fmt.Sprintf("%s : %s\n", k, s.qs.NameOf(tags[k]))
+	}
+	return out
+}
diff --git a/vendor/github.com/google/cayley/static/branding/cayley_bottom.png b/vendor/github.com/google/cayley/static/branding/cayley_bottom.png
new file mode 100644
index 00000000..8ef57031
Binary files /dev/null and b/vendor/github.com/google/cayley/static/branding/cayley_bottom.png differ
diff --git a/vendor/github.com/google/cayley/static/branding/cayley_bottom.svg b/vendor/github.com/google/cayley/static/branding/cayley_bottom.svg
new file mode 100644
index 00000000..9a9fb9e3
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/branding/cayley_bottom.svg
@@ -0,0 +1,266 @@
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   height="210"
+   version="1.1"
+   width="210"
+   id="svg2"
+   inkscape:version="0.48.4 r9939"
+   sodipodi:docname="cayley_bottom.svg"
+   inkscape:export-filename="U:\home\barak\src\cayley\static\text\cayley_bottom.png"
+   inkscape:export-xdpi="250"
+   inkscape:export-ydpi="250">
+  <metadata
+     id="metadata44">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="2172"
+     inkscape:window-height="1473"
+     id="namedview42"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     showguides="false"
+     inkscape:zoom="4.6240876"
+     inkscape:cx="119.5"
+     inkscape:cy="88"
+     inkscape:window-x="997"
+     inkscape:window-y="558"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg2"
+     inkscape:snap-global="false">
+    <inkscape:grid
+       type="xygrid"
+       id="grid3037"
+       empspacing="5"
+       visible="true"
+       enabled="true"
+       snapvisiblegridlinesonly="true"
+       originx="-245.73938px"
+       originy="74.494766px" />
+  </sodipodi:namedview>
+  <defs
+     id="defs4" />
+  <line
+     x1="15"
+     x2="55"
+     y1="62.062759"
+     y2="62.062759"
+     id="line6"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="195"
+     x2="155"
+     y1="62.062759"
+     y2="62.062759"
+     id="line8"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="130"
+     y1="62.062759"
+     y2="18.761484"
+     id="line10"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="80"
+     y1="62.062759"
+     y2="18.761484"
+     id="line12"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="80"
+     y1="62.062759"
+     y2="105.36402"
+     id="line14"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="130"
+     y1="62.062759"
+     y2="105.36402"
+     id="line16"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="130"
+     x2="55"
+     y1="18.761484"
+     y2="62.062759"
+     id="line18"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="80"
+     x2="55"
+     y1="18.761484"
+     y2="62.062759"
+     id="line20"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="55"
+     x2="80"
+     y1="62.062759"
+     y2="105.36402"
+     id="line22"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="55"
+     x2="130"
+     y1="62.062759"
+     y2="105.36402"
+     id="line24"
+     style="stroke:#999999;stroke-width:2.5" />
+  <circle
+     cx="155"
+     cy="65"
+     r="15"
+     id="circle26"
+     sodipodi:cx="155"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#4285f4"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="130"
+     cy="21.69873"
+     r="15"
+     id="circle28"
+     sodipodi:cx="130"
+     sodipodi:cy="21.69873"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#db4437"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="80"
+     cy="21.69873"
+     r="15"
+     id="circle30"
+     sodipodi:cx="80"
+     sodipodi:cy="21.69873"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#f4b400"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="55"
+     cy="65"
+     r="15"
+     id="circle32"
+     sodipodi:cx="55"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#4285f4"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="80"
+     cy="108.30127"
+     r="15"
+     id="circle34"
+     sodipodi:cx="80"
+     sodipodi:cy="108.30127"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#db4437"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="130"
+     cy="108.30127"
+     r="15"
+     id="circle36"
+     sodipodi:cx="130"
+     sodipodi:cy="108.30127"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#f4b400"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="15"
+     cy="65"
+     r="15"
+     id="circle38"
+     sodipodi:cx="15"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#999999"
+     transform="translate(0,-2.9372461)" />
+  <circle
+     cx="195"
+     cy="65"
+     r="15"
+     id="circle40"
+     sodipodi:cx="195"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#999999"
+     transform="translate(0,-2.9372461)" />
+  <flowRoot
+     xml:space="preserve"
+     id="flowRoot3025"
+     style="font-size:72px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Open Sans;-inkscape-font-specification:Open Sans"
+     transform="translate(0,15.761484)"><flowRegion
+       id="flowRegion3027"><rect
+         id="rect3029"
+         width="305.06277"
+         height="118.24139"
+         x="220.71725"
+         y="-0.062292095"
+         style="font-size:72px" /></flowRegion><flowPara
+       id="flowPara3031" /></flowRoot>  <text
+     xml:space="preserve"
+     style="font-size:100px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Open Sans;-inkscape-font-specification:Open Sans"
+     x="0.46484375"
+     y="188.70313"
+     id="text3033"
+     sodipodi:linespacing="125%"><tspan
+       sodipodi:role="line"
+       id="tspan3035"
+       x="0.46484375"
+       y="188.70313"
+       style="font-size:72px;font-style:normal;font-variant:normal;font-weight:300;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Open Sans Light;-inkscape-font-specification:'Open Sans Light, Light'">Cayley</tspan></text>
+</svg>
diff --git a/vendor/github.com/google/cayley/static/branding/cayley_side.png b/vendor/github.com/google/cayley/static/branding/cayley_side.png
new file mode 100644
index 00000000..058b3676
Binary files /dev/null and b/vendor/github.com/google/cayley/static/branding/cayley_side.png differ
diff --git a/vendor/github.com/google/cayley/static/branding/cayley_side.svg b/vendor/github.com/google/cayley/static/branding/cayley_side.svg
new file mode 100644
index 00000000..c8de91af
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/branding/cayley_side.svg
@@ -0,0 +1,265 @@
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   height="116.60254"
+   version="1.1"
+   width="430.28"
+   id="svg2"
+   inkscape:version="0.48.4 r9939"
+   sodipodi:docname="cayley_side.svg"
+   inkscape:export-filename="U:\home\barak\src\cayley\static\text\cayley_side.png"
+   inkscape:export-xdpi="250"
+   inkscape:export-ydpi="250">
+  <metadata
+     id="metadata44">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="2172"
+     inkscape:window-height="1473"
+     id="namedview42"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     showguides="false"
+     inkscape:zoom="3.2360288"
+     inkscape:cx="245.81598"
+     inkscape:cy="52.763956"
+     inkscape:window-x="323"
+     inkscape:window-y="134"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg2"
+     inkscape:snap-global="false">
+    <inkscape:grid
+       type="xygrid"
+       id="grid3037"
+       empspacing="5"
+       visible="true"
+       enabled="true"
+       snapvisiblegridlinesonly="true"
+       originx="-245.73938px"
+       originy="-3.1412048px" />
+  </sodipodi:namedview>
+  <defs
+     id="defs4" />
+  <line
+     x1="15"
+     x2="55"
+     y1="58.30127"
+     y2="58.30127"
+     id="line6"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="195"
+     x2="155"
+     y1="58.30127"
+     y2="58.30127"
+     id="line8"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="130"
+     y1="58.30127"
+     y2="15"
+     id="line10"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="80"
+     y1="58.30127"
+     y2="15"
+     id="line12"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="80"
+     y1="58.30127"
+     y2="101.60254"
+     id="line14"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="155"
+     x2="130"
+     y1="58.30127"
+     y2="101.60254"
+     id="line16"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="130"
+     x2="55"
+     y1="15"
+     y2="58.30127"
+     id="line18"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="80"
+     x2="55"
+     y1="15"
+     y2="58.30127"
+     id="line20"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="55"
+     x2="80"
+     y1="58.30127"
+     y2="101.60254"
+     id="line22"
+     style="stroke:#999999;stroke-width:2.5" />
+  <line
+     x1="55"
+     x2="130"
+     y1="58.30127"
+     y2="101.60254"
+     id="line24"
+     style="stroke:#999999;stroke-width:2.5" />
+  <circle
+     cx="155"
+     cy="65"
+     r="15"
+     id="circle26"
+     sodipodi:cx="155"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#4285f4"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="130"
+     cy="21.69873"
+     r="15"
+     id="circle28"
+     sodipodi:cx="130"
+     sodipodi:cy="21.69873"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#db4437"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="80"
+     cy="21.69873"
+     r="15"
+     id="circle30"
+     sodipodi:cx="80"
+     sodipodi:cy="21.69873"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#f4b400"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="55"
+     cy="65"
+     r="15"
+     id="circle32"
+     sodipodi:cx="55"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#4285f4"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="80"
+     cy="108.30127"
+     r="15"
+     id="circle34"
+     sodipodi:cx="80"
+     sodipodi:cy="108.30127"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#db4437"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="130"
+     cy="108.30127"
+     r="15"
+     id="circle36"
+     sodipodi:cx="130"
+     sodipodi:cy="108.30127"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#f4b400"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="15"
+     cy="65"
+     r="15"
+     id="circle38"
+     sodipodi:cx="15"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#999999"
+     transform="translate(0,-6.6987305)" />
+  <circle
+     cx="195"
+     cy="65"
+     r="15"
+     id="circle40"
+     sodipodi:cx="195"
+     sodipodi:cy="65"
+     sodipodi:rx="15"
+     sodipodi:ry="15"
+     style="fill:#999999"
+     transform="translate(0,-6.6987305)" />
+  <flowRoot
+     xml:space="preserve"
+     id="flowRoot3025"
+     style="font-size:72px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Open Sans;-inkscape-font-specification:Open Sans"><flowRegion
+       id="flowRegion3027"><rect
+         id="rect3029"
+         width="305.06277"
+         height="118.24139"
+         x="220.71725"
+         y="-0.062292095"
+         style="font-size:72px" /></flowRegion><flowPara
+       id="flowPara3031" /></flowRoot>  <text
+     xml:space="preserve"
+     style="font-size:100px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Open Sans;-inkscape-font-specification:Open Sans"
+     x="224.53387"
+     y="78.020462"
+     id="text3033"
+     sodipodi:linespacing="125%"><tspan
+       sodipodi:role="line"
+       id="tspan3035"
+       x="224.53387"
+       y="78.020462"
+       style="font-size:72px;font-style:normal;font-variant:normal;font-weight:300;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;font-family:Open Sans Light;-inkscape-font-specification:'Open Sans Light, Light'">Cayley</tspan></text>
+</svg>
diff --git a/vendor/github.com/google/cayley/static/cayley.png b/vendor/github.com/google/cayley/static/cayley.png
new file mode 100644
index 00000000..dd53060a
Binary files /dev/null and b/vendor/github.com/google/cayley/static/cayley.png differ
diff --git a/vendor/github.com/google/cayley/static/cayley.svg b/vendor/github.com/google/cayley/static/cayley.svg
new file mode 100644
index 00000000..ab37cddf
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/cayley.svg
@@ -0,0 +1,17 @@
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<?xml version="1.0" encoding="utf-8" ?>
+<svg baseProfile="full" height="100%" version="1.1" width="100%" xmlns="http://www.w3.org/2000/svg" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:xlink="http://www.w3.org/1999/xlink"><defs /><line stroke="#999999" stroke-width="2.5" x1="15" x2="55.0" y1="65" y2="65.0" /><line stroke="#999999" stroke-width="2.5" x1="195" x2="155.0" y1="65" y2="65.0" /><line stroke="#999999" stroke-width="2.5" x1="155.0" x2="130.0" y1="65.0" y2="21.6987298108" /><line stroke="#999999" stroke-width="2.5" x1="155.0" x2="80.0" y1="65.0" y2="21.6987298108" /><line stroke="#999999" stroke-width="2.5" x1="155.0" x2="80.0" y1="65.0" y2="108.301270189" /><line stroke="#999999" stroke-width="2.5" x1="155.0" x2="130.0" y1="65.0" y2="108.301270189" /><line stroke="#999999" stroke-width="2.5" x1="130.0" x2="55.0" y1="21.6987298108" y2="65.0" /><line stroke="#999999" stroke-width="2.5" x1="80.0" x2="55.0" y1="21.6987298108" y2="65.0" /><line stroke="#999999" stroke-width="2.5" x1="55.0" x2="80.0" y1="65.0" y2="108.301270189" /><line stroke="#999999" stroke-width="2.5" x1="55.0" x2="130.0" y1="65.0" y2="108.301270189" /><circle cx="155.0" cy="65.0" fill="#4285F4" r="15" /><circle cx="130.0" cy="21.6987298108" fill="#DB4437" r="15" /><circle cx="80.0" cy="21.6987298108" fill="#F4B400" r="15" /><circle cx="55.0" cy="65.0" fill="#4285F4" r="15" /><circle cx="80.0" cy="108.301270189" fill="#DB4437" r="15" /><circle cx="130.0" cy="108.301270189" fill="#F4B400" r="15" /><circle cx="15" cy="65" fill="#999999" r="15" /><circle cx="195" cy="65" fill="#999999" r="15" /></svg>
diff --git a/vendor/github.com/google/cayley/static/css/docs.css b/vendor/github.com/google/cayley/static/css/docs.css
new file mode 100644
index 00000000..e302a092
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/css/docs.css
@@ -0,0 +1,293 @@
+/*
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+body {
+  font-family: Helvetica, arial, sans-serif;
+  font-size: 14px;
+  line-height: 1.6;
+  padding-top: 10px;
+  padding-bottom: 10px;
+  background-color: white;
+  padding: 30px; }
+
+body > *:first-child {
+  margin-top: 0 !important; }
+body > *:last-child {
+  margin-bottom: 0 !important; }
+
+a {
+  color: #4183C4; }
+a.absent {
+  color: #cc0000; }
+a.anchor {
+  display: block;
+  padding-left: 30px;
+  margin-left: -30px;
+  cursor: pointer;
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0; }
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 20px 0 10px;
+  padding: 0;
+  font-weight: bold;
+  -webkit-font-smoothing: antialiased;
+  cursor: text;
+  position: relative; }
+
+h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor, h5:hover a.anchor, h6:hover a.anchor {
+  background: url("../../images/modules/styleguide/para.png") no-repeat 10px center;
+  text-decoration: none; }
+
+h1 tt, h1 code {
+  font-size: inherit; }
+
+h2 tt, h2 code {
+  font-size: inherit; }
+
+h3 tt, h3 code {
+  font-size: inherit; }
+
+h4 tt, h4 code {
+  font-size: inherit; }
+
+h5 tt, h5 code {
+  font-size: inherit; }
+
+h6 tt, h6 code {
+  font-size: inherit; }
+
+h1 {
+  font-size: 28px;
+  color: black; }
+
+h2 {
+  font-size: 24px;
+  border-bottom: 1px solid #cccccc;
+  color: black; }
+
+h3 {
+  font-size: 18px; }
+
+h4 {
+  font-size: 16px; }
+
+h5 {
+  font-size: 14px; }
+
+h6 {
+  color: #777777;
+  font-size: 14px; }
+
+p, blockquote, ul, ol, dl, li, table, pre {
+  margin: 15px 0; }
+
+hr {
+  background: transparent url("../../images/modules/pulls/dirty-shade.png") repeat-x 0 0;
+  border: 0 none;
+  color: #cccccc;
+  height: 4px;
+  padding: 0; }
+
+body > h2:first-child {
+  margin-top: 0;
+  padding-top: 0; }
+body > h1:first-child {
+  margin-top: 0;
+  padding-top: 0; }
+  body > h1:first-child + h2 {
+    margin-top: 0;
+    padding-top: 0; }
+body > h3:first-child, body > h4:first-child, body > h5:first-child, body > h6:first-child {
+  margin-top: 0;
+  padding-top: 0; }
+
+a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
+  margin-top: 0;
+  padding-top: 0; }
+
+h1 p, h2 p, h3 p, h4 p, h5 p, h6 p {
+  margin-top: 0; }
+
+li p.first {
+  display: inline-block; }
+
+ul, ol {
+  padding-left: 30px; }
+
+ul :first-child, ol :first-child {
+  margin-top: 0; }
+
+ul :last-child, ol :last-child {
+  margin-bottom: 0; }
+
+dl {
+  padding: 0; }
+  dl dt {
+    font-size: 14px;
+    font-weight: bold;
+    font-style: italic;
+    padding: 0;
+    margin: 15px 0 5px; }
+    dl dt:first-child {
+      padding: 0; }
+    dl dt > :first-child {
+      margin-top: 0; }
+    dl dt > :last-child {
+      margin-bottom: 0; }
+  dl dd {
+    margin: 0 0 15px;
+    padding: 0 15px; }
+    dl dd > :first-child {
+      margin-top: 0; }
+    dl dd > :last-child {
+      margin-bottom: 0; }
+
+blockquote {
+  border-left: 4px solid #dddddd;
+  padding: 0 15px;
+  color: #777777; }
+  blockquote > :first-child {
+    margin-top: 0; }
+  blockquote > :last-child {
+    margin-bottom: 0; }
+
+table {
+  padding: 0; }
+  table tr {
+    border-top: 1px solid #cccccc;
+    background-color: white;
+    margin: 0;
+    padding: 0; }
+    table tr:nth-child(2n) {
+      background-color: #f8f8f8; }
+    table tr th {
+      font-weight: bold;
+      border: 1px solid #cccccc;
+      text-align: left;
+      margin: 0;
+      padding: 6px 13px; }
+    table tr td {
+      border: 1px solid #cccccc;
+      text-align: left;
+      margin: 0;
+      padding: 6px 13px; }
+    table tr th :first-child, table tr td :first-child {
+      margin-top: 0; }
+    table tr th :last-child, table tr td :last-child {
+      margin-bottom: 0; }
+
+img {
+  max-width: 100%; }
+
+span.frame {
+  display: block;
+  overflow: hidden; }
+  span.frame > span {
+    border: 1px solid #dddddd;
+    display: block;
+    float: left;
+    overflow: hidden;
+    margin: 13px 0 0;
+    padding: 7px;
+    width: auto; }
+  span.frame span img {
+    display: block;
+    float: left; }
+  span.frame span span {
+    clear: both;
+    color: #333333;
+    display: block;
+    padding: 5px 0 0; }
+span.align-center {
+  display: block;
+  overflow: hidden;
+  clear: both; }
+  span.align-center > span {
+    display: block;
+    overflow: hidden;
+    margin: 13px auto 0;
+    text-align: center; }
+  span.align-center span img {
+    margin: 0 auto;
+    text-align: center; }
+span.align-right {
+  display: block;
+  overflow: hidden;
+  clear: both; }
+  span.align-right > span {
+    display: block;
+    overflow: hidden;
+    margin: 13px 0 0;
+    text-align: right; }
+  span.align-right span img {
+    margin: 0;
+    text-align: right; }
+span.float-left {
+  display: block;
+  margin-right: 13px;
+  overflow: hidden;
+  float: left; }
+  span.float-left span {
+    margin: 13px 0 0; }
+span.float-right {
+  display: block;
+  margin-left: 13px;
+  overflow: hidden;
+  float: right; }
+  span.float-right > span {
+    display: block;
+    overflow: hidden;
+    margin: 13px auto 0;
+    text-align: right; }
+
+code, tt {
+  margin: 0 2px;
+  padding: 0 5px;
+  white-space: nowrap;
+  border: 1px solid #eaeaea;
+  background-color: #f8f8f8;
+  border-radius: 3px; }
+
+pre code {
+  margin: 0;
+  padding: 0;
+  white-space: pre;
+  border: none;
+  background: transparent; }
+
+.highlight pre {
+  background-color: #f8f8f8;
+  border: 1px solid #cccccc;
+  font-size: 13px;
+  line-height: 19px;
+  overflow: auto;
+  padding: 6px 10px;
+  border-radius: 3px; }
+
+pre {
+  background-color: #f8f8f8;
+  border: 1px solid #cccccc;
+  font-size: 13px;
+  line-height: 19px;
+  overflow: auto;
+  padding: 6px 10px;
+  border-radius: 3px; }
+  pre code, pre tt {
+    background-color: transparent;
+    border: none; }
diff --git a/vendor/github.com/google/cayley/static/css/grid.css b/vendor/github.com/google/cayley/static/css/grid.css
new file mode 100644
index 00000000..6793fb67
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/css/grid.css
@@ -0,0 +1,172 @@
+/*
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+body {
+  padding-top: 104px;  
+  font-weight: 300;
+  font-family: 'Open Sans', sans-serif;
+}
+.text-center {
+  padding-top: 20px;
+}
+.col-xs-12 {
+  background-color: #fff;
+}
+#sidebar {
+  height: 100%;
+  padding-right: 0;
+  padding-top: 20px;
+}
+#sidebar .nav {
+  width: 95%;
+}
+#sidebar li {
+  border:0 #f2f2f2 solid;
+  border-bottom-width:1px;
+}
+
+.navbar-color-back {
+  background-color: #2c3e50;
+  border-color: #2c3e50;
+  padding-top: 20px;
+  padding-left:20px;
+}
+.navbar-toggle .icon-bar {
+  /*display:block;*/
+  width:22px;
+  height:2px;
+  border-radius:1px;
+  background-color: #ddd;
+}
+.navbar-toggle .icon-bar+.icon-bar {
+  margin-top:4px;
+}
+
+#logo {
+  width: 105px;
+  height: 65px;
+  float:left;
+}
+
+#logo-div h1 {
+  float:left;
+  font-weight: 300;
+  font-family: 'Open Sans', sans-serif;
+  padding-left: 15px;
+  margin-top: 8.0px;
+}
+
+h2 {
+  font-weight: 300;
+  font-family: 'Open Sans', sans-serif;
+}
+
+.navbar {
+  background-color: #ffffff;
+  border-bottom: 1px solid rgba(0,0,0,0.2);
+  padding-top: 10px;
+  padding-bottom: 10px;
+  padding-left 20px;
+}
+
+.bottompad {
+  padding-bottom: 10px;
+}
+
+.button-row {
+  padding-top: 10px;
+  padding-bottom: 10px;
+}
+
+#alertBox {
+  position: fixed;
+  top: 0px;
+  right: 0%;
+  display: none;
+  z-index: 2000;
+}
+
+.at-bottom {
+  position: fixed;
+  bottom: 0%;
+}
+
+
+/* collapsed sidebar styles */
+@media screen and (max-width: 767px) {
+  .row-offcanvas {
+    position: relative;
+    -webkit-transition: all 0.25s ease-out;
+    -moz-transition: all 0.25s ease-out;
+    transition: all 0.25s ease-out;
+  }
+  .row-offcanvas-right
+  .sidebar-offcanvas {
+      right: -41.6%;
+  }
+
+  .row-offcanvas-left
+  .sidebar-offcanvas {
+    left: -41.6%;
+  }
+  .row-offcanvas-right.active {
+    right: 41.6%;
+  }
+  .row-offcanvas-left.active {
+    left: 41.6%;
+  }
+  .sidebar-offcanvas {
+    position: absolute;
+    top: 0;
+    width: 41.6%;
+  }
+  #sidebar {
+    background-color:#3b3b3b;
+    padding-top:0;
+  }
+  #sidebar .nav>li {
+    color: #ddd;
+    background: linear-gradient(#3E3E3E, #383838);
+    border-top: 1px solid #484848;
+    border-bottom: 1px solid #2E2E2E;
+  }
+  #sidebar .nav>li:first-child {
+    border-top:0;
+  }
+  #sidebar .nav>li>a {
+    color: #ddd;
+  }
+  #sidebar .nav>li>a>img {
+    max-width: 14px;
+  }
+  #sidebar .nav>li>a:hover, #sidebar .nav>li>a:focus {
+    text-decoration: none;
+    background: linear-gradient(#373737, #323232);
+    color: #fff;  
+  }
+  #sidebar .nav .caret {
+    border-top-color: #fff;
+    border-bottom-color: #fff;
+  }
+  #sidebar .nav a:hover .caret{
+    border-top-color: #fff;
+    border-bottom-color: #fff;
+  }
+  .hide-small {
+    display: none;
+  }
+}
+
diff --git a/vendor/github.com/google/cayley/static/css/query_editor.css b/vendor/github.com/google/cayley/static/css/query_editor.css
new file mode 100644
index 00000000..0eefa820
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/css/query_editor.css
@@ -0,0 +1,45 @@
+/*
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+.codecol {
+  /* background-color: rgba(0,0,0,.2); */
+  margin-bottom: 10px;
+  padding-bottom: 10px;
+  border: 0 #f2f2f2 solid;
+  border-bottom-width: 1px;
+}
+.spacer {
+  margin-bottom: 2em;
+}
+
+line.link {
+  fill: none;
+  stroke-width: 1.5px;
+}
+      
+.active {
+  font-weight: bold;
+}
+
+.CodeMirror {
+  font-family: "Inconsolata", monospace;
+  font-size: 120%;
+}
+
+#visualize {
+  width: 100%;
+  height: 700px;
+}
diff --git a/vendor/github.com/google/cayley/static/favicon.ico b/vendor/github.com/google/cayley/static/favicon.ico
new file mode 100644
index 00000000..65af93e1
Binary files /dev/null and b/vendor/github.com/google/cayley/static/favicon.ico differ
diff --git a/vendor/github.com/google/cayley/static/js/cayley_main.js b/vendor/github.com/google/cayley/static/js/cayley_main.js
new file mode 100644
index 00000000..75af67c8
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/js/cayley_main.js
@@ -0,0 +1,167 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+$(function() {
+  s = null;
+  group = null;
+  Snap.load("/static/cayley.svg", function(d, err) {
+    //Snap(105,65).append(d);
+    s = Snap("#logo").append(d);
+    svg = Snap("svg");
+    var c = svg.selectAll("*")
+    group = svg.group()
+    group.add(c)
+    scale = new Snap.Matrix();
+    scale.scale(0.5);
+    group.transform(scale)
+  })
+
+	neutralColor = "#999999"
+	green = "#0F9D58"
+
+	stopAndReset = function () {
+		for (var i = 0; i < 19; i++) {
+			group[i].stop()
+		}
+		for (var i = 0; i < currentTimeouts.length; i++) {
+			clearTimeout(currentTimeouts[i])
+		}
+		currentTimeouts = []
+		group[17].attr({fill: neutralColor})
+		group[18].attr({fill: neutralColor})
+		for (var i = 1; i < 11; i++) {
+			group[i].attr({stroke: neutralColor})
+		}
+
+	}
+
+	currentTimeouts = []
+
+	flash = function(elem, start) {
+		currentTimeouts.push(
+			setTimeout(function() { elem.animate({stroke: green}, 1000)}, start * 1000))
+		currentTimeouts.push(
+			setTimeout(function() { elem.animate({stroke: neutralColor}, 1200)}, (start + 1) * 1000))
+	}
+
+	animate = function() {
+		group[17].animate({fill: green}, 1000)
+		currentTimeouts.push(
+			setTimeout(function() {group[17].animate({fill: neutralColor}, 1200)}, 1000))
+		flash(group[1], 0.5)
+		flash(group[8], 1.0)
+		flash(group[4], 1.5)
+		flash(group[10], 1.0)
+		flash(group[6], 1.5)
+		flash(group[2], 2.0)
+		currentTimeouts.push(
+			setTimeout(function() {group[18].animate({fill: green}, 1000)}, 2500))
+		currentTimeouts.push(
+			setTimeout(function() {group[18].animate({fill: neutralColor}, 1200)}, 3500))
+		currentTimeouts.push(
+			setTimeout(function() {group[17].animate({fill: green}, 1000)}, 3500))
+		currentTimeouts.push(
+			setTimeout(function() {group[17].animate({fill: neutralColor}, 1200)}, 4500))
+		flash(group[1], 4.0)
+		flash(group[7], 4.5)
+		flash(group[5], 5.0)
+		flash(group[9], 4.5)
+		flash(group[3], 5.0)
+		flash(group[2], 5.5)
+		currentTimeouts.push(
+			setTimeout(function() {group[18].animate({fill: green}, 1000)}, 6000))
+		currentTimeouts.push(
+			setTimeout(function() {group[18].animate({fill: neutralColor}, 1200, function() {
+				stopAndReset();
+				animate();
+		})}, 7000))
+	}
+
+  if ($("#code").length != 0) {
+    editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+      lineNumbers: true,
+      matchBrackets: true,
+      continueComments: "Enter",
+      //        extraKeys: {"Ctrl-Q": "toggleComment"}
+    });
+  } else{
+    editor = null;
+  }
+
+  var defaultQueryStrings = {
+    "gremlin": "g.Emit('Hello World')",
+    "mql": "[{\n  \"id\": \"Hello World\"\n}]"
+  }
+
+  var getLastQueryStringFor = function(type) {
+    if (typeof(Storage) !== "undefined") {
+      return localStorage.getItem("cayleySavedQueries" + type)
+    } else {
+      return defaultQueryStrings[type]
+    }
+  }
+
+  var switchTo = function(type) {
+    if (type === "gremlin") { switchToGremlin()}
+    if (type === "mql") { switchToMQL()}
+    if (typeof(Storage) !== "undefined") {
+      localStorage.setItem("cayleyQueryLang", type);
+    }
+    if (editor) {
+      editor.setValue(getLastQueryStringFor(type))
+    }
+  }
+
+
+  var switchToGremlin = function () {
+    $("#selected-query-lang").html("Gremlin " + caretSpan)
+    selectedQueryLanguage = "gremlin"
+  }
+
+  var switchToMQL = function() {
+    $("#selected-query-lang").html("MQL" + caretSpan)
+    selectedQueryLanguage = "mql"
+  }
+
+  selectedQueryLanguage = "gremlin"
+  var caretSpan = " &nbsp <span class='caret'></span>"
+
+  if (typeof(Storage) !== "undefined") {
+    savedQueries = localStorage.getItem("cayleySavedQueriesmql");
+    if (savedQueries === null) {
+      for (var key in defaultQueryStrings) {
+        localStorage.setItem("cayleySavedQueries" + key, defaultQueryStrings[key])
+      }
+    }
+    lang = localStorage.getItem("cayleyQueryLang");
+    if (lang !== null) {
+      switchTo(lang)
+    } else {
+      switchTo("gremlin")
+    }
+  } else {
+    switchTo("gremlin")
+  }
+
+
+  $("#gremlin-dropdown").click(function() {
+    switchTo("gremlin")
+  })
+
+  $("#mql-dropdown").click(function() {
+    switchTo("mql")
+  })
+});
+
+
diff --git a/vendor/github.com/google/cayley/static/js/cayley_query.js b/vendor/github.com/google/cayley/static/js/cayley_query.js
new file mode 100644
index 00000000..3f88f83f
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/js/cayley_query.js
@@ -0,0 +1,41 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+$(function() {
+
+  $("#sbQuery").addClass("active");
+
+  output_editor = CodeMirror.fromTextArea(document.getElementById("output"), {
+    lineNumbers: true,
+    matchBrackets: true,
+  });
+
+  $("#run_button").click(function() {
+    var data = editor.getValue()
+    $("#output").text(editor.getValue())
+    animate();
+    $.post("/api/v1/query/" + selectedQueryLanguage, data)
+      .done(function(return_data) {
+        if (typeof(Storage) !== "undefined") {
+          localStorage.setItem("cayleySavedQueries" + selectedQueryLanguage, data)
+        }
+        output_editor.setValue(return_data)
+        stopAndReset();
+      })
+      .fail(function(jqxhr, textStatus, errorThrown){
+        output_editor.setValue(jqxhr.responseText)
+        stopAndReset();
+      })
+  })
+});
diff --git a/vendor/github.com/google/cayley/static/js/cayley_shape.js b/vendor/github.com/google/cayley/static/js/cayley_shape.js
new file mode 100644
index 00000000..f47cf0f1
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/js/cayley_shape.js
@@ -0,0 +1,33 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+$(function() {
+  $("#sbQueryShape").addClass("active");
+
+  $("#run_button").click(function() {
+    var data = editor.getValue()
+    $.post("/api/v1/shape/" + selectedQueryLanguage, data)
+      .done(function(return_data) {
+        if (typeof(Storage) !== "undefined") {
+          localStorage.setItem("cayleySavedQueries" + selectedQueryLanguage, data)
+        }
+        shape = $.parseJSON(return_data)
+        $("#viz").empty()
+        if (shape.hasOwnProperty("nodes")) {
+          var net = Network()
+          net("#viz", shape)
+        }
+      });
+  });
+})
diff --git a/vendor/github.com/google/cayley/static/js/cayley_visualize.js b/vendor/github.com/google/cayley/static/js/cayley_visualize.js
new file mode 100644
index 00000000..e5ba88fe
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/js/cayley_visualize.js
@@ -0,0 +1,113 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+$(function() {
+  $("#sbVisualize").addClass("active");
+
+  var createGraphVisualization = function(results) {
+    if (window.sigmaGraph !== undefined) {
+      sigmaGraph.stopForceAtlas2()
+      sigmaGraph.kill()
+      $("#visualize").text("")
+    }
+    var nodeMap = {}
+    var g = {nodes: [], edges: []}
+    for (var i = 0; i < results.length; i++) {
+      result = results[i];
+      source = result["source"]
+      target = result["target"]
+			var source_color
+			var target_color
+			if (result["source_color"] != undefined) {
+				source_color = result["source_color"]
+			} else {
+				//source_color = "#2c3e50"
+				source_color = "#001B8A"
+			}
+			if (result["target_color"] != undefined) {
+				target_color = result["target_color"]
+			} else {
+				target_color = "#F09300"
+			}
+      if (nodeMap[source] !== true) {
+        var data = {
+          id: source,
+          x: Math.random(),
+          y: Math.random(),
+          size: 10,
+          color: source_color
+
+        }
+        if (result["source_label"] != undefined) {
+          data.label = result["source_label"]
+        } else {
+          data.label = source
+        }
+        g.nodes.push(data)
+        nodeMap[source] = true
+      }
+      if (nodeMap[target] !== true) {
+        var data = {
+          id: target,
+          x: Math.random(),
+          y: Math.random(),
+          size: 10,
+          color: target_color
+        }
+        if (result["target_label"] != undefined) {
+          data.label = result["target_label"]
+        } else {
+          data.label = target
+        }
+        g.nodes.push(data)
+        nodeMap[target] = true
+      }
+      g.edges.push({
+        id: "e" + i,
+        source: source,
+        target: target,
+        size: 5,
+        color: '#ccc'
+      })
+
+    }
+    sigmaGraph = new sigma({
+      graph: g,
+      container: 'visualize',
+      settings: {
+        defaultNodeColor: '#ec5148'
+      }
+
+    });
+    sigmaGraph.startForceAtlas2();
+		sigmaGraph.forceatlas2.p.linLogMode = true;
+  }
+
+  $("#run_button").click(function() {
+    var data = editor.getValue()
+    animate();
+    $.post("/api/v1/query/" + selectedQueryLanguage, data)
+      .done(function(return_data) {
+        stopAndReset();
+        if (typeof(Storage) !== "undefined") {
+          localStorage.setItem("cayleySavedQueries" + selectedQueryLanguage, data)
+        }
+        links = $.parseJSON(return_data)
+        createGraphVisualization(links.result)
+      })
+     .fail(function() {
+         stopAndReset();
+     });
+  });
+})
diff --git a/vendor/github.com/google/cayley/static/js/cayley_write.js b/vendor/github.com/google/cayley/static/js/cayley_write.js
new file mode 100644
index 00000000..7aa96cec
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/js/cayley_write.js
@@ -0,0 +1,158 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+$(function() {
+
+
+  var alertFail = function(text) {
+    $("#alertBox").text(text)
+    $("#alertBox").addClass("alert-danger").fadeIn(300).delay(2000).fadeOut(300).queue(function(){ $(this).removeClass("alert-danger")});
+  }
+
+  var alertSucceed = function(text) {
+    $("#alertBox").text(text)
+    $("#alertBox").addClass("alert-success").fadeIn(300).delay(2000).fadeOut(300).queue(function(){ $(this).removeClass("alert-success")});
+  }
+
+  var checkQuad = function(t) {
+    if (t.subject == "") {
+      alertFail("Need a subject")
+      return false
+    }
+    if (t.predicate == "") {
+      alertFail("Need a predicate")
+      return false
+    }
+    if (t.object == "") {
+      alertFail("Need an object")
+      return false
+    }
+    return true
+  }
+
+  $("#sbWrite").addClass("active");
+
+  $("#add_quad").click(function() {
+    var quad = {
+      subject: $("#subject").val(),
+      predicate: $("#predicate").val(),
+      object: $("#object").val(),
+      label: $("#label").val()
+    }
+    if (!checkQuad(quad)) {
+      return
+    }
+    $.post("/api/v1/write", JSON.stringify([quad]))
+      .done(function(return_data){
+        alertSucceed("Wrote a quad!")
+      })
+      .fail(function(jqxhr) {
+        var data = $.parseJSON(jqxhr.responseText)
+        alertFail(data.error)
+      })
+  })
+
+  $("#delete_quad").click(function() {
+    var quad = {
+      subject: $("#rsubject").val(),
+      predicate: $("#rpredicate").val(),
+      object: $("#robject").val(),
+      label: $("#rlabel").val()
+    }
+    if (!checkQuad(quad)) {
+      return
+    }
+    $.post("/api/v1/delete", JSON.stringify([quad]))
+      .done(function(return_data){
+        alertSucceed("Deleted a quad!")
+      })
+      .fail(function(jqxhr) {
+        var data = $.parseJSON(jqxhr.responseText)
+        alertFail(data.error)
+      })
+  })
+
+  var upload = null
+
+  var uploadProgress = function(event) {
+    if (event.lengthComputable) {
+      var percentComplete = Math.round(event.loaded * 100 / event.total);
+      $("#alertBox").text("Uploaded  " + percentComplete.toString() + "%")
+    } else {
+      $("#alertBox").text("Uploading...")
+    }
+  }
+
+  var uploadComplete = function(event) {
+    stopAndReset();
+    var data = $.parseJSON(upload.responseText)
+    $("#alertBox").text("Upload complete! " + data.result);
+    $("#alertBox").removeClass("alert-info").addClass("alert-success")
+    .delay(2000).fadeOut(300)
+    .queue(function () {
+      $("#write_file").fadeIn(30);
+      $("#alertBox").removeClass("alert-success");
+    })
+    upload = null
+  }
+
+  var uploadCanceled = function(event) {
+    upload = null
+    stopAndReset();
+    $("#alertBox").text("Upload canceled!")
+    $("#alertBox").removeClass("alert-info").addClass("alert-danger")
+    .delay(2000).fadeOut(300)
+    .queue(function () {
+      $("#write_file").fadeIn(30);
+      $("#alertBox").removeClass("alert-danger");
+    })
+  }
+
+  var uploadFailed = function(event) {
+    upload = null
+    stopAndReset();
+    $("#alertBox").text("Upload failed!")
+    $("#alertBox").removeClass("alert-info").addClass("alert-danger")
+    .delay(2000).fadeOut(300)
+    .queue(function () {
+      $("#write_file").fadeIn(30);
+      $("#alertBox").removeClass("alert-danger");
+    })
+  }
+
+  $("#write_file").click(function() {
+    try {
+      animate();
+      var fd = new FormData()
+      fd.append("NQuadFile", document.getElementById("nquad_file").files[0])
+      var xhr = new XMLHttpRequest()
+      upload = xhr
+      $("#write_file").fadeOut(30);
+      $("#alertBox").addClass("alert-info").fadeIn(300);
+      xhr.upload.addEventListener("progress", uploadProgress, false);
+      xhr.addEventListener("load", uploadComplete, false);
+      xhr.addEventListener("error", uploadFailed, false);
+      xhr.addEventListener("abort", uploadCanceled, false);
+      xhr.open("POST", "/api/v1/write/file/nquad");
+      xhr.send(fd);
+
+    } catch(err) {
+      $("#alertBox").removeClass("alert-info");
+      stopAndReset();
+      alertFail(err)
+      $("#write_file").fadeIn(30);
+    }
+  })
+
+});
diff --git a/vendor/github.com/google/cayley/static/js/query_viz.js b/vendor/github.com/google/cayley/static/js/query_viz.js
new file mode 100644
index 00000000..7dab0ec3
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/js/query_viz.js
@@ -0,0 +1,351 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+function Network() {
+  var height = 800;
+  var width = 800;
+
+  // Things in the first force graph.
+  var nodesG = null;
+  var linksG = null;
+  var linkNodesG = null;
+
+  var node = null;
+  var linknode = null;
+  var link = null;
+
+  var curLinksData = null;
+  var curNodesData = null;
+
+
+  // Things in the second force graph
+  var tag_nodesG = null;
+  var tag_linksG = null;
+
+  var tag_node = null;
+  var tag_link = null;
+
+  var curTagLinksData = null;
+  var curTagNodesData = null;
+
+
+  var allData = null;
+
+  var dragstart = function(d) {
+    d3.select(this).classed("fixed", d.fixed = true);
+  }
+
+  //our force directed layout
+  var force = d3.layout.force()
+  var force_drag = force.drag().on("dragstart", dragstart)
+  var tag_force = d3.layout.force()
+
+  //color function used to color nodes
+  var baseNodeColors = d3.scale.category20()
+  var linkNodeColors = function(d) {
+    return d3.rgb("#555").toString()
+  }
+  var strokeFor = function(d) {
+    return d3.rgb("#000").brighter().toString()
+  }
+
+  var rotationTransformForLinkNode = function (d) {
+    var center_x = (d.link.source.x + d.link.target.x) / 2
+    var center_y = (d.link.source.y + d.link.target.y) / 2
+    var dx = d.link.target.x - d.link.source.x
+    var dy = d.link.target.y - d.link.source.y
+    var rotation_radians = Math.atan2(dy,dx)
+    var rotation_degrees = rotation_radians * (180 / Math.PI)
+    return "rotate(" + rotation_degrees + ", " + center_x + ", " + center_y + ")"
+
+  }
+
+  var updateLink = function() {
+    this.attr("x1", function(d) {return d.source.x})
+        .attr("y1", function(d) {return d.source.y})
+        .attr("x2", function(d) {return d.target.x})
+        .attr("y2", function(d) {return d.target.y})
+  }
+
+  var forceTick = function(e) {
+    tag_force.start()
+    node
+      .attr("cx", function(d) {return d.x})
+      .attr("cy", function(d) {return d.y})
+
+    linknode.each(function(d) {
+      d.x = (d.link.source.x + d.link.target.x) / 2
+      d.y = (d.link.source.y + d.link.target.y) / 2
+    })
+
+    linknode
+      .attr("cx", function(d) {return d.x })
+      .attr("cy", function(d) {return d.y })
+      .attr("transform", rotationTransformForLinkNode)
+
+    link.call(updateLink);
+
+    tagForceTick(e)
+  }
+
+  var tagForceTick = function(e) {
+    tag_node.each(function(d) {
+      if(d.is_tag === false) {
+        d.x = d.node.x;
+        d.y = d.node.y;
+      } else {
+        var b = this.childNodes[1].getBBox();
+        var diffX = d.x - d.node.x;
+        var diffY = d.y - d.node.y;
+
+        var dist = Math.sqrt(diffX * diffX + diffY * diffY);
+
+        var shiftX = b.width * (diffX - dist) / (dist * 2);
+        shiftX = Math.max(-b.width, Math.min(0, shiftX));
+        var shiftY = 5;
+        this.childNodes[1].setAttribute("transform", "translate(" + shiftX + "," + shiftY + ")");
+      }
+    });
+    tag_node
+        .attr("transform", function(d) {
+                return "translate(" + d.x + "," + d.y + ")";
+        });
+
+    tag_link.call(updateLink);
+  }
+
+  var setupData = function (data) {
+    data.nodes.forEach(function (n) {
+      n.x = randomnumber=Math.floor(Math.random()*width)
+      n.y = randomnumber=Math.floor(Math.random()*height)
+      n.radius = 10
+    });
+
+    var nodesMap = mapNodes(data.nodes)
+
+    data.links.forEach(function (l) {
+      l.source = nodesMap.get(l.source)
+      l.target = nodesMap.get(l.target)
+      nodesMap.get(l.link_node).link = l
+    })
+
+    data.tag_links = []
+    data.tag_nodes = []
+    var tag_id_counter = 0
+
+    data.nodes.forEach(function (n) {
+      if (n.tags !== undefined) {
+        n.tags.forEach( function (tag) {
+          var tag_node = {}
+          tag_node.id = "tag" + tag_id_counter
+          tag_node.tag = tag
+          tag_node.x = n.x
+          tag_node.y = n.y
+          tag_node.is_tag = true
+          tag_node.is_value = false
+          tag_node.node = n
+          tag_node.radius = 0
+          tag_id_counter += 1;
+          var fake_node = {}
+          fake_node.id = "tag" + tag_id_counter
+          fake_node.x = n.x
+          fake_node.y = n.y
+          fake_node.node = n
+          fake_node.radius = 0
+          fake_node.is_tag = false
+          tag_id_counter += 1;
+          var tag_link = {}
+          tag_link.source = fake_node
+          tag_link.target = tag_node
+          data.tag_nodes.push(tag_node)
+          data.tag_nodes.push(fake_node)
+          data.tag_links.push(tag_link)
+        })
+      }
+      if (n.values !== undefined) {
+        n.values.forEach( function (value) {
+          var tag_node = {}
+          tag_node.id = "tag" + tag_id_counter
+          tag_node.tag = value
+          tag_node.x = n.x
+          tag_node.y = n.y
+          tag_node.is_tag = true
+          tag_node.is_value = true
+          tag_node.node = n
+          tag_node.radius = 0
+          tag_id_counter += 1;
+          var fake_node = {}
+          fake_node.id = "tag" + tag_id_counter
+          fake_node.x = n.x
+          fake_node.y = n.y
+          fake_node.node = n
+          fake_node.radius = 0
+          fake_node.is_tag = false
+          tag_id_counter += 1;
+          var tag_link = {}
+          tag_link.source = fake_node
+          tag_link.target = tag_node
+          data.tag_nodes.push(tag_node)
+          data.tag_nodes.push(fake_node)
+          data.tag_links.push(tag_link)
+        })
+      }
+    })
+
+    return data;
+  }
+
+  var mapNodes = function (nodes) {
+    var nodesMap = d3.map()
+    nodes.forEach(function (n) {
+      nodesMap.set(n.id, n)
+    })
+    return nodesMap
+  }
+
+  var network = function (selection, data) {
+    allData = setupData(data)
+    var vis = d3.select(selection).append("svg")
+       .attr("width", width)
+       .attr("height", height)
+
+    vis.append("defs").append("marker")
+    .attr("id", "arrowhead")
+    .attr("refX", 6 + 3) // shift?
+    .attr("refY", 2)
+    .attr("markerWidth", 6)
+    .attr("markerHeight", 4)
+    .attr("orient", "auto")
+    .append("path")
+    .attr("d", "M 0,0 V 4 L6,2 Z");
+
+    linksG = vis.append("g").attr("id", "links")
+    nodesG = vis.append("g").attr("id", "nodes")
+    linkNodesG = vis.append("g").attr("id", "link-nodes")
+
+    tagNodesG = vis.append("g").attr("id", "tag_nodes")
+    tagLinksG = vis.append("g").attr("id", "tag_links")
+
+    force.size([width, height])
+    force.on("tick", forceTick)
+      .charge(-200)
+      .linkDistance(100);
+
+    tag_force
+      .gravity(0)
+      .linkDistance(25)
+      .linkStrength(20)
+      .charge(-100)
+      .size([width, height])
+
+    tag_force.start()
+
+    //perform rendering and start force layout
+    update()
+
+  }
+
+
+
+  var update = function () {
+    allNodes = allData.nodes;
+    curLinksData = allData.links;
+    curNodesData = $.grep(allData.nodes, function(n) { return n.is_link_node === false; })
+    curLinkNodesData = $.grep(allData.nodes, function(n) { return n.is_link_node; })
+
+    curTagLinksData = allData.tag_links
+    curTagNodesData = allData.tag_nodes
+
+    force.nodes(allNodes);
+    node = nodesG.selectAll("circle.node")
+      .data(curNodesData, function(d) {return d.id})
+
+    node.enter().append("circle")
+      .attr("class", "node")
+      .attr("cx", function(d) {return d.x})
+      .attr("cy", function(d) {return d.y})
+      .attr("r", function(d) {return d.radius;})
+      .style("fill", function(d) {return baseNodeColors(d.id);})
+      .style("stroke", function(d) {return strokeFor(d);})
+      .style("stroke-width", 1.0)
+      .call(force_drag)
+
+    node.exit().remove();
+
+    linknode = linkNodesG.selectAll("ellipse.node")
+      .data(curLinkNodesData, function(d) { return d.id })
+
+    linknode.enter().append("ellipse")
+      .attr("class", "node")
+      .attr("cx", function(d) {return d.x})
+      .attr("cy", function(d) {return d.y})
+      .attr("rx", function(d) {return d.radius;})
+      .attr("ry", function(d) {return d.radius / 2;})
+      .style("fill", function(d) {return linkNodeColors(d.id);})
+      .style("stroke", function(d) {return strokeFor(d);})
+      .style("stroke-width", 1.0);
+
+    linknode.exit().remove();
+
+
+    force.links(curLinksData);
+
+    link = linksG.selectAll("line.link")
+      .data(curLinksData, function(d) { return d.source.id + "_" + d.target.id});
+
+    link.enter().append("line")
+      .attr("class", "link")
+      .attr("stroke", "#222")
+      .attr("stroke-opacity", 1.0)
+      .attr("marker-end", "url(#arrowhead)")
+      .style("stroke-width", 2.0)
+      .attr("x1", function(d) {return d.source.x})
+      .attr("y1", function(d) {return d.source.y})
+      .attr("x2", function(d) {return d.target.x})
+      .attr("y2", function(d) {return d.target.y});
+
+    link.exit().remove();
+    force.start();
+
+    tag_force.nodes(curTagNodesData);
+    tag_node = nodesG.selectAll("g.tag_node")
+        .data(curTagNodesData, function(d) { return d.id })
+    var tag_g = tag_node.enter().append("g").attr("class", "tag_node")
+    tag_g.append("svg:circle").attr("r", 0).style("fill", "#FFF");
+    tag_g.append("svg:text")
+      .text(function(d) { return d.is_tag ? d.tag : "" })
+      .style("fill", "#555")
+      .style("font-family", function(d) { return d.is_value ? "Courier" : "Arial"})
+      .style("font-size", 12);
+
+    tag_force.links(curTagLinksData);
+    tag_link = linksG.selectAll("line.tag_link")
+      .data(curTagLinksData, function(d) { return d.source.id + "_" + d.target.id});
+
+    tag_link.enter().append("line")
+      .attr("class", "tag_link")
+      .attr("stroke", "#ddd")
+      .attr("stroke-opacity", 0.5)
+      .attr("x1", function(d) {return d.source.x})
+      .attr("y1", function(d) {return d.source.y})
+      .attr("x2", function(d) {return d.target.x})
+      .attr("y2", function(d) {return d.target.y});
+
+    tag_link.exit().remove();
+    tag_force.start()
+  }
+
+  return network
+};
+
diff --git a/vendor/github.com/google/cayley/static/third_party/flatly/bootstrap.min.css b/vendor/github.com/google/cayley/static/third_party/flatly/bootstrap.min.css
new file mode 100644
index 00000000..30dd417d
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/flatly/bootstrap.min.css
@@ -0,0 +1,7 @@
+@import url("//fonts.googleapis.com/css?family=Lato:400,700,400italic");/*!
+ * Bootswatch v3.1.1+1
+ * Homepage: http://bootswatch.com
+ * Copyright 2012-2014 Thomas Park
+ * Licensed under MIT
+ * Based on Bootstrap
+*//*! normalize.css v3.0.0 | MIT License | git.io/normalize */html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:bold}dfn{font-style:italic}h1{font-size:2em;margin:0.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-0.5em}sub{bottom:-0.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace, monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type="button"],input[type="reset"],input[type="submit"]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type="checkbox"],input[type="radio"]{box-sizing:border-box;padding:0}input[type="number"]::-webkit-inner-spin-button,input[type="number"]::-webkit-outer-spin-button{height:auto}input[type="search"]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}input[type="search"]::-webkit-search-cancel-button,input[type="search"]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid #c0c0c0;margin:0 2px;padding:0.35em 0.625em 0.75em}legend{border:0;padding:0}textarea{overflow:auto}optgroup{font-weight:bold}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}@media print{*{text-shadow:none !important;color:#000 !important;background:transparent !important;box-shadow:none !important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}p,h2,h3{orphans:3;widows:3}h2,h3{page-break-after:avoid}select{background:#fff !important}.navbar{display:none}.table td,.table th{background-color:#fff !important}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000 !important}.label{border:1px solid #000}.table{border-collapse:collapse !important}.table-bordered th,.table-bordered td{border:1px solid #ddd !important}}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}*:before,*:after{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:62.5%;-webkit-tap-highlight-color:rgba(0,0,0,0)}body{font-family:"Lato","Helvetica Neue",Helvetica,Arial,sans-serif;font-size:15px;line-height:1.42857143;color:#2c3e50;background-color:#ffffff}input,button,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit}a{color:#18bc9c;text-decoration:none}a:hover,a:focus{color:#18bc9c;text-decoration:underline}a:focus{outline:thin dotted;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}figure{margin:0}img{vertical-align:middle}.img-responsive,.thumbnail>img,.thumbnail a>img,.carousel-inner>.item>img,.carousel-inner>.item>a>img{display:block;max-width:100%;height:auto}.img-rounded{border-radius:6px}.img-thumbnail{padding:4px;line-height:1.42857143;background-color:#ffffff;border:1px solid #ecf0f1;border-radius:4px;-webkit-transition:all .2s ease-in-out;transition:all .2s ease-in-out;display:inline-block;max-width:100%;height:auto}.img-circle{border-radius:50%}hr{margin-top:21px;margin-bottom:21px;border:0;border-top:1px solid #ecf0f1}.sr-only{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0, 0, 0, 0);border:0}h1,h2,h3,h4,h5,h6,.h1,.h2,.h3,.h4,.h5,.h6{font-family:"Lato","Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:400;line-height:1.1;color:inherit}h1 small,h2 small,h3 small,h4 small,h5 small,h6 small,.h1 small,.h2 small,.h3 small,.h4 small,.h5 small,.h6 small,h1 .small,h2 .small,h3 .small,h4 .small,h5 .small,h6 .small,.h1 .small,.h2 .small,.h3 .small,.h4 .small,.h5 .small,.h6 .small{font-weight:normal;line-height:1;color:#b4bcc2}h1,.h1,h2,.h2,h3,.h3{margin-top:21px;margin-bottom:10.5px}h1 small,.h1 small,h2 small,.h2 small,h3 small,.h3 small,h1 .small,.h1 .small,h2 .small,.h2 .small,h3 .small,.h3 .small{font-size:65%}h4,.h4,h5,.h5,h6,.h6{margin-top:10.5px;margin-bottom:10.5px}h4 small,.h4 small,h5 small,.h5 small,h6 small,.h6 small,h4 .small,.h4 .small,h5 .small,.h5 .small,h6 .small,.h6 .small{font-size:75%}h1,.h1{font-size:39px}h2,.h2{font-size:32px}h3,.h3{font-size:26px}h4,.h4{font-size:19px}h5,.h5{font-size:15px}h6,.h6{font-size:13px}p{margin:0 0 10.5px}.lead{margin-bottom:21px;font-size:17px;font-weight:200;line-height:1.4}@media (min-width:768px){.lead{font-size:22.5px}}small,.small{font-size:85%}cite{font-style:normal}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}.text-justify{text-align:justify}.text-muted{color:#b4bcc2}.text-primary{color:#2c3e50}a.text-primary:hover{color:#1a242f}.text-success{color:#ffffff}a.text-success:hover{color:#e6e6e6}.text-info{color:#ffffff}a.text-info:hover{color:#e6e6e6}.text-warning{color:#ffffff}a.text-warning:hover{color:#e6e6e6}.text-danger{color:#ffffff}a.text-danger:hover{color:#e6e6e6}.bg-primary{color:#fff;background-color:#2c3e50}a.bg-primary:hover{background-color:#1a242f}.bg-success{background-color:#18bc9c}a.bg-success:hover{background-color:#128f76}.bg-info{background-color:#3498db}a.bg-info:hover{background-color:#217dbb}.bg-warning{background-color:#f39c12}a.bg-warning:hover{background-color:#c87f0a}.bg-danger{background-color:#e74c3c}a.bg-danger:hover{background-color:#d62c1a}.page-header{padding-bottom:9.5px;margin:42px 0 21px;border-bottom:1px solid transparent}ul,ol{margin-top:0;margin-bottom:10.5px}ul ul,ol ul,ul ol,ol ol{margin-bottom:0}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;list-style:none;margin-left:-5px}.list-inline>li{display:inline-block;padding-left:5px;padding-right:5px}dl{margin-top:0;margin-bottom:21px}dt,dd{line-height:1.42857143}dt{font-weight:bold}dd{margin-left:0}@media (min-width:768px){.dl-horizontal dt{float:left;width:160px;clear:left;text-align:right;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}}abbr[title],abbr[data-original-title]{cursor:help;border-bottom:1px dotted #b4bcc2}.initialism{font-size:90%;text-transform:uppercase}blockquote{padding:10.5px 21px;margin:0 0 21px;font-size:18.75px;border-left:5px solid #ecf0f1}blockquote p:last-child,blockquote ul:last-child,blockquote ol:last-child{margin-bottom:0}blockquote footer,blockquote small,blockquote .small{display:block;font-size:80%;line-height:1.42857143;color:#b4bcc2}blockquote footer:before,blockquote small:before,blockquote .small:before{content:'\2014 \00A0'}.blockquote-reverse,blockquote.pull-right{padding-right:15px;padding-left:0;border-right:5px solid #ecf0f1;border-left:0;text-align:right}.blockquote-reverse footer:before,blockquote.pull-right footer:before,.blockquote-reverse small:before,blockquote.pull-right small:before,.blockquote-reverse .small:before,blockquote.pull-right .small:before{content:''}.blockquote-reverse footer:after,blockquote.pull-right footer:after,.blockquote-reverse small:after,blockquote.pull-right small:after,.blockquote-reverse .small:after,blockquote.pull-right .small:after{content:'\00A0 \2014'}blockquote:before,blockquote:after{content:""}address{margin-bottom:21px;font-style:normal;line-height:1.42857143}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,"Courier New",monospace}code{padding:2px 4px;font-size:90%;color:#c7254e;background-color:#f9f2f4;white-space:nowrap;border-radius:4px}kbd{padding:2px 4px;font-size:90%;color:#ffffff;background-color:#333333;border-radius:3px;box-shadow:inset 0 -1px 0 rgba(0,0,0,0.25)}pre{display:block;padding:10px;margin:0 0 10.5px;font-size:14px;line-height:1.42857143;word-break:break-all;word-wrap:break-word;color:#7b8a8b;background-color:#ecf0f1;border:1px solid #cccccc;border-radius:4px}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{margin-right:auto;margin-left:auto;padding-left:15px;padding-right:15px}@media (min-width:768px){.container{width:750px}}@media (min-width:992px){.container{width:970px}}@media (min-width:1200px){.container{width:1170px}}.container-fluid{margin-right:auto;margin-left:auto;padding-left:15px;padding-right:15px}.row{margin-left:-15px;margin-right:-15px}.col-xs-1,.col-sm-1,.col-md-1,.col-lg-1,.col-xs-2,.col-sm-2,.col-md-2,.col-lg-2,.col-xs-3,.col-sm-3,.col-md-3,.col-lg-3,.col-xs-4,.col-sm-4,.col-md-4,.col-lg-4,.col-xs-5,.col-sm-5,.col-md-5,.col-lg-5,.col-xs-6,.col-sm-6,.col-md-6,.col-lg-6,.col-xs-7,.col-sm-7,.col-md-7,.col-lg-7,.col-xs-8,.col-sm-8,.col-md-8,.col-lg-8,.col-xs-9,.col-sm-9,.col-md-9,.col-lg-9,.col-xs-10,.col-sm-10,.col-md-10,.col-lg-10,.col-xs-11,.col-sm-11,.col-md-11,.col-lg-11,.col-xs-12,.col-sm-12,.col-md-12,.col-lg-12{position:relative;min-height:1px;padding-left:15px;padding-right:15px}.col-xs-1,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9,.col-xs-10,.col-xs-11,.col-xs-12{float:left}.col-xs-12{width:100%}.col-xs-11{width:91.66666667%}.col-xs-10{width:83.33333333%}.col-xs-9{width:75%}.col-xs-8{width:66.66666667%}.col-xs-7{width:58.33333333%}.col-xs-6{width:50%}.col-xs-5{width:41.66666667%}.col-xs-4{width:33.33333333%}.col-xs-3{width:25%}.col-xs-2{width:16.66666667%}.col-xs-1{width:8.33333333%}.col-xs-pull-12{right:100%}.col-xs-pull-11{right:91.66666667%}.col-xs-pull-10{right:83.33333333%}.col-xs-pull-9{right:75%}.col-xs-pull-8{right:66.66666667%}.col-xs-pull-7{right:58.33333333%}.col-xs-pull-6{right:50%}.col-xs-pull-5{right:41.66666667%}.col-xs-pull-4{right:33.33333333%}.col-xs-pull-3{right:25%}.col-xs-pull-2{right:16.66666667%}.col-xs-pull-1{right:8.33333333%}.col-xs-pull-0{right:0%}.col-xs-push-12{left:100%}.col-xs-push-11{left:91.66666667%}.col-xs-push-10{left:83.33333333%}.col-xs-push-9{left:75%}.col-xs-push-8{left:66.66666667%}.col-xs-push-7{left:58.33333333%}.col-xs-push-6{left:50%}.col-xs-push-5{left:41.66666667%}.col-xs-push-4{left:33.33333333%}.col-xs-push-3{left:25%}.col-xs-push-2{left:16.66666667%}.col-xs-push-1{left:8.33333333%}.col-xs-push-0{left:0%}.col-xs-offset-12{margin-left:100%}.col-xs-offset-11{margin-left:91.66666667%}.col-xs-offset-10{margin-left:83.33333333%}.col-xs-offset-9{margin-left:75%}.col-xs-offset-8{margin-left:66.66666667%}.col-xs-offset-7{margin-left:58.33333333%}.col-xs-offset-6{margin-left:50%}.col-xs-offset-5{margin-left:41.66666667%}.col-xs-offset-4{margin-left:33.33333333%}.col-xs-offset-3{margin-left:25%}.col-xs-offset-2{margin-left:16.66666667%}.col-xs-offset-1{margin-left:8.33333333%}.col-xs-offset-0{margin-left:0%}@media (min-width:768px){.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12{float:left}.col-sm-12{width:100%}.col-sm-11{width:91.66666667%}.col-sm-10{width:83.33333333%}.col-sm-9{width:75%}.col-sm-8{width:66.66666667%}.col-sm-7{width:58.33333333%}.col-sm-6{width:50%}.col-sm-5{width:41.66666667%}.col-sm-4{width:33.33333333%}.col-sm-3{width:25%}.col-sm-2{width:16.66666667%}.col-sm-1{width:8.33333333%}.col-sm-pull-12{right:100%}.col-sm-pull-11{right:91.66666667%}.col-sm-pull-10{right:83.33333333%}.col-sm-pull-9{right:75%}.col-sm-pull-8{right:66.66666667%}.col-sm-pull-7{right:58.33333333%}.col-sm-pull-6{right:50%}.col-sm-pull-5{right:41.66666667%}.col-sm-pull-4{right:33.33333333%}.col-sm-pull-3{right:25%}.col-sm-pull-2{right:16.66666667%}.col-sm-pull-1{right:8.33333333%}.col-sm-pull-0{right:0%}.col-sm-push-12{left:100%}.col-sm-push-11{left:91.66666667%}.col-sm-push-10{left:83.33333333%}.col-sm-push-9{left:75%}.col-sm-push-8{left:66.66666667%}.col-sm-push-7{left:58.33333333%}.col-sm-push-6{left:50%}.col-sm-push-5{left:41.66666667%}.col-sm-push-4{left:33.33333333%}.col-sm-push-3{left:25%}.col-sm-push-2{left:16.66666667%}.col-sm-push-1{left:8.33333333%}.col-sm-push-0{left:0%}.col-sm-offset-12{margin-left:100%}.col-sm-offset-11{margin-left:91.66666667%}.col-sm-offset-10{margin-left:83.33333333%}.col-sm-offset-9{margin-left:75%}.col-sm-offset-8{margin-left:66.66666667%}.col-sm-offset-7{margin-left:58.33333333%}.col-sm-offset-6{margin-left:50%}.col-sm-offset-5{margin-left:41.66666667%}.col-sm-offset-4{margin-left:33.33333333%}.col-sm-offset-3{margin-left:25%}.col-sm-offset-2{margin-left:16.66666667%}.col-sm-offset-1{margin-left:8.33333333%}.col-sm-offset-0{margin-left:0%}}@media (min-width:992px){.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12{float:left}.col-md-12{width:100%}.col-md-11{width:91.66666667%}.col-md-10{width:83.33333333%}.col-md-9{width:75%}.col-md-8{width:66.66666667%}.col-md-7{width:58.33333333%}.col-md-6{width:50%}.col-md-5{width:41.66666667%}.col-md-4{width:33.33333333%}.col-md-3{width:25%}.col-md-2{width:16.66666667%}.col-md-1{width:8.33333333%}.col-md-pull-12{right:100%}.col-md-pull-11{right:91.66666667%}.col-md-pull-10{right:83.33333333%}.col-md-pull-9{right:75%}.col-md-pull-8{right:66.66666667%}.col-md-pull-7{right:58.33333333%}.col-md-pull-6{right:50%}.col-md-pull-5{right:41.66666667%}.col-md-pull-4{right:33.33333333%}.col-md-pull-3{right:25%}.col-md-pull-2{right:16.66666667%}.col-md-pull-1{right:8.33333333%}.col-md-pull-0{right:0%}.col-md-push-12{left:100%}.col-md-push-11{left:91.66666667%}.col-md-push-10{left:83.33333333%}.col-md-push-9{left:75%}.col-md-push-8{left:66.66666667%}.col-md-push-7{left:58.33333333%}.col-md-push-6{left:50%}.col-md-push-5{left:41.66666667%}.col-md-push-4{left:33.33333333%}.col-md-push-3{left:25%}.col-md-push-2{left:16.66666667%}.col-md-push-1{left:8.33333333%}.col-md-push-0{left:0%}.col-md-offset-12{margin-left:100%}.col-md-offset-11{margin-left:91.66666667%}.col-md-offset-10{margin-left:83.33333333%}.col-md-offset-9{margin-left:75%}.col-md-offset-8{margin-left:66.66666667%}.col-md-offset-7{margin-left:58.33333333%}.col-md-offset-6{margin-left:50%}.col-md-offset-5{margin-left:41.66666667%}.col-md-offset-4{margin-left:33.33333333%}.col-md-offset-3{margin-left:25%}.col-md-offset-2{margin-left:16.66666667%}.col-md-offset-1{margin-left:8.33333333%}.col-md-offset-0{margin-left:0%}}@media (min-width:1200px){.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12{float:left}.col-lg-12{width:100%}.col-lg-11{width:91.66666667%}.col-lg-10{width:83.33333333%}.col-lg-9{width:75%}.col-lg-8{width:66.66666667%}.col-lg-7{width:58.33333333%}.col-lg-6{width:50%}.col-lg-5{width:41.66666667%}.col-lg-4{width:33.33333333%}.col-lg-3{width:25%}.col-lg-2{width:16.66666667%}.col-lg-1{width:8.33333333%}.col-lg-pull-12{right:100%}.col-lg-pull-11{right:91.66666667%}.col-lg-pull-10{right:83.33333333%}.col-lg-pull-9{right:75%}.col-lg-pull-8{right:66.66666667%}.col-lg-pull-7{right:58.33333333%}.col-lg-pull-6{right:50%}.col-lg-pull-5{right:41.66666667%}.col-lg-pull-4{right:33.33333333%}.col-lg-pull-3{right:25%}.col-lg-pull-2{right:16.66666667%}.col-lg-pull-1{right:8.33333333%}.col-lg-pull-0{right:0%}.col-lg-push-12{left:100%}.col-lg-push-11{left:91.66666667%}.col-lg-push-10{left:83.33333333%}.col-lg-push-9{left:75%}.col-lg-push-8{left:66.66666667%}.col-lg-push-7{left:58.33333333%}.col-lg-push-6{left:50%}.col-lg-push-5{left:41.66666667%}.col-lg-push-4{left:33.33333333%}.col-lg-push-3{left:25%}.col-lg-push-2{left:16.66666667%}.col-lg-push-1{left:8.33333333%}.col-lg-push-0{left:0%}.col-lg-offset-12{margin-left:100%}.col-lg-offset-11{margin-left:91.66666667%}.col-lg-offset-10{margin-left:83.33333333%}.col-lg-offset-9{margin-left:75%}.col-lg-offset-8{margin-left:66.66666667%}.col-lg-offset-7{margin-left:58.33333333%}.col-lg-offset-6{margin-left:50%}.col-lg-offset-5{margin-left:41.66666667%}.col-lg-offset-4{margin-left:33.33333333%}.col-lg-offset-3{margin-left:25%}.col-lg-offset-2{margin-left:16.66666667%}.col-lg-offset-1{margin-left:8.33333333%}.col-lg-offset-0{margin-left:0%}}table{max-width:100%;background-color:transparent}th{text-align:left}.table{width:100%;margin-bottom:21px}.table>thead>tr>th,.table>tbody>tr>th,.table>tfoot>tr>th,.table>thead>tr>td,.table>tbody>tr>td,.table>tfoot>tr>td{padding:8px;line-height:1.42857143;vertical-align:top;border-top:1px solid #ecf0f1}.table>thead>tr>th{vertical-align:bottom;border-bottom:2px solid #ecf0f1}.table>caption+thead>tr:first-child>th,.table>colgroup+thead>tr:first-child>th,.table>thead:first-child>tr:first-child>th,.table>caption+thead>tr:first-child>td,.table>colgroup+thead>tr:first-child>td,.table>thead:first-child>tr:first-child>td{border-top:0}.table>tbody+tbody{border-top:2px solid #ecf0f1}.table .table{background-color:#ffffff}.table-condensed>thead>tr>th,.table-condensed>tbody>tr>th,.table-condensed>tfoot>tr>th,.table-condensed>thead>tr>td,.table-condensed>tbody>tr>td,.table-condensed>tfoot>tr>td{padding:5px}.table-bordered{border:1px solid #ecf0f1}.table-bordered>thead>tr>th,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>tbody>tr>td,.table-bordered>tfoot>tr>td{border:1px solid #ecf0f1}.table-bordered>thead>tr>th,.table-bordered>thead>tr>td{border-bottom-width:2px}.table-striped>tbody>tr:nth-child(odd)>td,.table-striped>tbody>tr:nth-child(odd)>th{background-color:#f9f9f9}.table-hover>tbody>tr:hover>td,.table-hover>tbody>tr:hover>th{background-color:#ecf0f1}table col[class*="col-"]{position:static;float:none;display:table-column}table td[class*="col-"],table th[class*="col-"]{position:static;float:none;display:table-cell}.table>thead>tr>td.active,.table>tbody>tr>td.active,.table>tfoot>tr>td.active,.table>thead>tr>th.active,.table>tbody>tr>th.active,.table>tfoot>tr>th.active,.table>thead>tr.active>td,.table>tbody>tr.active>td,.table>tfoot>tr.active>td,.table>thead>tr.active>th,.table>tbody>tr.active>th,.table>tfoot>tr.active>th{background-color:#ecf0f1}.table-hover>tbody>tr>td.active:hover,.table-hover>tbody>tr>th.active:hover,.table-hover>tbody>tr.active:hover>td,.table-hover>tbody>tr.active:hover>th{background-color:#dde4e6}.table>thead>tr>td.success,.table>tbody>tr>td.success,.table>tfoot>tr>td.success,.table>thead>tr>th.success,.table>tbody>tr>th.success,.table>tfoot>tr>th.success,.table>thead>tr.success>td,.table>tbody>tr.success>td,.table>tfoot>tr.success>td,.table>thead>tr.success>th,.table>tbody>tr.success>th,.table>tfoot>tr.success>th{background-color:#18bc9c}.table-hover>tbody>tr>td.success:hover,.table-hover>tbody>tr>th.success:hover,.table-hover>tbody>tr.success:hover>td,.table-hover>tbody>tr.success:hover>th{background-color:#15a589}.table>thead>tr>td.info,.table>tbody>tr>td.info,.table>tfoot>tr>td.info,.table>thead>tr>th.info,.table>tbody>tr>th.info,.table>tfoot>tr>th.info,.table>thead>tr.info>td,.table>tbody>tr.info>td,.table>tfoot>tr.info>td,.table>thead>tr.info>th,.table>tbody>tr.info>th,.table>tfoot>tr.info>th{background-color:#3498db}.table-hover>tbody>tr>td.info:hover,.table-hover>tbody>tr>th.info:hover,.table-hover>tbody>tr.info:hover>td,.table-hover>tbody>tr.info:hover>th{background-color:#258cd1}.table>thead>tr>td.warning,.table>tbody>tr>td.warning,.table>tfoot>tr>td.warning,.table>thead>tr>th.warning,.table>tbody>tr>th.warning,.table>tfoot>tr>th.warning,.table>thead>tr.warning>td,.table>tbody>tr.warning>td,.table>tfoot>tr.warning>td,.table>thead>tr.warning>th,.table>tbody>tr.warning>th,.table>tfoot>tr.warning>th{background-color:#f39c12}.table-hover>tbody>tr>td.warning:hover,.table-hover>tbody>tr>th.warning:hover,.table-hover>tbody>tr.warning:hover>td,.table-hover>tbody>tr.warning:hover>th{background-color:#e08e0b}.table>thead>tr>td.danger,.table>tbody>tr>td.danger,.table>tfoot>tr>td.danger,.table>thead>tr>th.danger,.table>tbody>tr>th.danger,.table>tfoot>tr>th.danger,.table>thead>tr.danger>td,.table>tbody>tr.danger>td,.table>tfoot>tr.danger>td,.table>thead>tr.danger>th,.table>tbody>tr.danger>th,.table>tfoot>tr.danger>th{background-color:#e74c3c}.table-hover>tbody>tr>td.danger:hover,.table-hover>tbody>tr>th.danger:hover,.table-hover>tbody>tr.danger:hover>td,.table-hover>tbody>tr.danger:hover>th{background-color:#e43725}@media (max-width:767px){.table-responsive{width:100%;margin-bottom:15.75px;overflow-y:hidden;overflow-x:scroll;-ms-overflow-style:-ms-autohiding-scrollbar;border:1px solid #ecf0f1;-webkit-overflow-scrolling:touch}.table-responsive>.table{margin-bottom:0}.table-responsive>.table>thead>tr>th,.table-responsive>.table>tbody>tr>th,.table-responsive>.table>tfoot>tr>th,.table-responsive>.table>thead>tr>td,.table-responsive>.table>tbody>tr>td,.table-responsive>.table>tfoot>tr>td{white-space:nowrap}.table-responsive>.table-bordered{border:0}.table-responsive>.table-bordered>thead>tr>th:first-child,.table-responsive>.table-bordered>tbody>tr>th:first-child,.table-responsive>.table-bordered>tfoot>tr>th:first-child,.table-responsive>.table-bordered>thead>tr>td:first-child,.table-responsive>.table-bordered>tbody>tr>td:first-child,.table-responsive>.table-bordered>tfoot>tr>td:first-child{border-left:0}.table-responsive>.table-bordered>thead>tr>th:last-child,.table-responsive>.table-bordered>tbody>tr>th:last-child,.table-responsive>.table-bordered>tfoot>tr>th:last-child,.table-responsive>.table-bordered>thead>tr>td:last-child,.table-responsive>.table-bordered>tbody>tr>td:last-child,.table-responsive>.table-bordered>tfoot>tr>td:last-child{border-right:0}.table-responsive>.table-bordered>tbody>tr:last-child>th,.table-responsive>.table-bordered>tfoot>tr:last-child>th,.table-responsive>.table-bordered>tbody>tr:last-child>td,.table-responsive>.table-bordered>tfoot>tr:last-child>td{border-bottom:0}}fieldset{padding:0;margin:0;border:0;min-width:0}legend{display:block;width:100%;padding:0;margin-bottom:21px;font-size:22.5px;line-height:inherit;color:#2c3e50;border:0;border-bottom:1px solid transparent}label{display:inline-block;margin-bottom:5px;font-weight:bold}input[type="search"]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type="radio"],input[type="checkbox"]{margin:4px 0 0;margin-top:1px \9;line-height:normal}input[type="file"]{display:block}input[type="range"]{display:block;width:100%}select[multiple],select[size]{height:auto}input[type="file"]:focus,input[type="radio"]:focus,input[type="checkbox"]:focus{outline:thin dotted;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}output{display:block;padding-top:11px;font-size:15px;line-height:1.42857143;color:#2c3e50}.form-control{display:block;width:100%;height:43px;padding:10px 15px;font-size:15px;line-height:1.42857143;color:#2c3e50;background-color:#ffffff;background-image:none;border:1px solid #dce4ec;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-webkit-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s}.form-control:focus{border-color:#2c3e50;outline:0;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(44,62,80,0.6);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(44,62,80,0.6)}.form-control::-moz-placeholder{color:#acb6c0;opacity:1}.form-control:-ms-input-placeholder{color:#acb6c0}.form-control::-webkit-input-placeholder{color:#acb6c0}.form-control[disabled],.form-control[readonly],fieldset[disabled] .form-control{cursor:not-allowed;background-color:#ecf0f1;opacity:1}textarea.form-control{height:auto}input[type="search"]{-webkit-appearance:none}input[type="date"]{line-height:43px}.form-group{margin-bottom:15px}.radio,.checkbox{display:block;min-height:21px;margin-top:10px;margin-bottom:10px;padding-left:20px}.radio label,.checkbox label{display:inline;font-weight:normal;cursor:pointer}.radio input[type="radio"],.radio-inline input[type="radio"],.checkbox input[type="checkbox"],.checkbox-inline input[type="checkbox"]{float:left;margin-left:-20px}.radio+.radio,.checkbox+.checkbox{margin-top:-5px}.radio-inline,.checkbox-inline{display:inline-block;padding-left:20px;margin-bottom:0;vertical-align:middle;font-weight:normal;cursor:pointer}.radio-inline+.radio-inline,.checkbox-inline+.checkbox-inline{margin-top:0;margin-left:10px}input[type="radio"][disabled],input[type="checkbox"][disabled],.radio[disabled],.radio-inline[disabled],.checkbox[disabled],.checkbox-inline[disabled],fieldset[disabled] input[type="radio"],fieldset[disabled] input[type="checkbox"],fieldset[disabled] .radio,fieldset[disabled] .radio-inline,fieldset[disabled] .checkbox,fieldset[disabled] .checkbox-inline{cursor:not-allowed}.input-sm{height:33px;padding:6px 9px;font-size:13px;line-height:1.5;border-radius:3px}select.input-sm{height:33px;line-height:33px}textarea.input-sm,select[multiple].input-sm{height:auto}.input-lg{height:64px;padding:18px 27px;font-size:19px;line-height:1.33;border-radius:6px}select.input-lg{height:64px;line-height:64px}textarea.input-lg,select[multiple].input-lg{height:auto}.has-feedback{position:relative}.has-feedback .form-control{padding-right:53.75px}.has-feedback .form-control-feedback{position:absolute;top:26px;right:0;display:block;width:43px;height:43px;line-height:43px;text-align:center}.has-success .help-block,.has-success .control-label,.has-success .radio,.has-success .checkbox,.has-success .radio-inline,.has-success .checkbox-inline{color:#ffffff}.has-success .form-control{border-color:#ffffff;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.has-success .form-control:focus{border-color:#e6e6e6;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #fff;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #fff}.has-success .input-group-addon{color:#ffffff;border-color:#ffffff;background-color:#18bc9c}.has-success .form-control-feedback{color:#ffffff}.has-warning .help-block,.has-warning .control-label,.has-warning .radio,.has-warning .checkbox,.has-warning .radio-inline,.has-warning .checkbox-inline{color:#ffffff}.has-warning .form-control{border-color:#ffffff;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.has-warning .form-control:focus{border-color:#e6e6e6;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #fff;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #fff}.has-warning .input-group-addon{color:#ffffff;border-color:#ffffff;background-color:#f39c12}.has-warning .form-control-feedback{color:#ffffff}.has-error .help-block,.has-error .control-label,.has-error .radio,.has-error .checkbox,.has-error .radio-inline,.has-error .checkbox-inline{color:#ffffff}.has-error .form-control{border-color:#ffffff;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.has-error .form-control:focus{border-color:#e6e6e6;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #fff;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #fff}.has-error .input-group-addon{color:#ffffff;border-color:#ffffff;background-color:#e74c3c}.has-error .form-control-feedback{color:#ffffff}.form-control-static{margin-bottom:0}.help-block{display:block;margin-top:5px;margin-bottom:10px;color:#597ea2}@media (min-width:768px){.form-inline .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .input-group>.form-control{width:100%}.form-inline .control-label{margin-bottom:0;vertical-align:middle}.form-inline .radio,.form-inline .checkbox{display:inline-block;margin-top:0;margin-bottom:0;padding-left:0;vertical-align:middle}.form-inline .radio input[type="radio"],.form-inline .checkbox input[type="checkbox"]{float:none;margin-left:0}.form-inline .has-feedback .form-control-feedback{top:0}}.form-horizontal .control-label,.form-horizontal .radio,.form-horizontal .checkbox,.form-horizontal .radio-inline,.form-horizontal .checkbox-inline{margin-top:0;margin-bottom:0;padding-top:11px}.form-horizontal .radio,.form-horizontal .checkbox{min-height:32px}.form-horizontal .form-group{margin-left:-15px;margin-right:-15px}.form-horizontal .form-control-static{padding-top:11px}@media (min-width:768px){.form-horizontal .control-label{text-align:right}}.form-horizontal .has-feedback .form-control-feedback{top:0;right:15px}.btn{display:inline-block;margin-bottom:0;font-weight:normal;text-align:center;vertical-align:middle;cursor:pointer;background-image:none;border:1px solid transparent;white-space:nowrap;padding:10px 15px;font-size:15px;line-height:1.42857143;border-radius:4px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.btn:focus,.btn:active:focus,.btn.active:focus{outline:thin dotted;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn:hover,.btn:focus{color:#ffffff;text-decoration:none}.btn:active,.btn.active{outline:0;background-image:none;-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,0.125);box-shadow:inset 0 3px 5px rgba(0,0,0,0.125)}.btn.disabled,.btn[disabled],fieldset[disabled] .btn{cursor:not-allowed;pointer-events:none;opacity:0.65;filter:alpha(opacity=65);-webkit-box-shadow:none;box-shadow:none}.btn-default{color:#ffffff;background-color:#95a5a6;border-color:#95a5a6}.btn-default:hover,.btn-default:focus,.btn-default:active,.btn-default.active,.open .dropdown-toggle.btn-default{color:#ffffff;background-color:#7f9293;border-color:#74898a}.btn-default:active,.btn-default.active,.open .dropdown-toggle.btn-default{background-image:none}.btn-default.disabled,.btn-default[disabled],fieldset[disabled] .btn-default,.btn-default.disabled:hover,.btn-default[disabled]:hover,fieldset[disabled] .btn-default:hover,.btn-default.disabled:focus,.btn-default[disabled]:focus,fieldset[disabled] .btn-default:focus,.btn-default.disabled:active,.btn-default[disabled]:active,fieldset[disabled] .btn-default:active,.btn-default.disabled.active,.btn-default[disabled].active,fieldset[disabled] .btn-default.active{background-color:#95a5a6;border-color:#95a5a6}.btn-default .badge{color:#95a5a6;background-color:#ffffff}.btn-primary{color:#ffffff;background-color:#2c3e50;border-color:#2c3e50}.btn-primary:hover,.btn-primary:focus,.btn-primary:active,.btn-primary.active,.open .dropdown-toggle.btn-primary{color:#ffffff;background-color:#1e2a36;border-color:#161f29}.btn-primary:active,.btn-primary.active,.open .dropdown-toggle.btn-primary{background-image:none}.btn-primary.disabled,.btn-primary[disabled],fieldset[disabled] .btn-primary,.btn-primary.disabled:hover,.btn-primary[disabled]:hover,fieldset[disabled] .btn-primary:hover,.btn-primary.disabled:focus,.btn-primary[disabled]:focus,fieldset[disabled] .btn-primary:focus,.btn-primary.disabled:active,.btn-primary[disabled]:active,fieldset[disabled] .btn-primary:active,.btn-primary.disabled.active,.btn-primary[disabled].active,fieldset[disabled] .btn-primary.active{background-color:#2c3e50;border-color:#2c3e50}.btn-primary .badge{color:#2c3e50;background-color:#ffffff}.btn-success{color:#ffffff;background-color:#18bc9c;border-color:#18bc9c}.btn-success:hover,.btn-success:focus,.btn-success:active,.btn-success.active,.open .dropdown-toggle.btn-success{color:#ffffff;background-color:#13987e;border-color:#11866f}.btn-success:active,.btn-success.active,.open .dropdown-toggle.btn-success{background-image:none}.btn-success.disabled,.btn-success[disabled],fieldset[disabled] .btn-success,.btn-success.disabled:hover,.btn-success[disabled]:hover,fieldset[disabled] .btn-success:hover,.btn-success.disabled:focus,.btn-success[disabled]:focus,fieldset[disabled] .btn-success:focus,.btn-success.disabled:active,.btn-success[disabled]:active,fieldset[disabled] .btn-success:active,.btn-success.disabled.active,.btn-success[disabled].active,fieldset[disabled] .btn-success.active{background-color:#18bc9c;border-color:#18bc9c}.btn-success .badge{color:#18bc9c;background-color:#ffffff}.btn-info{color:#ffffff;background-color:#3498db;border-color:#3498db}.btn-info:hover,.btn-info:focus,.btn-info:active,.btn-info.active,.open .dropdown-toggle.btn-info{color:#ffffff;background-color:#2383c4;border-color:#2077b2}.btn-info:active,.btn-info.active,.open .dropdown-toggle.btn-info{background-image:none}.btn-info.disabled,.btn-info[disabled],fieldset[disabled] .btn-info,.btn-info.disabled:hover,.btn-info[disabled]:hover,fieldset[disabled] .btn-info:hover,.btn-info.disabled:focus,.btn-info[disabled]:focus,fieldset[disabled] .btn-info:focus,.btn-info.disabled:active,.btn-info[disabled]:active,fieldset[disabled] .btn-info:active,.btn-info.disabled.active,.btn-info[disabled].active,fieldset[disabled] .btn-info.active{background-color:#3498db;border-color:#3498db}.btn-info .badge{color:#3498db;background-color:#ffffff}.btn-warning{color:#ffffff;background-color:#f39c12;border-color:#f39c12}.btn-warning:hover,.btn-warning:focus,.btn-warning:active,.btn-warning.active,.open .dropdown-toggle.btn-warning{color:#ffffff;background-color:#d2850b;border-color:#be780a}.btn-warning:active,.btn-warning.active,.open .dropdown-toggle.btn-warning{background-image:none}.btn-warning.disabled,.btn-warning[disabled],fieldset[disabled] .btn-warning,.btn-warning.disabled:hover,.btn-warning[disabled]:hover,fieldset[disabled] .btn-warning:hover,.btn-warning.disabled:focus,.btn-warning[disabled]:focus,fieldset[disabled] .btn-warning:focus,.btn-warning.disabled:active,.btn-warning[disabled]:active,fieldset[disabled] .btn-warning:active,.btn-warning.disabled.active,.btn-warning[disabled].active,fieldset[disabled] .btn-warning.active{background-color:#f39c12;border-color:#f39c12}.btn-warning .badge{color:#f39c12;background-color:#ffffff}.btn-danger{color:#ffffff;background-color:#e74c3c;border-color:#e74c3c}.btn-danger:hover,.btn-danger:focus,.btn-danger:active,.btn-danger.active,.open .dropdown-toggle.btn-danger{color:#ffffff;background-color:#df2e1b;border-color:#cd2a19}.btn-danger:active,.btn-danger.active,.open .dropdown-toggle.btn-danger{background-image:none}.btn-danger.disabled,.btn-danger[disabled],fieldset[disabled] .btn-danger,.btn-danger.disabled:hover,.btn-danger[disabled]:hover,fieldset[disabled] .btn-danger:hover,.btn-danger.disabled:focus,.btn-danger[disabled]:focus,fieldset[disabled] .btn-danger:focus,.btn-danger.disabled:active,.btn-danger[disabled]:active,fieldset[disabled] .btn-danger:active,.btn-danger.disabled.active,.btn-danger[disabled].active,fieldset[disabled] .btn-danger.active{background-color:#e74c3c;border-color:#e74c3c}.btn-danger .badge{color:#e74c3c;background-color:#ffffff}.btn-link{color:#18bc9c;font-weight:normal;cursor:pointer;border-radius:0}.btn-link,.btn-link:active,.btn-link[disabled],fieldset[disabled] .btn-link{background-color:transparent;-webkit-box-shadow:none;box-shadow:none}.btn-link,.btn-link:hover,.btn-link:focus,.btn-link:active{border-color:transparent}.btn-link:hover,.btn-link:focus{color:#18bc9c;text-decoration:underline;background-color:transparent}.btn-link[disabled]:hover,fieldset[disabled] .btn-link:hover,.btn-link[disabled]:focus,fieldset[disabled] .btn-link:focus{color:#b4bcc2;text-decoration:none}.btn-lg,.btn-group-lg>.btn{padding:18px 27px;font-size:19px;line-height:1.33;border-radius:6px}.btn-sm,.btn-group-sm>.btn{padding:6px 9px;font-size:13px;line-height:1.5;border-radius:3px}.btn-xs,.btn-group-xs>.btn{padding:1px 5px;font-size:13px;line-height:1.5;border-radius:3px}.btn-block{display:block;width:100%;padding-left:0;padding-right:0}.btn-block+.btn-block{margin-top:5px}input[type="submit"].btn-block,input[type="reset"].btn-block,input[type="button"].btn-block{width:100%}.fade{opacity:0;-webkit-transition:opacity 0.15s linear;transition:opacity 0.15s linear}.fade.in{opacity:1}.collapse{display:none}.collapse.in{display:block}.collapsing{position:relative;height:0;overflow:hidden;-webkit-transition:height 0.35s ease;transition:height 0.35s ease}@font-face{font-family:'Glyphicons Halflings';src:url('../fonts/glyphicons-halflings-regular.eot');src:url('../fonts/glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'),url('../fonts/glyphicons-halflings-regular.woff') format('woff'),url('../fonts/glyphicons-halflings-regular.ttf') format('truetype'),url('../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg')}.glyphicon{position:relative;top:1px;display:inline-block;font-family:'Glyphicons Halflings';font-style:normal;font-weight:normal;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\2a"}.glyphicon-plus:before{content:"\2b"}.glyphicon-euro:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e027"}.glyphicon-inbox:before{content:"\e028"}.glyphicon-play-circle:before{content:"\e029"}.glyphicon-repeat:before{content:"\e030"}.glyphicon-refresh:before{content:"\e031"}.glyphicon-list-alt:before{content:"\e032"}.glyphicon-lock:before{content:"\e033"}.glyphicon-flag:before{content:"\e034"}.glyphicon-headphones:before{content:"\e035"}.glyphicon-volume-off:before{content:"\e036"}.glyphicon-volume-down:before{content:"\e037"}.glyphicon-volume-up:before{content:"\e038"}.glyphicon-qrcode:before{content:"\e039"}.glyphicon-barcode:before{content:"\e040"}.glyphicon-tag:before{content:"\e041"}.glyphicon-tags:before{content:"\e042"}.glyphicon-book:before{content:"\e043"}.glyphicon-bookmark:before{content:"\e044"}.glyphicon-print:before{content:"\e045"}.glyphicon-camera:before{content:"\e046"}.glyphicon-font:before{content:"\e047"}.glyphicon-bold:before{content:"\e048"}.glyphicon-italic:before{content:"\e049"}.glyphicon-text-height:before{content:"\e050"}.glyphicon-text-width:before{content:"\e051"}.glyphicon-align-left:before{content:"\e052"}.glyphicon-align-center:before{content:"\e053"}.glyphicon-align-right:before{content:"\e054"}.glyphicon-align-justify:before{content:"\e055"}.glyphicon-list:before{content:"\e056"}.glyphicon-indent-left:before{content:"\e057"}.glyphicon-indent-right:before{content:"\e058"}.glyphicon-facetime-video:before{content:"\e059"}.glyphicon-picture:before{content:"\e060"}.glyphicon-map-marker:before{content:"\e062"}.glyphicon-adjust:before{content:"\e063"}.glyphicon-tint:before{content:"\e064"}.glyphicon-edit:before{content:"\e065"}.glyphicon-share:before{content:"\e066"}.glyphicon-check:before{content:"\e067"}.glyphicon-move:before{content:"\e068"}.glyphicon-step-backward:before{content:"\e069"}.glyphicon-fast-backward:before{content:"\e070"}.glyphicon-backward:before{content:"\e071"}.glyphicon-play:before{content:"\e072"}.glyphicon-pause:before{content:"\e073"}.glyphicon-stop:before{content:"\e074"}.glyphicon-forward:before{content:"\e075"}.glyphicon-fast-forward:before{content:"\e076"}.glyphicon-step-forward:before{content:"\e077"}.glyphicon-eject:before{content:"\e078"}.glyphicon-chevron-left:before{content:"\e079"}.glyphicon-chevron-right:before{content:"\e080"}.glyphicon-plus-sign:before{content:"\e081"}.glyphicon-minus-sign:before{content:"\e082"}.glyphicon-remove-sign:before{content:"\e083"}.glyphicon-ok-sign:before{content:"\e084"}.glyphicon-question-sign:before{content:"\e085"}.glyphicon-info-sign:before{content:"\e086"}.glyphicon-screenshot:before{content:"\e087"}.glyphicon-remove-circle:before{content:"\e088"}.glyphicon-ok-circle:before{content:"\e089"}.glyphicon-ban-circle:before{content:"\e090"}.glyphicon-arrow-left:before{content:"\e091"}.glyphicon-arrow-right:before{content:"\e092"}.glyphicon-arrow-up:before{content:"\e093"}.glyphicon-arrow-down:before{content:"\e094"}.glyphicon-share-alt:before{content:"\e095"}.glyphicon-resize-full:before{content:"\e096"}.glyphicon-resize-small:before{content:"\e097"}.glyphicon-exclamation-sign:before{content:"\e101"}.glyphicon-gift:before{content:"\e102"}.glyphicon-leaf:before{content:"\e103"}.glyphicon-fire:before{content:"\e104"}.glyphicon-eye-open:before{content:"\e105"}.glyphicon-eye-close:before{content:"\e106"}.glyphicon-warning-sign:before{content:"\e107"}.glyphicon-plane:before{content:"\e108"}.glyphicon-calendar:before{content:"\e109"}.glyphicon-random:before{content:"\e110"}.glyphicon-comment:before{content:"\e111"}.glyphicon-magnet:before{content:"\e112"}.glyphicon-chevron-up:before{content:"\e113"}.glyphicon-chevron-down:before{content:"\e114"}.glyphicon-retweet:before{content:"\e115"}.glyphicon-shopping-cart:before{content:"\e116"}.glyphicon-folder-close:before{content:"\e117"}.glyphicon-folder-open:before{content:"\e118"}.glyphicon-resize-vertical:before{content:"\e119"}.glyphicon-resize-horizontal:before{content:"\e120"}.glyphicon-hdd:before{content:"\e121"}.glyphicon-bullhorn:before{content:"\e122"}.glyphicon-bell:before{content:"\e123"}.glyphicon-certificate:before{content:"\e124"}.glyphicon-thumbs-up:before{content:"\e125"}.glyphicon-thumbs-down:before{content:"\e126"}.glyphicon-hand-right:before{content:"\e127"}.glyphicon-hand-left:before{content:"\e128"}.glyphicon-hand-up:before{content:"\e129"}.glyphicon-hand-down:before{content:"\e130"}.glyphicon-circle-arrow-right:before{content:"\e131"}.glyphicon-circle-arrow-left:before{content:"\e132"}.glyphicon-circle-arrow-up:before{content:"\e133"}.glyphicon-circle-arrow-down:before{content:"\e134"}.glyphicon-globe:before{content:"\e135"}.glyphicon-wrench:before{content:"\e136"}.glyphicon-tasks:before{content:"\e137"}.glyphicon-filter:before{content:"\e138"}.glyphicon-briefcase:before{content:"\e139"}.glyphicon-fullscreen:before{content:"\e140"}.glyphicon-dashboard:before{content:"\e141"}.glyphicon-paperclip:before{content:"\e142"}.glyphicon-heart-empty:before{content:"\e143"}.glyphicon-link:before{content:"\e144"}.glyphicon-phone:before{content:"\e145"}.glyphicon-pushpin:before{content:"\e146"}.glyphicon-usd:before{content:"\e148"}.glyphicon-gbp:before{content:"\e149"}.glyphicon-sort:before{content:"\e150"}.glyphicon-sort-by-alphabet:before{content:"\e151"}.glyphicon-sort-by-alphabet-alt:before{content:"\e152"}.glyphicon-sort-by-order:before{content:"\e153"}.glyphicon-sort-by-order-alt:before{content:"\e154"}.glyphicon-sort-by-attributes:before{content:"\e155"}.glyphicon-sort-by-attributes-alt:before{content:"\e156"}.glyphicon-unchecked:before{content:"\e157"}.glyphicon-expand:before{content:"\e158"}.glyphicon-collapse-down:before{content:"\e159"}.glyphicon-collapse-up:before{content:"\e160"}.glyphicon-log-in:before{content:"\e161"}.glyphicon-flash:before{content:"\e162"}.glyphicon-log-out:before{content:"\e163"}.glyphicon-new-window:before{content:"\e164"}.glyphicon-record:before{content:"\e165"}.glyphicon-save:before{content:"\e166"}.glyphicon-open:before{content:"\e167"}.glyphicon-saved:before{content:"\e168"}.glyphicon-import:before{content:"\e169"}.glyphicon-export:before{content:"\e170"}.glyphicon-send:before{content:"\e171"}.glyphicon-floppy-disk:before{content:"\e172"}.glyphicon-floppy-saved:before{content:"\e173"}.glyphicon-floppy-remove:before{content:"\e174"}.glyphicon-floppy-save:before{content:"\e175"}.glyphicon-floppy-open:before{content:"\e176"}.glyphicon-credit-card:before{content:"\e177"}.glyphicon-transfer:before{content:"\e178"}.glyphicon-cutlery:before{content:"\e179"}.glyphicon-header:before{content:"\e180"}.glyphicon-compressed:before{content:"\e181"}.glyphicon-earphone:before{content:"\e182"}.glyphicon-phone-alt:before{content:"\e183"}.glyphicon-tower:before{content:"\e184"}.glyphicon-stats:before{content:"\e185"}.glyphicon-sd-video:before{content:"\e186"}.glyphicon-hd-video:before{content:"\e187"}.glyphicon-subtitles:before{content:"\e188"}.glyphicon-sound-stereo:before{content:"\e189"}.glyphicon-sound-dolby:before{content:"\e190"}.glyphicon-sound-5-1:before{content:"\e191"}.glyphicon-sound-6-1:before{content:"\e192"}.glyphicon-sound-7-1:before{content:"\e193"}.glyphicon-copyright-mark:before{content:"\e194"}.glyphicon-registration-mark:before{content:"\e195"}.glyphicon-cloud-download:before{content:"\e197"}.glyphicon-cloud-upload:before{content:"\e198"}.glyphicon-tree-conifer:before{content:"\e199"}.glyphicon-tree-deciduous:before{content:"\e200"}.caret{display:inline-block;width:0;height:0;margin-left:2px;vertical-align:middle;border-top:4px solid;border-right:4px solid transparent;border-left:4px solid transparent}.dropdown{position:relative}.dropdown-toggle:focus{outline:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;list-style:none;font-size:15px;background-color:#ffffff;border:1px solid #cccccc;border:1px solid rgba(0,0,0,0.15);border-radius:4px;-webkit-box-shadow:0 6px 12px rgba(0,0,0,0.175);box-shadow:0 6px 12px rgba(0,0,0,0.175);background-clip:padding-box}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{height:1px;margin:9.5px 0;overflow:hidden;background-color:#e5e5e5}.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:normal;line-height:1.42857143;color:#7b8a8b;white-space:nowrap}.dropdown-menu>li>a:hover,.dropdown-menu>li>a:focus{text-decoration:none;color:#ffffff;background-color:#2c3e50}.dropdown-menu>.active>a,.dropdown-menu>.active>a:hover,.dropdown-menu>.active>a:focus{color:#ffffff;text-decoration:none;outline:0;background-color:#2c3e50}.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:hover,.dropdown-menu>.disabled>a:focus{color:#b4bcc2}.dropdown-menu>.disabled>a:hover,.dropdown-menu>.disabled>a:focus{text-decoration:none;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);cursor:not-allowed}.open>.dropdown-menu{display:block}.open>a{outline:0}.dropdown-menu-right{left:auto;right:0}.dropdown-menu-left{left:0;right:auto}.dropdown-header{display:block;padding:3px 20px;font-size:13px;line-height:1.42857143;color:#b4bcc2}.dropdown-backdrop{position:fixed;left:0;right:0;bottom:0;top:0;z-index:990}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{border-top:0;border-bottom:4px solid;content:""}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:1px}@media (min-width:768px){.navbar-right .dropdown-menu{left:auto;right:0}.navbar-right .dropdown-menu-left{left:0;right:auto}}.btn-group,.btn-group-vertical{position:relative;display:inline-block;vertical-align:middle}.btn-group>.btn,.btn-group-vertical>.btn{position:relative;float:left}.btn-group>.btn:hover,.btn-group-vertical>.btn:hover,.btn-group>.btn:focus,.btn-group-vertical>.btn:focus,.btn-group>.btn:active,.btn-group-vertical>.btn:active,.btn-group>.btn.active,.btn-group-vertical>.btn.active{z-index:2}.btn-group>.btn:focus,.btn-group-vertical>.btn:focus{outline:none}.btn-group .btn+.btn,.btn-group .btn+.btn-group,.btn-group .btn-group+.btn,.btn-group .btn-group+.btn-group{margin-left:-1px}.btn-toolbar{margin-left:-5px}.btn-toolbar .btn-group,.btn-toolbar .input-group{float:left}.btn-toolbar>.btn,.btn-toolbar>.btn-group,.btn-toolbar>.input-group{margin-left:5px}.btn-group>.btn:not(:first-child):not(:last-child):not(.dropdown-toggle){border-radius:0}.btn-group>.btn:first-child{margin-left:0}.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-top-right-radius:0}.btn-group>.btn:last-child:not(:first-child),.btn-group>.dropdown-toggle:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0}.btn-group>.btn-group{float:left}.btn-group>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group>.btn-group:first-child>.btn:last-child,.btn-group>.btn-group:first-child>.dropdown-toggle{border-bottom-right-radius:0;border-top-right-radius:0}.btn-group>.btn-group:last-child>.btn:first-child{border-bottom-left-radius:0;border-top-left-radius:0}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{padding-left:8px;padding-right:8px}.btn-group>.btn-lg+.dropdown-toggle{padding-left:12px;padding-right:12px}.btn-group.open .dropdown-toggle{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,0.125);box-shadow:inset 0 3px 5px rgba(0,0,0,0.125)}.btn-group.open .dropdown-toggle.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn .caret{margin-left:0}.btn-lg .caret{border-width:5px 5px 0;border-bottom-width:0}.dropup .btn-lg .caret{border-width:0 5px 5px}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group,.btn-group-vertical>.btn-group>.btn{display:block;float:none;width:100%;max-width:100%}.btn-group-vertical>.btn-group>.btn{float:none}.btn-group-vertical>.btn+.btn,.btn-group-vertical>.btn+.btn-group,.btn-group-vertical>.btn-group+.btn,.btn-group-vertical>.btn-group+.btn-group{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:not(:first-child):not(:last-child){border-radius:0}.btn-group-vertical>.btn:first-child:not(:last-child){border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:last-child:not(:first-child){border-bottom-left-radius:4px;border-top-right-radius:0;border-top-left-radius:0}.btn-group-vertical>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group-vertical>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group-vertical>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-right-radius:0;border-top-left-radius:0}.btn-group-justified{display:table;width:100%;table-layout:fixed;border-collapse:separate}.btn-group-justified>.btn,.btn-group-justified>.btn-group{float:none;display:table-cell;width:1%}.btn-group-justified>.btn-group .btn{width:100%}[data-toggle="buttons"]>.btn>input[type="radio"],[data-toggle="buttons"]>.btn>input[type="checkbox"]{display:none}.input-group{position:relative;display:table;border-collapse:separate}.input-group[class*="col-"]{float:none;padding-left:0;padding-right:0}.input-group .form-control{position:relative;z-index:2;float:left;width:100%;margin-bottom:0}.input-group-lg>.form-control,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.btn{height:64px;padding:18px 27px;font-size:19px;line-height:1.33;border-radius:6px}select.input-group-lg>.form-control,select.input-group-lg>.input-group-addon,select.input-group-lg>.input-group-btn>.btn{height:64px;line-height:64px}textarea.input-group-lg>.form-control,textarea.input-group-lg>.input-group-addon,textarea.input-group-lg>.input-group-btn>.btn,select[multiple].input-group-lg>.form-control,select[multiple].input-group-lg>.input-group-addon,select[multiple].input-group-lg>.input-group-btn>.btn{height:auto}.input-group-sm>.form-control,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.btn{height:33px;padding:6px 9px;font-size:13px;line-height:1.5;border-radius:3px}select.input-group-sm>.form-control,select.input-group-sm>.input-group-addon,select.input-group-sm>.input-group-btn>.btn{height:33px;line-height:33px}textarea.input-group-sm>.form-control,textarea.input-group-sm>.input-group-addon,textarea.input-group-sm>.input-group-btn>.btn,select[multiple].input-group-sm>.form-control,select[multiple].input-group-sm>.input-group-addon,select[multiple].input-group-sm>.input-group-btn>.btn{height:auto}.input-group-addon,.input-group-btn,.input-group .form-control{display:table-cell}.input-group-addon:not(:first-child):not(:last-child),.input-group-btn:not(:first-child):not(:last-child),.input-group .form-control:not(:first-child):not(:last-child){border-radius:0}.input-group-addon,.input-group-btn{width:1%;white-space:nowrap;vertical-align:middle}.input-group-addon{padding:10px 15px;font-size:15px;font-weight:normal;line-height:1;color:#2c3e50;text-align:center;background-color:#ecf0f1;border:1px solid #dce4ec;border-radius:4px}.input-group-addon.input-sm{padding:6px 9px;font-size:13px;border-radius:3px}.input-group-addon.input-lg{padding:18px 27px;font-size:19px;border-radius:6px}.input-group-addon input[type="radio"],.input-group-addon input[type="checkbox"]{margin-top:0}.input-group .form-control:first-child,.input-group-addon:first-child,.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group>.btn,.input-group-btn:first-child>.dropdown-toggle,.input-group-btn:last-child>.btn:not(:last-child):not(.dropdown-toggle),.input-group-btn:last-child>.btn-group:not(:last-child)>.btn{border-bottom-right-radius:0;border-top-right-radius:0}.input-group-addon:first-child{border-right:0}.input-group .form-control:last-child,.input-group-addon:last-child,.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group>.btn,.input-group-btn:last-child>.dropdown-toggle,.input-group-btn:first-child>.btn:not(:first-child),.input-group-btn:first-child>.btn-group:not(:first-child)>.btn{border-bottom-left-radius:0;border-top-left-radius:0}.input-group-addon:last-child{border-left:0}.input-group-btn{position:relative;font-size:0;white-space:nowrap}.input-group-btn>.btn{position:relative}.input-group-btn>.btn+.btn{margin-left:-1px}.input-group-btn>.btn:hover,.input-group-btn>.btn:focus,.input-group-btn>.btn:active{z-index:2}.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group{margin-right:-1px}.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group{margin-left:-1px}.nav{margin-bottom:0;padding-left:0;list-style:none}.nav>li{position:relative;display:block}.nav>li>a{position:relative;display:block;padding:10px 15px}.nav>li>a:hover,.nav>li>a:focus{text-decoration:none;background-color:#ecf0f1}.nav>li.disabled>a{color:#b4bcc2}.nav>li.disabled>a:hover,.nav>li.disabled>a:focus{color:#b4bcc2;text-decoration:none;background-color:transparent;cursor:not-allowed}.nav .open>a,.nav .open>a:hover,.nav .open>a:focus{background-color:#ecf0f1;border-color:#18bc9c}.nav .nav-divider{height:1px;margin:9.5px 0;overflow:hidden;background-color:#e5e5e5}.nav>li>a>img{max-width:none}.nav-tabs{border-bottom:1px solid #ecf0f1}.nav-tabs>li{float:left;margin-bottom:-1px}.nav-tabs>li>a{margin-right:2px;line-height:1.42857143;border:1px solid transparent;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover{border-color:#ecf0f1 #ecf0f1 #ecf0f1}.nav-tabs>li.active>a,.nav-tabs>li.active>a:hover,.nav-tabs>li.active>a:focus{color:#2c3e50;background-color:#ffffff;border:1px solid #ecf0f1;border-bottom-color:transparent;cursor:default}.nav-tabs.nav-justified{width:100%;border-bottom:0}.nav-tabs.nav-justified>li{float:none}.nav-tabs.nav-justified>li>a{text-align:center;margin-bottom:5px}.nav-tabs.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-tabs.nav-justified>li{display:table-cell;width:1%}.nav-tabs.nav-justified>li>a{margin-bottom:0}}.nav-tabs.nav-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:hover,.nav-tabs.nav-justified>.active>a:focus{border:1px solid #ecf0f1}@media (min-width:768px){.nav-tabs.nav-justified>li>a{border-bottom:1px solid #ecf0f1;border-radius:4px 4px 0 0}.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:hover,.nav-tabs.nav-justified>.active>a:focus{border-bottom-color:#ffffff}}.nav-pills>li{float:left}.nav-pills>li>a{border-radius:4px}.nav-pills>li+li{margin-left:2px}.nav-pills>li.active>a,.nav-pills>li.active>a:hover,.nav-pills>li.active>a:focus{color:#ffffff;background-color:#2c3e50}.nav-stacked>li{float:none}.nav-stacked>li+li{margin-top:2px;margin-left:0}.nav-justified{width:100%}.nav-justified>li{float:none}.nav-justified>li>a{text-align:center;margin-bottom:5px}.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-justified>li{display:table-cell;width:1%}.nav-justified>li>a{margin-bottom:0}}.nav-tabs-justified{border-bottom:0}.nav-tabs-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:hover,.nav-tabs-justified>.active>a:focus{border:1px solid #ecf0f1}@media (min-width:768px){.nav-tabs-justified>li>a{border-bottom:1px solid #ecf0f1;border-radius:4px 4px 0 0}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:hover,.nav-tabs-justified>.active>a:focus{border-bottom-color:#ffffff}}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-right-radius:0;border-top-left-radius:0}.navbar{position:relative;min-height:60px;margin-bottom:21px;border:1px solid transparent}@media (min-width:768px){.navbar{border-radius:4px}}@media (min-width:768px){.navbar-header{float:left}}.navbar-collapse{max-height:340px;overflow-x:visible;padding-right:15px;padding-left:15px;border-top:1px solid transparent;box-shadow:inset 0 1px 0 rgba(255,255,255,0.1);-webkit-overflow-scrolling:touch}.navbar-collapse.in{overflow-y:auto}@media (min-width:768px){.navbar-collapse{width:auto;border-top:0;box-shadow:none}.navbar-collapse.collapse{display:block !important;height:auto !important;padding-bottom:0;overflow:visible !important}.navbar-collapse.in{overflow-y:visible}.navbar-fixed-top .navbar-collapse,.navbar-static-top .navbar-collapse,.navbar-fixed-bottom .navbar-collapse{padding-left:0;padding-right:0}}.container>.navbar-header,.container-fluid>.navbar-header,.container>.navbar-collapse,.container-fluid>.navbar-collapse{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.container>.navbar-header,.container-fluid>.navbar-header,.container>.navbar-collapse,.container-fluid>.navbar-collapse{margin-right:0;margin-left:0}}.navbar-static-top{z-index:1000;border-width:0 0 1px}@media (min-width:768px){.navbar-static-top{border-radius:0}}.navbar-fixed-top,.navbar-fixed-bottom{position:fixed;right:0;left:0;z-index:1030}@media (min-width:768px){.navbar-fixed-top,.navbar-fixed-bottom{border-radius:0}}.navbar-fixed-top{top:0;border-width:0 0 1px}.navbar-fixed-bottom{bottom:0;margin-bottom:0;border-width:1px 0 0}.navbar-brand{float:left;padding:19.5px 15px;font-size:19px;line-height:21px;height:60px}.navbar-brand:hover,.navbar-brand:focus{text-decoration:none}@media (min-width:768px){.navbar>.container .navbar-brand,.navbar>.container-fluid .navbar-brand{margin-left:-15px}}.navbar-toggle{position:relative;float:right;margin-right:15px;padding:9px 10px;margin-top:13px;margin-bottom:13px;background-color:transparent;background-image:none;border:1px solid transparent;border-radius:4px}.navbar-toggle:focus{outline:none}.navbar-toggle .icon-bar{display:block;width:22px;height:2px;border-radius:1px}.navbar-toggle .icon-bar+.icon-bar{margin-top:4px}@media (min-width:768px){.navbar-toggle{display:none}}.navbar-nav{margin:9.75px -15px}.navbar-nav>li>a{padding-top:10px;padding-bottom:10px;line-height:21px}@media (max-width:767px){.navbar-nav .open .dropdown-menu{position:static;float:none;width:auto;margin-top:0;background-color:transparent;border:0;box-shadow:none}.navbar-nav .open .dropdown-menu>li>a,.navbar-nav .open .dropdown-menu .dropdown-header{padding:5px 15px 5px 25px}.navbar-nav .open .dropdown-menu>li>a{line-height:21px}.navbar-nav .open .dropdown-menu>li>a:hover,.navbar-nav .open .dropdown-menu>li>a:focus{background-image:none}}@media (min-width:768px){.navbar-nav{float:left;margin:0}.navbar-nav>li{float:left}.navbar-nav>li>a{padding-top:19.5px;padding-bottom:19.5px}.navbar-nav.navbar-right:last-child{margin-right:-15px}}@media (min-width:768px){.navbar-left{float:left !important}.navbar-right{float:right !important}}.navbar-form{margin-left:-15px;margin-right:-15px;padding:10px 15px;border-top:1px solid transparent;border-bottom:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.1);box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.1);margin-top:8.5px;margin-bottom:8.5px}@media (min-width:768px){.navbar-form .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.navbar-form .form-control{display:inline-block;width:auto;vertical-align:middle}.navbar-form .input-group>.form-control{width:100%}.navbar-form .control-label{margin-bottom:0;vertical-align:middle}.navbar-form .radio,.navbar-form .checkbox{display:inline-block;margin-top:0;margin-bottom:0;padding-left:0;vertical-align:middle}.navbar-form .radio input[type="radio"],.navbar-form .checkbox input[type="checkbox"]{float:none;margin-left:0}.navbar-form .has-feedback .form-control-feedback{top:0}}@media (max-width:767px){.navbar-form .form-group{margin-bottom:5px}}@media (min-width:768px){.navbar-form{width:auto;border:0;margin-left:0;margin-right:0;padding-top:0;padding-bottom:0;-webkit-box-shadow:none;box-shadow:none}.navbar-form.navbar-right:last-child{margin-right:-15px}}.navbar-nav>li>.dropdown-menu{margin-top:0;border-top-right-radius:0;border-top-left-radius:0}.navbar-fixed-bottom .navbar-nav>li>.dropdown-menu{border-bottom-right-radius:0;border-bottom-left-radius:0}.navbar-btn{margin-top:8.5px;margin-bottom:8.5px}.navbar-btn.btn-sm{margin-top:13.5px;margin-bottom:13.5px}.navbar-btn.btn-xs{margin-top:19px;margin-bottom:19px}.navbar-text{margin-top:19.5px;margin-bottom:19.5px}@media (min-width:768px){.navbar-text{float:left;margin-left:15px;margin-right:15px}.navbar-text.navbar-right:last-child{margin-right:0}}.navbar-default{background-color:#2c3e50;border-color:transparent}.navbar-default .navbar-brand{color:#ffffff}.navbar-default .navbar-brand:hover,.navbar-default .navbar-brand:focus{color:#18bc9c;background-color:transparent}.navbar-default .navbar-text{color:#777777}.navbar-default .navbar-nav>li>a{color:#ffffff}.navbar-default .navbar-nav>li>a:hover,.navbar-default .navbar-nav>li>a:focus{color:#18bc9c;background-color:transparent}.navbar-default .navbar-nav>.active>a,.navbar-default .navbar-nav>.active>a:hover,.navbar-default .navbar-nav>.active>a:focus{color:#ffffff;background-color:#1a242f}.navbar-default .navbar-nav>.disabled>a,.navbar-default .navbar-nav>.disabled>a:hover,.navbar-default .navbar-nav>.disabled>a:focus{color:#cccccc;background-color:transparent}.navbar-default .navbar-toggle{border-color:#1a242f}.navbar-default .navbar-toggle:hover,.navbar-default .navbar-toggle:focus{background-color:#1a242f}.navbar-default .navbar-toggle .icon-bar{background-color:#ffffff}.navbar-default .navbar-collapse,.navbar-default .navbar-form{border-color:transparent}.navbar-default .navbar-nav>.open>a,.navbar-default .navbar-nav>.open>a:hover,.navbar-default .navbar-nav>.open>a:focus{background-color:#1a242f;color:#ffffff}@media (max-width:767px){.navbar-default .navbar-nav .open .dropdown-menu>li>a{color:#ffffff}.navbar-default .navbar-nav .open .dropdown-menu>li>a:hover,.navbar-default .navbar-nav .open .dropdown-menu>li>a:focus{color:#18bc9c;background-color:transparent}.navbar-default .navbar-nav .open .dropdown-menu>.active>a,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:hover,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:focus{color:#ffffff;background-color:#1a242f}.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:hover,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:focus{color:#cccccc;background-color:transparent}}.navbar-default .navbar-link{color:#ffffff}.navbar-default .navbar-link:hover{color:#18bc9c}.navbar-inverse{background-color:#18bc9c;border-color:transparent}.navbar-inverse .navbar-brand{color:#ffffff}.navbar-inverse .navbar-brand:hover,.navbar-inverse .navbar-brand:focus{color:#2c3e50;background-color:transparent}.navbar-inverse .navbar-text{color:#ffffff}.navbar-inverse .navbar-nav>li>a{color:#ffffff}.navbar-inverse .navbar-nav>li>a:hover,.navbar-inverse .navbar-nav>li>a:focus{color:#2c3e50;background-color:transparent}.navbar-inverse .navbar-nav>.active>a,.navbar-inverse .navbar-nav>.active>a:hover,.navbar-inverse .navbar-nav>.active>a:focus{color:#ffffff;background-color:#15a589}.navbar-inverse .navbar-nav>.disabled>a,.navbar-inverse .navbar-nav>.disabled>a:hover,.navbar-inverse .navbar-nav>.disabled>a:focus{color:#cccccc;background-color:transparent}.navbar-inverse .navbar-toggle{border-color:#128f76}.navbar-inverse .navbar-toggle:hover,.navbar-inverse .navbar-toggle:focus{background-color:#128f76}.navbar-inverse .navbar-toggle .icon-bar{background-color:#ffffff}.navbar-inverse .navbar-collapse,.navbar-inverse .navbar-form{border-color:#149c82}.navbar-inverse .navbar-nav>.open>a,.navbar-inverse .navbar-nav>.open>a:hover,.navbar-inverse .navbar-nav>.open>a:focus{background-color:#15a589;color:#ffffff}@media (max-width:767px){.navbar-inverse .navbar-nav .open .dropdown-menu>.dropdown-header{border-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu .divider{background-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a{color:#ffffff}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:hover,.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:focus{color:#2c3e50;background-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:hover,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:focus{color:#ffffff;background-color:#15a589}.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:hover,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:focus{color:#cccccc;background-color:transparent}}.navbar-inverse .navbar-link{color:#ffffff}.navbar-inverse .navbar-link:hover{color:#2c3e50}.breadcrumb{padding:8px 15px;margin-bottom:21px;list-style:none;background-color:#ecf0f1;border-radius:4px}.breadcrumb>li{display:inline-block}.breadcrumb>li+li:before{content:"/\00a0";padding:0 5px;color:#cccccc}.breadcrumb>.active{color:#95a5a6}.pagination{display:inline-block;padding-left:0;margin:21px 0;border-radius:4px}.pagination>li{display:inline}.pagination>li>a,.pagination>li>span{position:relative;float:left;padding:10px 15px;line-height:1.42857143;text-decoration:none;color:#ffffff;background-color:#18bc9c;border:1px solid transparent;margin-left:-1px}.pagination>li:first-child>a,.pagination>li:first-child>span{margin-left:0;border-bottom-left-radius:4px;border-top-left-radius:4px}.pagination>li:last-child>a,.pagination>li:last-child>span{border-bottom-right-radius:4px;border-top-right-radius:4px}.pagination>li>a:hover,.pagination>li>span:hover,.pagination>li>a:focus,.pagination>li>span:focus{color:#ffffff;background-color:#0f7864;border-color:transparent}.pagination>.active>a,.pagination>.active>span,.pagination>.active>a:hover,.pagination>.active>span:hover,.pagination>.active>a:focus,.pagination>.active>span:focus{z-index:2;color:#ffffff;background-color:#0f7864;border-color:transparent;cursor:default}.pagination>.disabled>span,.pagination>.disabled>span:hover,.pagination>.disabled>span:focus,.pagination>.disabled>a,.pagination>.disabled>a:hover,.pagination>.disabled>a:focus{color:#ecf0f1;background-color:#3be6c4;border-color:transparent;cursor:not-allowed}.pagination-lg>li>a,.pagination-lg>li>span{padding:18px 27px;font-size:19px}.pagination-lg>li:first-child>a,.pagination-lg>li:first-child>span{border-bottom-left-radius:6px;border-top-left-radius:6px}.pagination-lg>li:last-child>a,.pagination-lg>li:last-child>span{border-bottom-right-radius:6px;border-top-right-radius:6px}.pagination-sm>li>a,.pagination-sm>li>span{padding:6px 9px;font-size:13px}.pagination-sm>li:first-child>a,.pagination-sm>li:first-child>span{border-bottom-left-radius:3px;border-top-left-radius:3px}.pagination-sm>li:last-child>a,.pagination-sm>li:last-child>span{border-bottom-right-radius:3px;border-top-right-radius:3px}.pager{padding-left:0;margin:21px 0;list-style:none;text-align:center}.pager li{display:inline}.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#18bc9c;border:1px solid transparent;border-radius:15px}.pager li>a:hover,.pager li>a:focus{text-decoration:none;background-color:#0f7864}.pager .next>a,.pager .next>span{float:right}.pager .previous>a,.pager .previous>span{float:left}.pager .disabled>a,.pager .disabled>a:hover,.pager .disabled>a:focus,.pager .disabled>span{color:#ffffff;background-color:#18bc9c;cursor:not-allowed}.label{display:inline;padding:.2em .6em .3em;font-size:75%;font-weight:bold;line-height:1;color:#ffffff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25em}.label[href]:hover,.label[href]:focus{color:#ffffff;text-decoration:none;cursor:pointer}.label:empty{display:none}.btn .label{position:relative;top:-1px}.label-default{background-color:#95a5a6}.label-default[href]:hover,.label-default[href]:focus{background-color:#798d8f}.label-primary{background-color:#2c3e50}.label-primary[href]:hover,.label-primary[href]:focus{background-color:#1a242f}.label-success{background-color:#18bc9c}.label-success[href]:hover,.label-success[href]:focus{background-color:#128f76}.label-info{background-color:#3498db}.label-info[href]:hover,.label-info[href]:focus{background-color:#217dbb}.label-warning{background-color:#f39c12}.label-warning[href]:hover,.label-warning[href]:focus{background-color:#c87f0a}.label-danger{background-color:#e74c3c}.label-danger[href]:hover,.label-danger[href]:focus{background-color:#d62c1a}.badge{display:inline-block;min-width:10px;padding:3px 7px;font-size:13px;font-weight:bold;color:#ffffff;line-height:1;vertical-align:baseline;white-space:nowrap;text-align:center;background-color:#2c3e50;border-radius:10px}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.btn-xs .badge{top:0;padding:1px 5px}a.badge:hover,a.badge:focus{color:#ffffff;text-decoration:none;cursor:pointer}a.list-group-item.active>.badge,.nav-pills>.active>a>.badge{color:#2c3e50;background-color:#ffffff}.nav-pills>li>a>.badge{margin-left:3px}.jumbotron{padding:30px;margin-bottom:30px;color:inherit;background-color:#ecf0f1}.jumbotron h1,.jumbotron .h1{color:inherit}.jumbotron p{margin-bottom:15px;font-size:23px;font-weight:200}.container .jumbotron{border-radius:6px}.jumbotron .container{max-width:100%}@media screen and (min-width:768px){.jumbotron{padding-top:48px;padding-bottom:48px}.container .jumbotron{padding-left:60px;padding-right:60px}.jumbotron h1,.jumbotron .h1{font-size:67.5px}}.thumbnail{display:block;padding:4px;margin-bottom:21px;line-height:1.42857143;background-color:#ffffff;border:1px solid #ecf0f1;border-radius:4px;-webkit-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.thumbnail>img,.thumbnail a>img{margin-left:auto;margin-right:auto}a.thumbnail:hover,a.thumbnail:focus,a.thumbnail.active{border-color:#18bc9c}.thumbnail .caption{padding:9px;color:#2c3e50}.alert{padding:15px;margin-bottom:21px;border:1px solid transparent;border-radius:4px}.alert h4{margin-top:0;color:inherit}.alert .alert-link{font-weight:bold}.alert>p,.alert>ul{margin-bottom:0}.alert>p+p{margin-top:5px}.alert-dismissable{padding-right:35px}.alert-dismissable .close{position:relative;top:-2px;right:-21px;color:inherit}.alert-success{background-color:#18bc9c;border-color:#18bc9c;color:#ffffff}.alert-success hr{border-top-color:#15a589}.alert-success .alert-link{color:#e6e6e6}.alert-info{background-color:#3498db;border-color:#3498db;color:#ffffff}.alert-info hr{border-top-color:#258cd1}.alert-info .alert-link{color:#e6e6e6}.alert-warning{background-color:#f39c12;border-color:#f39c12;color:#ffffff}.alert-warning hr{border-top-color:#e08e0b}.alert-warning .alert-link{color:#e6e6e6}.alert-danger{background-color:#e74c3c;border-color:#e74c3c;color:#ffffff}.alert-danger hr{border-top-color:#e43725}.alert-danger .alert-link{color:#e6e6e6}@-webkit-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}.progress{overflow:hidden;height:21px;margin-bottom:21px;background-color:#ecf0f1;border-radius:4px;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1);box-shadow:inset 0 1px 2px rgba(0,0,0,0.1)}.progress-bar{float:left;width:0%;height:100%;font-size:13px;line-height:21px;color:#ffffff;text-align:center;background-color:#2c3e50;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);-webkit-transition:width 0.6s ease;transition:width 0.6s ease}.progress-striped .progress-bar{background-image:-webkit-linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent);background-size:40px 40px}.progress.active .progress-bar{-webkit-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-bar-success{background-color:#18bc9c}.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent)}.progress-bar-info{background-color:#3498db}.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent)}.progress-bar-warning{background-color:#f39c12}.progress-striped .progress-bar-warning{background-image:-webkit-linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent)}.progress-bar-danger{background-color:#e74c3c}.progress-striped .progress-bar-danger{background-image:-webkit-linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255,255,255,0.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,0.15) 50%, rgba(255,255,255,0.15) 75%, transparent 75%, transparent)}.media,.media-body{overflow:hidden;zoom:1}.media,.media .media{margin-top:15px}.media:first-child{margin-top:0}.media-object{display:block}.media-heading{margin:0 0 5px}.media>.pull-left{margin-right:10px}.media>.pull-right{margin-left:10px}.media-list{padding-left:0;list-style:none}.list-group{margin-bottom:20px;padding-left:0}.list-group-item{position:relative;display:block;padding:10px 15px;margin-bottom:-1px;background-color:#ffffff;border:1px solid #ecf0f1}.list-group-item:first-child{border-top-right-radius:4px;border-top-left-radius:4px}.list-group-item:last-child{margin-bottom:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.list-group-item>.badge{float:right}.list-group-item>.badge+.badge{margin-right:5px}a.list-group-item{color:#555555}a.list-group-item .list-group-item-heading{color:#333333}a.list-group-item:hover,a.list-group-item:focus{text-decoration:none;background-color:#ecf0f1}a.list-group-item.active,a.list-group-item.active:hover,a.list-group-item.active:focus{z-index:2;color:#ffffff;background-color:#2c3e50;border-color:#2c3e50}a.list-group-item.active .list-group-item-heading,a.list-group-item.active:hover .list-group-item-heading,a.list-group-item.active:focus .list-group-item-heading{color:inherit}a.list-group-item.active .list-group-item-text,a.list-group-item.active:hover .list-group-item-text,a.list-group-item.active:focus .list-group-item-text{color:#8aa4be}.list-group-item-success{color:#ffffff;background-color:#18bc9c}a.list-group-item-success{color:#ffffff}a.list-group-item-success .list-group-item-heading{color:inherit}a.list-group-item-success:hover,a.list-group-item-success:focus{color:#ffffff;background-color:#15a589}a.list-group-item-success.active,a.list-group-item-success.active:hover,a.list-group-item-success.active:focus{color:#fff;background-color:#ffffff;border-color:#ffffff}.list-group-item-info{color:#ffffff;background-color:#3498db}a.list-group-item-info{color:#ffffff}a.list-group-item-info .list-group-item-heading{color:inherit}a.list-group-item-info:hover,a.list-group-item-info:focus{color:#ffffff;background-color:#258cd1}a.list-group-item-info.active,a.list-group-item-info.active:hover,a.list-group-item-info.active:focus{color:#fff;background-color:#ffffff;border-color:#ffffff}.list-group-item-warning{color:#ffffff;background-color:#f39c12}a.list-group-item-warning{color:#ffffff}a.list-group-item-warning .list-group-item-heading{color:inherit}a.list-group-item-warning:hover,a.list-group-item-warning:focus{color:#ffffff;background-color:#e08e0b}a.list-group-item-warning.active,a.list-group-item-warning.active:hover,a.list-group-item-warning.active:focus{color:#fff;background-color:#ffffff;border-color:#ffffff}.list-group-item-danger{color:#ffffff;background-color:#e74c3c}a.list-group-item-danger{color:#ffffff}a.list-group-item-danger .list-group-item-heading{color:inherit}a.list-group-item-danger:hover,a.list-group-item-danger:focus{color:#ffffff;background-color:#e43725}a.list-group-item-danger.active,a.list-group-item-danger.active:hover,a.list-group-item-danger.active:focus{color:#fff;background-color:#ffffff;border-color:#ffffff}.list-group-item-heading{margin-top:0;margin-bottom:5px}.list-group-item-text{margin-bottom:0;line-height:1.3}.panel{margin-bottom:21px;background-color:#ffffff;border:1px solid transparent;border-radius:4px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,0.05);box-shadow:0 1px 1px rgba(0,0,0,0.05)}.panel-body{padding:15px}.panel-heading{padding:10px 15px;border-bottom:1px solid transparent;border-top-right-radius:3px;border-top-left-radius:3px}.panel-heading>.dropdown .dropdown-toggle{color:inherit}.panel-title{margin-top:0;margin-bottom:0;font-size:17px;color:inherit}.panel-title>a{color:inherit}.panel-footer{padding:10px 15px;background-color:#ecf0f1;border-top:1px solid #ecf0f1;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.list-group{margin-bottom:0}.panel>.list-group .list-group-item{border-width:1px 0;border-radius:0}.panel>.list-group:first-child .list-group-item:first-child{border-top:0;border-top-right-radius:3px;border-top-left-radius:3px}.panel>.list-group:last-child .list-group-item:last-child{border-bottom:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel-heading+.list-group .list-group-item:first-child{border-top-width:0}.panel>.table,.panel>.table-responsive>.table{margin-bottom:0}.panel>.table:first-child,.panel>.table-responsive:first-child>.table:first-child{border-top-right-radius:3px;border-top-left-radius:3px}.panel>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table:first-child>thead:first-child>tr:first-child th:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:first-child{border-top-left-radius:3px}.panel>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table:first-child>thead:first-child>tr:first-child th:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:last-child{border-top-right-radius:3px}.panel>.table:last-child,.panel>.table-responsive:last-child>.table:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:first-child{border-bottom-left-radius:3px}.panel>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:last-child{border-bottom-right-radius:3px}.panel>.panel-body+.table,.panel>.panel-body+.table-responsive{border-top:1px solid #ecf0f1}.panel>.table>tbody:first-child>tr:first-child th,.panel>.table>tbody:first-child>tr:first-child td{border-top:0}.panel>.table-bordered,.panel>.table-responsive>.table-bordered{border:0}.panel>.table-bordered>thead>tr>th:first-child,.panel>.table-responsive>.table-bordered>thead>tr>th:first-child,.panel>.table-bordered>tbody>tr>th:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:first-child,.panel>.table-bordered>tfoot>tr>th:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:first-child,.panel>.table-bordered>thead>tr>td:first-child,.panel>.table-responsive>.table-bordered>thead>tr>td:first-child,.panel>.table-bordered>tbody>tr>td:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:first-child,.panel>.table-bordered>tfoot>tr>td:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:first-child{border-left:0}.panel>.table-bordered>thead>tr>th:last-child,.panel>.table-responsive>.table-bordered>thead>tr>th:last-child,.panel>.table-bordered>tbody>tr>th:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:last-child,.panel>.table-bordered>tfoot>tr>th:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:last-child,.panel>.table-bordered>thead>tr>td:last-child,.panel>.table-responsive>.table-bordered>thead>tr>td:last-child,.panel>.table-bordered>tbody>tr>td:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:last-child,.panel>.table-bordered>tfoot>tr>td:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:last-child{border-right:0}.panel>.table-bordered>thead>tr:first-child>td,.panel>.table-responsive>.table-bordered>thead>tr:first-child>td,.panel>.table-bordered>tbody>tr:first-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>td,.panel>.table-bordered>thead>tr:first-child>th,.panel>.table-responsive>.table-bordered>thead>tr:first-child>th,.panel>.table-bordered>tbody>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>th{border-bottom:0}.panel>.table-bordered>tbody>tr:last-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>td,.panel>.table-bordered>tfoot>tr:last-child>td,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>td,.panel>.table-bordered>tbody>tr:last-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>th,.panel>.table-bordered>tfoot>tr:last-child>th,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}.panel>.table-responsive{border:0;margin-bottom:0}.panel-group{margin-bottom:21px}.panel-group .panel{margin-bottom:0;border-radius:4px;overflow:hidden}.panel-group .panel+.panel{margin-top:5px}.panel-group .panel-heading{border-bottom:0}.panel-group .panel-heading+.panel-collapse .panel-body{border-top:1px solid #ecf0f1}.panel-group .panel-footer{border-top:0}.panel-group .panel-footer+.panel-collapse .panel-body{border-bottom:1px solid #ecf0f1}.panel-default{border-color:#ecf0f1}.panel-default>.panel-heading{color:#2c3e50;background-color:#ecf0f1;border-color:#ecf0f1}.panel-default>.panel-heading+.panel-collapse .panel-body{border-top-color:#ecf0f1}.panel-default>.panel-footer+.panel-collapse .panel-body{border-bottom-color:#ecf0f1}.panel-primary{border-color:#2c3e50}.panel-primary>.panel-heading{color:#ffffff;background-color:#2c3e50;border-color:#2c3e50}.panel-primary>.panel-heading+.panel-collapse .panel-body{border-top-color:#2c3e50}.panel-primary>.panel-footer+.panel-collapse .panel-body{border-bottom-color:#2c3e50}.panel-success{border-color:#18bc9c}.panel-success>.panel-heading{color:#ffffff;background-color:#18bc9c;border-color:#18bc9c}.panel-success>.panel-heading+.panel-collapse .panel-body{border-top-color:#18bc9c}.panel-success>.panel-footer+.panel-collapse .panel-body{border-bottom-color:#18bc9c}.panel-info{border-color:#3498db}.panel-info>.panel-heading{color:#ffffff;background-color:#3498db;border-color:#3498db}.panel-info>.panel-heading+.panel-collapse .panel-body{border-top-color:#3498db}.panel-info>.panel-footer+.panel-collapse .panel-body{border-bottom-color:#3498db}.panel-warning{border-color:#f39c12}.panel-warning>.panel-heading{color:#ffffff;background-color:#f39c12;border-color:#f39c12}.panel-warning>.panel-heading+.panel-collapse .panel-body{border-top-color:#f39c12}.panel-warning>.panel-footer+.panel-collapse .panel-body{border-bottom-color:#f39c12}.panel-danger{border-color:#e74c3c}.panel-danger>.panel-heading{color:#ffffff;background-color:#e74c3c;border-color:#e74c3c}.panel-danger>.panel-heading+.panel-collapse .panel-body{border-top-color:#e74c3c}.panel-danger>.panel-footer+.panel-collapse .panel-body{border-bottom-color:#e74c3c}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#ecf0f1;border:1px solid transparent;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.05);box-shadow:inset 0 1px 1px rgba(0,0,0,0.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,0.15)}.well-lg{padding:24px;border-radius:6px}.well-sm{padding:9px;border-radius:3px}.close{float:right;font-size:22.5px;font-weight:bold;line-height:1;color:#000000;text-shadow:none;opacity:0.2;filter:alpha(opacity=20)}.close:hover,.close:focus{color:#000000;text-decoration:none;cursor:pointer;opacity:0.5;filter:alpha(opacity=50)}button.close{padding:0;cursor:pointer;background:transparent;border:0;-webkit-appearance:none}.modal-open{overflow:hidden}.modal{display:none;overflow:auto;overflow-y:scroll;position:fixed;top:0;right:0;bottom:0;left:0;z-index:1050;-webkit-overflow-scrolling:touch;outline:0}.modal.fade .modal-dialog{-webkit-transform:translate(0, -25%);-ms-transform:translate(0, -25%);transform:translate(0, -25%);-webkit-transition:-webkit-transform .3s ease-out;-moz-transition:-moz-transform .3s ease-out;-o-transition:-o-transform .3s ease-out;transition:transform .3s ease-out}.modal.in .modal-dialog{-webkit-transform:translate(0, 0);-ms-transform:translate(0, 0);transform:translate(0, 0)}.modal-dialog{position:relative;width:auto;margin:10px}.modal-content{position:relative;background-color:#ffffff;border:1px solid #999999;border:1px solid rgba(0,0,0,0.2);border-radius:6px;-webkit-box-shadow:0 3px 9px rgba(0,0,0,0.5);box-shadow:0 3px 9px rgba(0,0,0,0.5);background-clip:padding-box;outline:none}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000000}.modal-backdrop.fade{opacity:0;filter:alpha(opacity=0)}.modal-backdrop.in{opacity:0.5;filter:alpha(opacity=50)}.modal-header{padding:15px;border-bottom:1px solid #e5e5e5;min-height:16.42857143px}.modal-header .close{margin-top:-2px}.modal-title{margin:0;line-height:1.42857143}.modal-body{position:relative;padding:20px}.modal-footer{margin-top:15px;padding:19px 20px 20px;text-align:right;border-top:1px solid #e5e5e5}.modal-footer .btn+.btn{margin-left:5px;margin-bottom:0}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.modal-footer .btn-block+.btn-block{margin-left:0}@media (min-width:768px){.modal-dialog{width:600px;margin:30px auto}.modal-content{-webkit-box-shadow:0 5px 15px rgba(0,0,0,0.5);box-shadow:0 5px 15px rgba(0,0,0,0.5)}.modal-sm{width:300px}}@media (min-width:992px){.modal-lg{width:900px}}.tooltip{position:absolute;z-index:1030;display:block;visibility:visible;font-size:13px;line-height:1.4;opacity:0;filter:alpha(opacity=0)}.tooltip.in{opacity:0.9;filter:alpha(opacity=90)}.tooltip.top{margin-top:-3px;padding:5px 0}.tooltip.right{margin-left:3px;padding:0 5px}.tooltip.bottom{margin-top:3px;padding:5px 0}.tooltip.left{margin-left:-3px;padding:0 5px}.tooltip-inner{max-width:200px;padding:3px 8px;color:#ffffff;text-align:center;text-decoration:none;background-color:rgba(0,0,0,0.9);border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-width:5px 5px 0;border-top-color:rgba(0,0,0,0.9)}.tooltip.top-left .tooltip-arrow{bottom:0;left:5px;border-width:5px 5px 0;border-top-color:rgba(0,0,0,0.9)}.tooltip.top-right .tooltip-arrow{bottom:0;right:5px;border-width:5px 5px 0;border-top-color:rgba(0,0,0,0.9)}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-width:5px 5px 5px 0;border-right-color:rgba(0,0,0,0.9)}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-width:5px 0 5px 5px;border-left-color:rgba(0,0,0,0.9)}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-width:0 5px 5px;border-bottom-color:rgba(0,0,0,0.9)}.tooltip.bottom-left .tooltip-arrow{top:0;left:5px;border-width:0 5px 5px;border-bottom-color:rgba(0,0,0,0.9)}.tooltip.bottom-right .tooltip-arrow{top:0;right:5px;border-width:0 5px 5px;border-bottom-color:rgba(0,0,0,0.9)}.popover{position:absolute;top:0;left:0;z-index:1010;display:none;max-width:276px;padding:1px;text-align:left;background-color:#ffffff;background-clip:padding-box;border:1px solid #cccccc;border:1px solid rgba(0,0,0,0.2);border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,0.2);box-shadow:0 5px 10px rgba(0,0,0,0.2);white-space:normal}.popover.top{margin-top:-10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-left:-10px}.popover-title{margin:0;padding:8px 14px;font-size:15px;font-weight:normal;line-height:18px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-radius:5px 5px 0 0}.popover-content{padding:9px 14px}.popover>.arrow,.popover>.arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover>.arrow{border-width:11px}.popover>.arrow:after{border-width:10px;content:""}.popover.top>.arrow{left:50%;margin-left:-11px;border-bottom-width:0;border-top-color:#999999;border-top-color:rgba(0,0,0,0.25);bottom:-11px}.popover.top>.arrow:after{content:" ";bottom:1px;margin-left:-10px;border-bottom-width:0;border-top-color:#ffffff}.popover.right>.arrow{top:50%;left:-11px;margin-top:-11px;border-left-width:0;border-right-color:#999999;border-right-color:rgba(0,0,0,0.25)}.popover.right>.arrow:after{content:" ";left:1px;bottom:-10px;border-left-width:0;border-right-color:#ffffff}.popover.bottom>.arrow{left:50%;margin-left:-11px;border-top-width:0;border-bottom-color:#999999;border-bottom-color:rgba(0,0,0,0.25);top:-11px}.popover.bottom>.arrow:after{content:" ";top:1px;margin-left:-10px;border-top-width:0;border-bottom-color:#ffffff}.popover.left>.arrow{top:50%;right:-11px;margin-top:-11px;border-right-width:0;border-left-color:#999999;border-left-color:rgba(0,0,0,0.25)}.popover.left>.arrow:after{content:" ";right:1px;border-right-width:0;border-left-color:#ffffff;bottom:-10px}.carousel{position:relative}.carousel-inner{position:relative;overflow:hidden;width:100%}.carousel-inner>.item{display:none;position:relative;-webkit-transition:.6s ease-in-out left;transition:.6s ease-in-out left}.carousel-inner>.item>img,.carousel-inner>.item>a>img{line-height:1}.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block}.carousel-inner>.active{left:0}.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%}.carousel-inner>.next{left:100%}.carousel-inner>.prev{left:-100%}.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0}.carousel-inner>.active.left{left:-100%}.carousel-inner>.active.right{left:100%}.carousel-control{position:absolute;top:0;left:0;bottom:0;width:15%;opacity:0.5;filter:alpha(opacity=50);font-size:20px;color:#ffffff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,0.6)}.carousel-control.left{background-image:-webkit-linear-gradient(left, color-stop(rgba(0,0,0,0.5) 0), color-stop(rgba(0,0,0,0.0001) 100%));background-image:linear-gradient(to right, rgba(0,0,0,0.5) 0, rgba(0,0,0,0.0001) 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#80000000', endColorstr='#00000000', GradientType=1)}.carousel-control.right{left:auto;right:0;background-image:-webkit-linear-gradient(left, color-stop(rgba(0,0,0,0.0001) 0), color-stop(rgba(0,0,0,0.5) 100%));background-image:linear-gradient(to right, rgba(0,0,0,0.0001) 0, rgba(0,0,0,0.5) 100%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#00000000', endColorstr='#80000000', GradientType=1)}.carousel-control:hover,.carousel-control:focus{outline:none;color:#ffffff;text-decoration:none;opacity:0.9;filter:alpha(opacity=90)}.carousel-control .icon-prev,.carousel-control .icon-next,.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right{position:absolute;top:50%;z-index:5;display:inline-block}.carousel-control .icon-prev,.carousel-control .glyphicon-chevron-left{left:50%}.carousel-control .icon-next,.carousel-control .glyphicon-chevron-right{right:50%}.carousel-control .icon-prev,.carousel-control .icon-next{width:20px;height:20px;margin-top:-10px;margin-left:-10px;font-family:serif}.carousel-control .icon-prev:before{content:'\2039'}.carousel-control .icon-next:before{content:'\203a'}.carousel-indicators{position:absolute;bottom:10px;left:50%;z-index:15;width:60%;margin-left:-30%;padding-left:0;list-style:none;text-align:center}.carousel-indicators li{display:inline-block;width:10px;height:10px;margin:1px;text-indent:-999px;border:1px solid #ffffff;border-radius:10px;cursor:pointer;background-color:#000 \9;background-color:rgba(0,0,0,0)}.carousel-indicators .active{margin:0;width:12px;height:12px;background-color:#ffffff}.carousel-caption{position:absolute;left:15%;right:15%;bottom:20px;z-index:10;padding-top:20px;padding-bottom:20px;color:#ffffff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,0.6)}.carousel-caption .btn{text-shadow:none}@media screen and (min-width:768px){.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-prev,.carousel-control .icon-next{width:30px;height:30px;margin-top:-15px;margin-left:-15px;font-size:30px}.carousel-caption{left:20%;right:20%;padding-bottom:30px}.carousel-indicators{bottom:20px}}.clearfix:before,.clearfix:after,.container:before,.container:after,.container-fluid:before,.container-fluid:after,.row:before,.row:after,.form-horizontal .form-group:before,.form-horizontal .form-group:after,.btn-toolbar:before,.btn-toolbar:after,.btn-group-vertical>.btn-group:before,.btn-group-vertical>.btn-group:after,.nav:before,.nav:after,.navbar:before,.navbar:after,.navbar-header:before,.navbar-header:after,.navbar-collapse:before,.navbar-collapse:after,.pager:before,.pager:after,.panel-body:before,.panel-body:after,.modal-footer:before,.modal-footer:after{content:" ";display:table}.clearfix:after,.container:after,.container-fluid:after,.row:after,.form-horizontal .form-group:after,.btn-toolbar:after,.btn-group-vertical>.btn-group:after,.nav:after,.navbar:after,.navbar-header:after,.navbar-collapse:after,.pager:after,.panel-body:after,.modal-footer:after{clear:both}.center-block{display:block;margin-left:auto;margin-right:auto}.pull-right{float:right !important}.pull-left{float:left !important}.hide{display:none !important}.show{display:block !important}.invisible{visibility:hidden}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.hidden{display:none !important;visibility:hidden !important}.affix{position:fixed}@-ms-viewport{width:device-width}.visible-xs,.visible-sm,.visible-md,.visible-lg{display:none !important}@media (max-width:767px){.visible-xs{display:block !important}table.visible-xs{display:table}tr.visible-xs{display:table-row !important}th.visible-xs,td.visible-xs{display:table-cell !important}}@media (min-width:768px) and (max-width:991px){.visible-sm{display:block !important}table.visible-sm{display:table}tr.visible-sm{display:table-row !important}th.visible-sm,td.visible-sm{display:table-cell !important}}@media (min-width:992px) and (max-width:1199px){.visible-md{display:block !important}table.visible-md{display:table}tr.visible-md{display:table-row !important}th.visible-md,td.visible-md{display:table-cell !important}}@media (min-width:1200px){.visible-lg{display:block !important}table.visible-lg{display:table}tr.visible-lg{display:table-row !important}th.visible-lg,td.visible-lg{display:table-cell !important}}@media (max-width:767px){.hidden-xs{display:none !important}}@media (min-width:768px) and (max-width:991px){.hidden-sm{display:none !important}}@media (min-width:992px) and (max-width:1199px){.hidden-md{display:none !important}}@media (min-width:1200px){.hidden-lg{display:none !important}}.visible-print{display:none !important}@media print{.visible-print{display:block !important}table.visible-print{display:table}tr.visible-print{display:table-row !important}th.visible-print,td.visible-print{display:table-cell !important}}@media print{.hidden-print{display:none !important}}.navbar{border-width:0}.navbar-default .badge{background-color:#fff;color:#2c3e50}.navbar-inverse .badge{background-color:#fff;color:#18bc9c}.navbar-brand{padding:18.5px 15px 20.5px}.btn:active{-webkit-box-shadow:none;box-shadow:none}.btn-group.open .dropdown-toggle{-webkit-box-shadow:none;box-shadow:none}.text-primary,.text-primary:hover{color:#2c3e50}.text-success,.text-success:hover{color:#18bc9c}.text-danger,.text-danger:hover{color:#e74c3c}.text-warning,.text-warning:hover{color:#f39c12}.text-info,.text-info:hover{color:#3498db}table a,.table a{text-decoration:underline}table .success,.table .success,table .warning,.table .warning,table .danger,.table .danger,table .info,.table .info{color:#fff}table .success a,.table .success a,table .warning a,.table .warning a,table .danger a,.table .danger a,table .info a,.table .info a{color:#fff}table>thead>tr>th,.table>thead>tr>th,table>tbody>tr>th,.table>tbody>tr>th,table>tfoot>tr>th,.table>tfoot>tr>th,table>thead>tr>td,.table>thead>tr>td,table>tbody>tr>td,.table>tbody>tr>td,table>tfoot>tr>td,.table>tfoot>tr>td{border:none}table-bordered>thead>tr>th,.table-bordered>thead>tr>th,table-bordered>tbody>tr>th,.table-bordered>tbody>tr>th,table-bordered>tfoot>tr>th,.table-bordered>tfoot>tr>th,table-bordered>thead>tr>td,.table-bordered>thead>tr>td,table-bordered>tbody>tr>td,.table-bordered>tbody>tr>td,table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>td{border:1px solid #ecf0f1}.form-control,input{border-width:2px;-webkit-box-shadow:none;box-shadow:none}.form-control:focus,input:focus{-webkit-box-shadow:none;box-shadow:none}.has-warning .help-block,.has-warning .control-label,.has-warning .form-control-feedback{color:#f39c12}.has-warning .form-control,.has-warning .form-control:focus{border:2px solid #f39c12}.has-error .help-block,.has-error .control-label,.has-error .form-control-feedback{color:#e74c3c}.has-error .form-control,.has-error .form-control:focus{border:2px solid #e74c3c}.has-success .help-block,.has-success .control-label,.has-success .form-control-feedback{color:#18bc9c}.has-success .form-control,.has-success .form-control:focus{border:2px solid #18bc9c}.nav .open>a,.nav .open>a:hover,.nav .open>a:focus{border-color:transparent}.pager a,.pager a:hover{color:#fff}.pager .disabled>a,.pager .disabled>a:hover,.pager .disabled>a:focus,.pager .disabled>span{background-color:#3be6c4}.alert a,.alert .alert-link{color:#fff;text-decoration:underline}.alert .close{color:#fff;text-decoration:none;opacity:0.4}.alert .close:hover,.alert .close:focus{color:#fff;opacity:1}.progress{height:10px;-webkit-box-shadow:none;box-shadow:none}.progress .progress-bar{font-size:10px;line-height:10px}.well{-webkit-box-shadow:none;box-shadow:none}
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/README.md b/vendor/github.com/google/cayley/static/third_party/sigmajs/README.md
new file mode 100644
index 00000000..94c0f63a
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/README.md
@@ -0,0 +1,35 @@
+[![Build Status](https://travis-ci.org/jacomyal/sigma.js.png)](https://travis-ci.org/jacomyal/sigma.js)
+
+sigma.js - v1.0.2
+=================
+
+Sigma is a JavaScript library dedicated to graph drawing.
+
+### Resources
+
+[The website](http://sigmajs.org) provides a global overview of the project, and the documentation is available in the [Github Wiki](https://github.com/jacomyal/sigma.js/wiki).
+
+Also, the `plugins` and `examples` directories contain some various use-cases, that might help you understanding how to use sigma.
+
+### How to use it
+
+To use it, clone the repository:
+
+```
+git clone git@github.com:jacomyal/sigma.js.git
+```
+
+To build the code:
+
+ - Install [Node.js](http://nodejs.org/).
+ - Install [gjslint](https://developers.google.com/closure/utilities/docs/linter_howto?hl=en).
+ - Use `npm install` to install sigma development dependencies.
+ - Use `npm run build` to minify the code with [Uglify](https://github.com/mishoo/UglifyJS). The minified file `sigma.min.js` will then be accessible in the `build/` folder.
+
+Also, you can customize the build by adding or removing files from the `coreJsFiles` array in `Gruntfile.js` before applying the grunt task.
+
+### Contributing
+
+You can contribute by submitting [issues tickets](http://github.com/jacomyal/sigma.js/issues) and proposing [pull requests](http://github.com/jacomyal/sigma.js/pulls). Make sure that tests and linting pass before submitting any pull request by running the command `grunt`.
+
+The whole source code is validated by the [Google Closure Linter](https://developers.google.com/closure/utilities/) and [JSHint](http://www.jshint.com/), and the comments are written in [JSDoc](http://en.wikipedia.org/wiki/JSDoc) (tags description is available [here](https://developers.google.com/closure/compiler/docs/js-for-compiler)).
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.layout.forceAtlas2.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.layout.forceAtlas2.min.js
new file mode 100644
index 00000000..ee7ad784
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.layout.forceAtlas2.min.js
@@ -0,0 +1 @@
+!function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";var a=sigma.utils.pkg("sigma.layout.forceatlas2");a.ForceAtlas2=function(b,c){var d=this;this.graph=b,this.p=sigma.utils.extend(c||{},a.defaultSettings),this.state={step:0,index:0},this.init=function(){return d.state={step:0,index:0},d.graph.nodes().forEach(function(a){a.fa2={mass:1+d.graph.degree(a.id),old_dx:0,old_dy:0,dx:0,dy:0}}),d},this.go=function(){for(;d.atomicGo(););},this.atomicGo=function(){var b,c,e,f,g,h,i,j=d.graph,k=j.nodes,l=j.edges,m=k(),n=l(),o=d.p.complexIntervals,p=d.p.simpleIntervals;switch(d.state.step){case 0:for(b=0,f=m.length;f>b;b++)c=m[b],c.fa2=c.fa2?{mass:1+d.graph.degree(c.id),old_dx:c.fa2.dx||0,old_dy:c.fa2.dy||0,dx:0,dy:0}:{mass:1+d.graph.degree(c.id),old_dx:0,old_dy:0,dx:0,dy:0};if(d.p.barnesHutOptimize&&(d.rootRegion=new a.Region(m,0),d.rootRegion.buildSubRegions()),d.p.outboundAttractionDistribution){for(d.p.outboundAttCompensation=0,b=0,f=m.length;f>b;b++)c=m[b],d.p.outboundAttCompensation+=c.fa2.mass;d.p.outboundAttCompensation/=m.length}return d.state.step=1,d.state.index=0,!0;case 1:var q,r,s,t,u,v,w=d.ForceFactory.buildRepulsion(d.p.adjustSizes,d.p.scalingRatio);if(d.p.barnesHutOptimize){for(u=d.rootRegion,v=d.p.barnesHutTheta,b=d.state.index;b<m.length&&b<d.state.index+o;)(c=m[b++]).fa2&&u.applyForce(c,w,v);b===m.length?d.state={step:2,index:0}:d.state.index=b}else{for(s=d.state.index;s<m.length&&s<d.state.index+o;)if((q=m[s++]).fa2)for(t=0;s>t;t++)(r=m[t]).fa2&&w.apply_nn(q,r);s===m.length?d.state={step:2,index:0}:d.state.index=s}return!0;case 2:var x=d.p.strongGravityMode?d.ForceFactory.getStrongGravity(d.p.scalingRatio):d.ForceFactory.buildRepulsion(d.p.adjustSizes,d.p.scalingRatio),y=d.p.gravity,z=d.p.scalingRatio;for(b=d.state.index;b<m.length&&b<d.state.index+p;)c=m[b++],c.fa2&&x.apply_g(c,y/z);return b===m.length?d.state={step:3,index:0}:d.state.index=b,!0;case 3:var A=d.ForceFactory.buildAttraction(d.p.linLogMode,d.p.outboundAttractionDistribution,d.p.adjustSizes,d.p.outboundAttractionDistribution?d.p.outboundAttCompensation:1);if(b=d.state.index,0===d.p.edgeWeightInfluence)for(;b<n.length&&b<d.state.index+o;)e=n[b++],A.apply_nn(k(e.source),k(e.target),1);else if(1===d.p.edgeWeightInfluence)for(;b<n.length&&b<d.state.index+o;)e=n[b++],A.apply_nn(k(e.source),k(e.target),e.weight||1);else for(;b<n.length&&b<d.state.index+o;)e=n[b++],A.apply_nn(k(e.source),k(e.target),Math.pow(e.weight||1,d.p.edgeWeightInfluence));return b===n.length?d.state={step:4,index:0}:d.state.index=b,!0;case 4:var B,C,D=0,E=0;for(b=0,f=m.length;f>b;b++)c=m[b],g=c.fixed||!1,!g&&c.fa2&&(h=Math.sqrt(Math.pow(c.fa2.old_dx-c.fa2.dx,2)+Math.pow(c.fa2.old_dy-c.fa2.dy,2)),D+=c.fa2.mass*h,E+=.5*c.fa2.mass*Math.sqrt(Math.pow(c.fa2.old_dx+c.fa2.dx,2)+Math.pow(c.fa2.old_dy+c.fa2.dy,2)));for(d.p.totalSwinging=D,d.p.totalEffectiveTraction=E,C=Math.pow(d.p.jitterTolerance,2)*d.p.totalEffectiveTraction/d.p.totalSwinging,B=.5,d.p.speed=d.p.speed+Math.min(C-d.p.speed,B*d.p.speed),b=0,f=m.length;f>b;b++)c=m[b],c.old_x=+c.x,c.old_y=+c.y;return d.state.step=5,!0;case 5:var F,G;if(b=d.state.index,d.p.adjustSizes)for(G=d.p.speed;b<m.length&&b<d.state.index+p;)c=m[b++],g=c.fixed||!1,!g&&c.fa2&&(h=Math.sqrt((c.fa2.old_dx-c.fa2.dx)*(c.fa2.old_dx-c.fa2.dx)+(c.fa2.old_dy-c.fa2.dy)*(c.fa2.old_dy-c.fa2.dy)),i=.1*G/(1+G*Math.sqrt(h)),F=Math.sqrt(Math.pow(c.fa2.dx,2)+Math.pow(c.fa2.dy,2)),i=Math.min(i*F,10)/F,c.x+=c.fa2.dx*i,c.y+=c.fa2.dy*i);else for(G=d.p.speed;b<m.length&&b<d.state.index+p;)c=m[b++],g=c.fixed||!1,!g&&c.fa2&&(h=Math.sqrt((c.fa2.old_dx-c.fa2.dx)*(c.fa2.old_dx-c.fa2.dx)+(c.fa2.old_dy-c.fa2.dy)*(c.fa2.old_dy-c.fa2.dy)),i=G/(1+G*Math.sqrt(h)),c.x+=c.fa2.dx*i,c.y+=c.fa2.dy*i);return b===m.length?(d.state={step:0,index:0},!1):(d.state.index=b,!0);default:throw new Error("ForceAtlas2 - atomic state error")}},this.clean=function(){var a,b=this.graph.nodes(),c=b.length;for(a=0;c>a;a++)delete b[a].fa2},this.setAutoSettings=function(){var a=this.graph;return this.p.scalingRatio=a.nodes().length>=100?2:10,this.p.strongGravityMode=!1,this.p.gravity=1,this.p.outboundAttractionDistribution=!1,this.p.linLogMode=!1,this.p.adjustSizes=!1,this.p.edgeWeightInfluence=1,this.p.jitterTolerance=a.nodes().length>=5e4?10:a.nodes().length>=5e3?1:.1,this.p.barnesHutOptimize=a.nodes().length>=1e3?!0:!1,this.p.barnesHutTheta=1.2,this},this.kill=function(){},this.ForceFactory={buildRepulsion:function(a,b){return a?new this.linRepulsion_antiCollision(b):new this.linRepulsion(b)},getStrongGravity:function(a){return new this.strongGravity(a)},buildAttraction:function(a,b,c,d){return c?a?b?new this.logAttraction_degreeDistributed_antiCollision(d):new this.logAttraction_antiCollision(d):b?new this.linAttraction_degreeDistributed_antiCollision(d):new this.linAttraction_antiCollision(d):a?b?new this.logAttraction_degreeDistributed(d):new this.logAttraction(d):b?new this.linAttraction_massDistributed(d):new this.linAttraction(d)},linRepulsion:function(a){this.coefficient=a,this.apply_nn=function(a,b){if(a.fa2&&b.fa2){var c=a.x-b.x,d=a.y-b.y,e=Math.sqrt(c*c+d*d);if(e>0){var f=this.coefficient*a.fa2.mass*b.fa2.mass/Math.pow(e,2);a.fa2.dx+=c*f,a.fa2.dy+=d*f,b.fa2.dx-=c*f,b.fa2.dy-=d*f}}},this.apply_nr=function(a,b){var c=a.x-b.p.massCenterX,d=a.y-b.p.massCenterY,e=Math.sqrt(c*c+d*d);if(e>0){var f=this.coefficient*a.fa2.mass*b.p.mass/Math.pow(e,2);a.fa2.dx+=c*f,a.fa2.dy+=d*f}},this.apply_g=function(a,b){var c=a.x,d=a.y,e=Math.sqrt(c*c+d*d);if(e>0){var f=this.coefficient*a.fa2.mass*b/e;a.fa2.dx-=c*f,a.fa2.dy-=d*f}}},linRepulsion_antiCollision:function(a){this.coefficient=a,this.apply_nn=function(a,b){var c;if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e)-a.size-b.size;f>0?(c=this.coefficient*a.fa2.mass*b.fa2.mass/Math.pow(f,2),a.fa2.dx+=d*c,a.fa2.dy+=e*c,b.fa2.dx-=d*c,b.fa2.dy-=e*c):0>f&&(c=100*this.coefficient*a.fa2.mass*b.fa2.mass,a.fa2.dx+=d*c,a.fa2.dy+=e*c,b.fa2.dx-=d*c,b.fa2.dy-=e*c)}},this.apply_nr=function(a,b){var c,d=a.fa2.x()-b.getMassCenterX(),e=a.fa2.y()-b.getMassCenterY(),f=Math.sqrt(d*d+e*e);f>0?(c=this.coefficient*a.fa2.mass*b.getMass()/Math.pow(f,2),a.fa2.dx+=d*c,a.fa2.dy+=e*c):0>f&&(c=-this.coefficient*a.fa2.mass*b.getMass()/f,a.fa2.dx+=d*c,a.fa2.dy+=e*c)},this.apply_g=function(a,b){var c=a.x,d=a.y,e=Math.sqrt(c*c+d*d);if(e>0){var f=this.coefficient*a.fa2.mass*b/e;a.fa2.dx-=c*f,a.fa2.dy-=d*f}}},strongGravity:function(a){this.coefficient=a,this.apply_nn=function(){},this.apply_nr=function(){},this.apply_g=function(a,b){var c=a.x,d=a.y,e=Math.sqrt(c*c+d*d);if(e>0){var f=this.coefficient*a.fa2.mass*b;a.fa2.dx-=c*f,a.fa2.dy-=d*f}}},linAttraction:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=-this.coefficient*c;a.fa2.dx+=d*f,a.fa2.dy+=e*f,b.fa2.dx-=d*f,b.fa2.dy-=e*f}}},linAttraction_massDistributed:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=-this.coefficient*c/a.fa2.mass;a.fa2.dx+=d*f,a.fa2.dy+=e*f,b.fa2.dx-=d*f,b.fa2.dy-=e*f}}},logAttraction:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e);if(f>0){var g=-this.coefficient*c*Math.log(1+f)/f;a.fa2.dx+=d*g,a.fa2.dy+=e*g,b.fa2.dx-=d*g,b.fa2.dy-=e*g}}}},logAttraction_degreeDistributed:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e);if(f>0){var g=-this.coefficient*c*Math.log(1+f)/f/a.fa2.mass;a.fa2.dx+=d*g,a.fa2.dy+=e*g,b.fa2.dx-=d*g,b.fa2.dy-=e*g}}}},linAttraction_antiCollision:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e);if(f>0){var g=-this.coefficient*c;a.fa2.dx+=d*g,a.fa2.dy+=e*g,b.fa2.dx-=d*g,b.fa2.dy-=e*g}}}},linAttraction_degreeDistributed_antiCollision:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e);if(f>0){var g=-this.coefficient*c/a.fa2.mass;a.fa2.dx+=d*g,a.fa2.dy+=e*g,b.fa2.dx-=d*g,b.fa2.dy-=e*g}}}},logAttraction_antiCollision:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e);if(f>0){var g=-this.coefficient*c*Math.log(1+f)/f;a.fa2.dx+=d*g,a.fa2.dy+=e*g,b.fa2.dx-=d*g,b.fa2.dy-=e*g}}}},logAttraction_degreeDistributed_antiCollision:function(a){this.coefficient=a,this.apply_nn=function(a,b,c){if(a.fa2&&b.fa2){var d=a.x-b.x,e=a.y-b.y,f=Math.sqrt(d*d+e*e);if(f>0){var g=-this.coefficient*c*Math.log(1+f)/f/a.fa2.mass;a.fa2.dx+=d*g,a.fa2.dy+=e*g,b.fa2.dx-=d*g,b.fa2.dy-=e*g}}}}}},a.Region=function(a,b){this.depthLimit=20,this.size=0,this.nodes=a,this.subregions=[],this.depth=b,this.p={mass:0,massCenterX:0,massCenterY:0},this.updateMassAndGeometry()},a.Region.prototype.updateMassAndGeometry=function(){if(this.nodes.length>1){var a=0,b=0,c=0;this.nodes.forEach(function(d){a+=d.fa2.mass,b+=d.x*d.fa2.mass,c+=d.y*d.fa2.mass});var d,e=b/a,f=c/a;this.nodes.forEach(function(a){var b=Math.sqrt((a.x-e)*(a.x-e)+(a.y-f)*(a.y-f));d=Math.max(d||2*b,2*b)}),this.p.mass=a,this.p.massCenterX=e,this.p.massCenterY=f,this.size=d}},a.Region.prototype.buildSubRegions=function(){if(this.nodes.length>1){var b,c,d,e,f=[],g=[],h=[],i=this.p.massCenterX,j=this.p.massCenterY,k=this.depth+1,l=this,m=[],n=[],o=[],p=[];this.nodes.forEach(function(a){b=a.x<i?f:g,b.push(a)}),f.forEach(function(a){c=a.y<j?m:n,c.push(a)}),g.forEach(function(a){c=a.y<j?p:o,c.push(a)}),[m,n,o,p].filter(function(a){return a.length}).forEach(function(b){k<=l.depthLimit&&b.length<l.nodes.length?(e=new a.Region(b,k),h.push(e)):b.forEach(function(b){d=[b],e=new a.Region(d,k),h.push(e)})}),this.subregions=h,h.forEach(function(a){a.buildSubRegions()})}},a.Region.prototype.applyForce=function(a,b,c){if(this.nodes.length<2){var d=this.nodes[0];b.apply_nn(a,d)}else{var e=Math.sqrt((a.x-this.p.massCenterX)*(a.x-this.p.massCenterX)+(a.y-this.p.massCenterY)*(a.y-this.p.massCenterY));e*c>this.size?b.apply_nr(a,this):this.subregions.forEach(function(d){d.applyForce(a,b,c)})}},sigma.prototype.startForceAtlas2=function(b){function c(){conrad.hasJob("forceatlas2_"+d.id)||conrad.addJob({id:"forceatlas2_"+d.id,job:d.forceatlas2.atomicGo,end:function(){d.refresh(),d.forceatlas2.isRunning&&c()}})}if((this.forceatlas2||{}).isRunning)return this;this.forceatlas2||(this.forceatlas2=new a.ForceAtlas2(this.graph,b||{}),this.forceatlas2.p.autoSettings&&this.forceatlas2.setAutoSettings(),this.forceatlas2.init()),this.forceatlas2.isRunning=!0;var d=this;return c(),this},sigma.prototype.stopForceAtlas2=function(){return(this.forceatlas2||{}).isRunning&&(this.forceatlas2.state={step:0,index:0},this.forceatlas2.isRunning=!1,this.forceatlas2.clean()),conrad.hasJob("forceatlas2_"+this.id)&&conrad.killJob("forceatlas2_"+this.id),this},a.defaultSettings={autoSettings:!0,linLogMode:!1,outboundAttractionDistribution:!1,adjustSizes:!1,edgeWeightInfluence:0,scalingRatio:1,strongGravityMode:!1,gravity:1,jitterTolerance:1,barnesHutOptimize:!1,barnesHutTheta:1.2,speed:1,outboundAttCompensation:1,totalSwinging:0,totalEffectiveTraction:0,complexIntervals:500,simpleIntervals:1e3}}();
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.parsers.gexf.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.parsers.gexf.min.js
new file mode 100644
index 00000000..4a915b6c
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.parsers.gexf.min.js
@@ -0,0 +1 @@
+(function(a){"use strict";function b(a){var b={id:a.id,label:a.label};return a.viz&&(b.viz=a.viz),a.attributes&&(b.attributes=a.attributes),b}function c(a){var b={id:a.id,type:a.type||"undirected",label:a.label||"",source:a.source,target:a.target,weight:+a.weight||1};return a.viz&&(b.viz=a.viz),a.attributes&&(b.attributes=a.attributes),b}function d(a){function d(){var a={};return l.els.meta?(a.lastmodifieddate=l.els.meta.getAttribute("lastmodifieddate"),h.nodeListEach(l.els.meta.childNodes,function(b){a[b.tagName.toLowerCase()]=b.textContent}),a):a}function e(a){var b=[];return l.els.model[a]&&h.nodeListEach(l.els.model[a],function(a){var c={id:a.getAttribute("id")||a.getAttribute("for"),type:a.getAttribute("type")||"string",title:a.getAttribute("title")||""},d=h.nodeListToArray(a.childNodes);d.length>0&&(c.defaultValue=d[0].textContent),b.push(c)}),b.length>0?b:!1}function f(a,b){var c={},d=b.getElementsByTagName("attvalue"),e=h.nodeListToHash(d,function(a){var b=h.namedNodeMapToObject(a.attributes),c=b.id||b["for"];return{key:c,value:b.value}});return a.map(function(a){var b=a.title.toLowerCase();c[b]=!(a.id in e)&&"defaultValue"in a?h.enforceType(a.type,a.defaultValue):h.enforceType(a.type,e[a.id])}),c}function g(a){var c=[];return h.nodeListEach(l.els.nodes,function(d){var e={id:d.getAttribute("id"),label:d.getAttribute("label")||""};a&&(e.attributes=f(a,d)),l.hasViz&&(e.viz=i(d)),c.push(b(e))}),c}function i(a){var b={},c=h.getFirstElementByTagNS(a,"viz","color");if(c){var d=["r","g","b","a"].map(function(a){return c.getAttribute(a)});b.color=h.getRGB(d)}var e=h.getFirstElementByTagNS(a,"viz","position");e&&(b.position={},["x","y","z"].map(function(a){b.position[a]=+e.getAttribute(a)}));var f=h.getFirstElementByTagNS(a,"viz","size");f&&(b.size=+f.getAttribute("value"));var g=h.getFirstElementByTagNS(a,"viz","shape");return g&&(b.shape=g.getAttribute("value")),b}function j(a,b){var d=[];return h.nodeListEach(l.els.edges,function(e){var g=h.namedNodeMapToObject(e.attributes);"type"in g||(g.type=b),a&&(g.attributes=f(a,e)),l.hasViz&&(g.viz=k(e)),d.push(c(g))}),d}function k(a){var b={},c=h.getFirstElementByTagNS(a,"viz","color");if(c){var d=["r","g","b","a"].map(function(a){return c.getAttribute(a)});b.color=h.getRGB(d)}var e=h.getFirstElementByTagNS(a,"viz","shape");e&&(b.shape=e.getAttribute("value"));var f=h.getFirstElementByTagNS(a,"viz","thickness");return f&&(b.thickness=+f.getAttribute("value")),b}var l={};l.els={root:a.getElementsByTagName("gexf")[0],graph:a.getElementsByTagName("graph")[0],meta:a.getElementsByTagName("meta")[0],nodes:a.getElementsByTagName("node"),edges:a.getElementsByTagName("edge"),model:h.getModelTags(a)},l.hasViz=!!h.getAttributeNS(l.els.root,"xmlns","viz"),l.version=l.els.root.getAttribute("version")||"1.0",l.mode=l.els.graph.getAttribute("mode")||"static";var m=l.els.graph.getAttribute("defaultedgetype");l.defaultEdgetype=m||"undirected";var n=e("node"),o=e("edge"),p={version:l.version,mode:l.mode,defaultEdgeType:l.defaultEdgetype,meta:d(),model:{},nodes:g(n),edges:j(o,l.defaultEdgetype)};return n&&(p.model.node=n),o&&(p.model.edge=o),p}function e(a,b){var c=function(){if(window.XMLHttpRequest)return new XMLHttpRequest;var a,b;if(window.ActiveXObject){a=["Msxml2.XMLHTTP.6.0","Msxml2.XMLHTTP.3.0","Msxml2.XMLHTTP","Microsoft.XMLHTTP"];for(b in a)try{return new ActiveXObject(a[b])}catch(c){}}return null}();if(!c)throw"XMLHttpRequest not supported, cannot load the file.";var d,e="function"==typeof b;return c.overrideMimeType?(c.overrideMimeType("text/xml"),d=function(a){return a.responseXML}):d=function(a){var b=new DOMParser;return b.parseFromString(a.responseText,"application/xml")},c.open("GET",a,e),e&&(c.onreadystatechange=function(){4===c.readyState&&b(d(c))}),c.send(),e?c:d(c)}function f(a){return d(a)}function g(a,b){return"function"==typeof b?e(a,function(a){b(d(a))}):d(e(a))}var h={getModelTags:function(a){var b,c=a.getElementsByTagName("attributes"),d={},e=c.length;for(b=0;e>b;b++)d[c[b].getAttribute("class")]=c[b].childNodes;return d},nodeListToArray:function(a){for(var b=[],c=0,d=a.length;d>c;++c)"#text"!==a[c].nodeName&&b.push(a[c]);return b},nodeListEach:function(a,b){for(var c=0,d=a.length;d>c;++c)"#text"!==a[c].nodeName&&b(a[c])},nodeListToHash:function(a,b){for(var c={},d=0;d<a.length;d++)if("#text"!==a[d].nodeName){var e=b(a[d]);c[e.key]=e.value}return c},namedNodeMapToObject:function(a){for(var b={},c=0;c<a.length;c++)b[a[c].name]=a[c].value;return b},getFirstElementByTagNS:function(a,b,c){var d=a.getElementsByTagName(b+":"+c)[0];return d||(d=a.getElementsByTagNameNS(b,c)[0]),d||(d=a.getElementsByTagName(c)[0]),d},getAttributeNS:function(b,c,d){var e=b.getAttribute(c+":"+d);return e===a&&(e=b.getAttributeNS(c,d)),e===a&&(e=b.getAttribute(d)),e},enforceType:function(a,b){switch(a){case"boolean":b="true"===b;break;case"integer":case"long":case"float":case"double":b=+b}return b},getRGB:function(a){return a[3]?"rgba("+a.join(",")+")":"rgb("+a.slice(0,-1).join(",")+")"}};if("undefined"!=typeof this.gexf)throw'gexf: error - a variable called "gexf" already exists in the global scope';this.gexf={parse:f,fetch:g,version:"0.1.1"},"undefined"!=typeof exports&&this.exports!==exports&&(module.exports=this.gexf)}).call(this),function(){"use strict";function a(){return"e"+b++}if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.parsers");var b=0;sigma.parsers.gexf=function(b,c,d){function e(b){for(h=b.nodes,f=0,g=h.length;g>f;f++)i=h[f],i.id=i.id,i.viz&&"object"==typeof i.viz&&(i.viz.position&&"object"==typeof i.viz.position&&(i.x=i.viz.position.x,i.y=i.viz.position.y),i.size=i.viz.size,i.color=i.viz.color);for(h=b.edges,f=0,g=h.length;g>f;f++)i=h[f],i.id="string"==typeof i.id?i.id:a(),i.source=""+i.source,i.target=""+i.target,i.viz&&"object"==typeof i.viz&&(i.color=i.viz.color,i.size=i.viz.thickness),i.size=i.weight;if(c instanceof sigma){for(c.graph.clear(),h=b.nodes,f=0,g=h.length;g>f;f++)c.graph.addNode(h[f]);for(h=b.edges,f=0,g=h.length;g>f;f++)c.graph.addEdge(h[f])}else"object"==typeof c?(c.graph=b,c=new sigma(c)):"function"==typeof c&&(d=c,c=null);return d?void d(c||b):b}var f,g,h,i;if("string"==typeof b)gexf.fetch(b,e);else if("object"==typeof b)return e(gexf.parse(b))}}.call(this);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.parsers.json.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.parsers.json.min.js
new file mode 100644
index 00000000..f3de1652
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.parsers.json.min.js
@@ -0,0 +1 @@
+(function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.parsers"),sigma.utils.pkg("sigma.utils"),sigma.utils.xhr=function(){if(window.XMLHttpRequest)return new XMLHttpRequest;var a,b;if(window.ActiveXObject){a=["Msxml2.XMLHTTP.6.0","Msxml2.XMLHTTP.3.0","Msxml2.XMLHTTP","Microsoft.XMLHTTP"];for(b in a)try{return new ActiveXObject(a[b])}catch(c){}}return null},sigma.parsers.json=function(a,b,c){var d,e=sigma.utils.xhr();if(!e)throw"XMLHttpRequest not supported, cannot load the file.";e.open("GET",a,!0),e.onreadystatechange=function(){4===e.readyState&&(d=JSON.parse(e.responseText),b instanceof sigma?(b.graph.clear(),b.graph.read(d)):"object"==typeof b?(b.graph=d,b=new sigma(b)):"function"==typeof b&&(c=b,b=null),c&&c(b||d))},e.send()}}).call(this);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.animate.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.animate.min.js
new file mode 100644
index 00000000..370d86f4
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.animate.min.js
@@ -0,0 +1 @@
+(function(){"use strict";function a(a){if(d[a])return d[a];var b=[0,0,0];return a.match(/^#/)?(a=(a||"").replace(/^#/,""),b=3===a.length?[parseInt(a.charAt(0)+a.charAt(0),16),parseInt(a.charAt(1)+a.charAt(1),16),parseInt(a.charAt(2)+a.charAt(2),16)]:[parseInt(a.charAt(0)+a.charAt(1),16),parseInt(a.charAt(2)+a.charAt(3),16),parseInt(a.charAt(4)+a.charAt(5),16)]):a.match(/^ *rgba? *\(/)&&(a=a.match(/^ *rgba? *\( *([0-9]*) *, *([0-9]*) *, *([0-9]*) *(,.*)?\) *$/),b=[+a[1],+a[2],+a[3]]),d[a]={r:b[0],g:b[1],b:b[2]},d[a]}function b(b,c,d){b=a(b),c=a(c);var e={r:b.r*(1-d)+c.r*d,g:b.g*(1-d)+c.g*d,b:b.b*(1-d)+c.b*d};return"rgb("+[0|e.r,0|e.g,0|e.b].join(",")+")"}if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.plugins");var c=0,d={};sigma.plugins.animate=function(a,d,e){function f(){var c=(sigma.utils.dateNow()-k)/i;c>=1?(a.graph.nodes().forEach(function(a){for(var b in d)b in d&&(a[b]=a[d[b]])}),a.refresh(),"function"==typeof g.onComplete&&g.onComplete()):(c=j(c),a.graph.nodes().forEach(function(a){for(var e in d)e in d&&(a[e]=e.match(/color$/)?b(l[a.id][e],a[d[e]],c):a[d[e]]*c+l[a.id][e]*(1-c))}),a.refresh(),a.animations[h]=requestAnimationFrame(f))}var g=e||{},h=++c,i=g.duration||a.settings("animationsTime"),j="string"==typeof g.easing?sigma.utils.easings[g.easing]:"function"==typeof g.easing?g.easing:sigma.utils.easings.quadraticInOut,k=sigma.utils.dateNow(),l=a.graph.nodes().reduce(function(a,b){var c;a[b.id]={};for(c in d)c in b&&(a[b.id][c]=b[c]);return a},{});a.animations=a.animations||Object.create({}),sigma.plugins.kill(a),f()},sigma.plugins.kill=function(a){for(var b in a.animations||{})cancelAnimationFrame(a.animations[b])}}).call(window);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.dragNodes.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.dragNodes.min.js
new file mode 100644
index 00000000..b9dd3b1c
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.dragNodes.min.js
@@ -0,0 +1 @@
+(function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.plugins"),sigma.plugins.dragNodes=function(a,b){if(sigma.renderers.webgl&&b instanceof sigma.renderers.webgl)throw new Error("The sigma.plugins.dragNodes is not compatible with the WebGL renderer");var c=document.body,d=b.container,e=d.lastChild,f=b.camera,g=null,h="",i=!1;h=b instanceof sigma.renderers.webgl?b.options.prefix.substr(5):b.options.prefix;var j=function(a){i||(g=a.data.node,e.addEventListener("mousedown",l),i=!0)},k=function(){i&&(e.removeEventListener("mousedown",l),i=!1)},l=function(){var d=a.graph.nodes().length;d>1&&(e.removeEventListener("mousedown",l),c.addEventListener("mousemove",n),c.addEventListener("mouseup",m),b.unbind("outNode",k),b.settings({mouseEnabled:!1,enableHovering:!1}),a.refresh())},m=function(){e.addEventListener("mousedown",l),c.removeEventListener("mousemove",n),c.removeEventListener("mouseup",m),k(),b.bind("outNode",k),b.settings({mouseEnabled:!0,enableHovering:!0}),a.refresh()},n=function(b){for(var c=b.pageX-d.offsetLeft,e=b.pageY-d.offsetTop,i=Math.cos(f.angle),j=Math.sin(f.angle),k=a.graph.nodes(),l=[],m=0;2>m;m++){var n=k[m],o={x:n.x*i+n.y*j,y:n.y*i-n.x*j,renX:n[h+"x"],renY:n[h+"y"]};l.push(o)}c=(c-l[0].renX)/(l[1].renX-l[0].renX)*(l[1].x-l[0].x)+l[0].x,e=(e-l[0].renY)/(l[1].renY-l[0].renY)*(l[1].y-l[0].y)+l[0].y,g.x=c*i-e*j,g.y=e*i+c*j,a.refresh()};b.bind("overNode",j),b.bind("outNode",k)}}).call(window);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.neighborhoods.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.neighborhoods.min.js
new file mode 100644
index 00000000..aa6ddc72
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.plugins.neighborhoods.min.js
@@ -0,0 +1 @@
+(function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.classes.graph.addMethod("neighborhood",function(a){var b,c,d,e,f,g={},h={},i={nodes:[],edges:[]};if(!this.nodes(a))return i;e=this.nodes(a),f={},f.center=!0;for(b in e)f[b]=e[b];g[a]=!0,i.nodes.push(f);for(b in this.allNeighborsIndex[a]){g[b]||(g[b]=!0,i.nodes.push(this.nodesIndex[b]));for(c in this.allNeighborsIndex[a][b])h[c]||(h[c]=!0,i.edges.push(this.edgesIndex[c]))}for(b in g)if(b!==a)for(c in g)if(c!==a&&b!==c&&this.allNeighborsIndex[b][c])for(d in this.allNeighborsIndex[b][c])h[d]||(h[d]=!0,i.edges.push(this.edgesIndex[d]));return i}),sigma.utils.pkg("sigma.plugins"),sigma.plugins.neighborhoods=function(){var a=new sigma.classes.graph;this.neighborhood=function(b){return a.neighborhood(b)},this.load=function(b,c){var d=function(){if(window.XMLHttpRequest)return new XMLHttpRequest;var a,b;if(window.ActiveXObject){a=["Msxml2.XMLHTTP.6.0","Msxml2.XMLHTTP.3.0","Msxml2.XMLHTTP","Microsoft.XMLHTTP"];for(b in a)try{return new ActiveXObject(a[b])}catch(c){}}return null}();if(!d)throw"XMLHttpRequest not supported, cannot load the data.";return d.open("GET",b,!0),d.onreadystatechange=function(){4===d.readyState&&(a.clear().read(JSON.parse(d.responseText)),c&&c())},d.send(),this},this.read=function(b){a.clear().read(b)}}}).call(window);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.renderers.customShapes.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.renderers.customShapes.min.js
new file mode 100644
index 00000000..0fbc60e8
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/plugins/sigma.renderers.customShapes.min.js
@@ -0,0 +1 @@
+(function(){"use strict";var a=[],b=function(b,c,d){a.push({name:b,drawShape:c,drawBorder:d})},c=function(){return a},d=function(a){return function(b,c,d,e,f,g){g.fillStyle=f,g.beginPath(),a(b,c,d,e,g),g.closePath(),g.fill()}},e=function(a){return function(b,c,d,e,f,g){g.strokeStyle=f,g.lineWidth=e/5,g.beginPath(),a(b,c,d,e,g),g.closePath(),g.stroke()}},f=function(a,b,c,d,e){var f=45*Math.PI/180;e.moveTo(b+d*Math.sin(f),c-d*Math.cos(f));for(var g=1;4>g;g++)e.lineTo(b+Math.sin(f+2*Math.PI*g/4)*d,c-Math.cos(f+2*Math.PI*g/4)*d)};b("square",d(f),e(f));var g=function(a,b,c,d,e){e.arc(b,c,d,0,2*Math.PI,!0)};b("circle",d(g),e(g));var h=function(a,b,c,d,e){e.moveTo(b-d,c),e.lineTo(b,c-d),e.lineTo(b+d,c),e.lineTo(b,c+d)};b("diamond",d(h),e(h));var i=function(a,b,c,d,e){var f=a.equilateral&&a.equilateral.numPoints||5,g=(a.equilateral&&a.equilateral.rotate||0)*Math.PI/180,h=d;e.moveTo(b+h*Math.sin(g),c-h*Math.cos(g));for(var i=1;f>i;i++)e.lineTo(b+Math.sin(g+2*Math.PI*i/f)*h,c-Math.cos(g+2*Math.PI*i/f)*h)};b("equilateral",d(i),e(i));var j=function(a,b,c,d,e){var f=a.star&&a.star.numPoints||5,g=a.star&&a.star.innerRatio||.5,h=d,i=d*g,j=Math.PI/f;e.moveTo(b,c-d);for(var k=0;f>k;k++)e.lineTo(b+Math.sin(j+2*Math.PI*k/f)*i,c-Math.cos(j+2*Math.PI*k/f)*i),e.lineTo(b+Math.sin(2*Math.PI*(k+1)/f)*h,c-Math.cos(2*Math.PI*(k+1)/f)*h)};b("star",d(j),e(j));var k=function(a,b,c,d,e,f){f.fillStyle="yellow",f.beginPath(),f.arc(b,c,d,1.25*Math.PI,0,!1),f.arc(b,c,d,0,.75*Math.PI,!1),f.lineTo(b,c),f.closePath(),f.fill(),f.fillStyle="white",f.strokeStyle="black",f.beginPath(),f.arc(b+d/3,c-d/3,d/4,0,2*Math.PI,!1),f.closePath(),f.fill(),f.stroke(),f.fillStyle="black",f.beginPath(),f.arc(b+4*d/9,c-d/3,d/8,0,2*Math.PI,!1),f.closePath(),f.fill()};b("pacman",k,null),this.ShapeLibrary={enumerate:c,version:"0.1"}}).call(this),function(a){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";if("undefined"==typeof ShapeLibrary)throw"ShapeLibrary is not declared";sigma.utils.pkg("sigma.canvas.nodes");var b=a,c={},d=function(a){b=a},e=function(a,d,e,f,g){if(b&&a.image&&a.image.url){var h=a.image.url,i=a.image.h||1,j=a.image.w||1,k=a.image.scale||1,l=a.image.clip||1,m=c[h];m||(m=document.createElement("IMG"),m.src=h,m.onload=function(){console.log("redraw on image load"),b.refresh()},c[h]=m);var n=i>j?j/i:1,o=j>i?i/j:1,p=f*k;g.save(),g.beginPath(),g.arc(d,e,f*l,0,2*Math.PI,!0),g.closePath(),g.clip(),g.drawImage(m,d+Math.sin(-0.7855)*p*n,e-Math.cos(-0.7855)*p*o,p*n*2*Math.sin(-0.7855)*-1,p*o*2*Math.cos(-0.7855)),g.restore()}},f=function(a,b,c){sigma.canvas.nodes[a]=function(a,d,f){var g=f("prefix")||"",h=a[g+"size"],i=a.color||f("defaultNodeColor"),j=a.borderColor||i,k=a[g+"x"],l=a[g+"y"];d.save(),b&&b(a,k,l,h,i,d),c&&c(a,k,l,h,j,d),e(a,k,l,h,d),d.restore()}};ShapeLibrary.enumerate().forEach(function(a){f(a.name,a.drawShape,a.drawBorder)}),this.CustomShapes={init:d,version:"0.1"}}.call(this);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/static/third_party/sigmajs/sigma.min.js b/vendor/github.com/google/cayley/static/third_party/sigmajs/sigma.min.js
new file mode 100644
index 00000000..8192bac0
--- /dev/null
+++ b/vendor/github.com/google/cayley/static/third_party/sigmajs/sigma.min.js
@@ -0,0 +1,4 @@
+/* sigma.js - A JavaScript library dedicated to graph drawing. - Version: 1.0.2 - Author: Alexis Jacomy, Sciences-Po Médialab - License: MIT */
+(function(){"use strict";var a={},b=function(c){var d,e,f,g,h;b.classes.dispatcher.extend(this);var i=this,j=c||{};if("string"==typeof j||j instanceof HTMLElement?j={renderers:[j]}:"[object Array]"===Object.prototype.toString.call(j)&&(j={renderers:j}),g=j.renderers||j.renderer||j.container,j.renderers&&0!==j.renderers.length||("string"==typeof g||g instanceof HTMLElement||"object"==typeof g&&"container"in g)&&(j.renderers=[g]),j.id){if(a[j.id])throw'sigma: Instance "'+j.id+'" already exists.';Object.defineProperty(this,"id",{value:j.id})}else{for(h=0;a[h];)h++;Object.defineProperty(this,"id",{value:""+h})}for(a[this.id]=this,this.settings=new b.classes.configurable(b.settings,j.settings||{}),Object.defineProperty(this,"graph",{value:new b.classes.graph(this.settings),configurable:!0}),Object.defineProperty(this,"middlewares",{value:[],configurable:!0}),Object.defineProperty(this,"cameras",{value:{},configurable:!0}),Object.defineProperty(this,"renderers",{value:{},configurable:!0}),Object.defineProperty(this,"renderersPerCamera",{value:{},configurable:!0}),Object.defineProperty(this,"cameraFrames",{value:{},configurable:!0}),Object.defineProperty(this,"camera",{get:function(){return this.cameras[0]}}),this._handler=function(a){var b,c={};for(b in a.data)c[b]=a.data[b];c.renderer=a.target,this.dispatchEvent(a.type,c)}.bind(this),f=j.renderers||[],d=0,e=f.length;e>d;d++)this.addRenderer(f[d]);for(f=j.middlewares||[],d=0,e=f.length;e>d;d++)this.middlewares.push("string"==typeof f[d]?b.middlewares[f[d]]:f[d]);"object"==typeof j.graph&&j.graph&&(this.graph.read(j.graph),this.refresh()),window.addEventListener("resize",function(){i.settings&&i.refresh()})};if(b.prototype.addCamera=function(a){var c,d=this;if(!arguments.length){for(a=0;this.cameras[""+a];)a++;a=""+a}if(this.cameras[a])throw'sigma.addCamera: The camera "'+a+'" already exists.';return c=new b.classes.camera(a,this.graph,this.settings),this.cameras[a]=c,c.quadtree=new b.classes.quad,c.bind("coordinatesUpdated",function(){d.renderCamera(c,c.isAnimated)}),this.renderersPerCamera[a]=[],c},b.prototype.killCamera=function(a){if(a="string"==typeof a?this.cameras[a]:a,!a)throw"sigma.killCamera: The camera is undefined.";var b,c,d=this.renderersPerCamera[a.id];for(c=d.length,b=c-1;b>=0;b--)this.killRenderer(d[b]);return delete this.renderersPerCamera[a.id],delete this.cameraFrames[a.id],delete this.cameras[a.id],a.kill&&a.kill(),this},b.prototype.addRenderer=function(a){var c,d,e,f,g=a||{};if("string"==typeof g?g={container:document.getElementById(g)}:g instanceof HTMLElement&&(g={container:g}),"id"in g)c=g.id;else{for(c=0;this.renderers[""+c];)c++;c=""+c}if(this.renderers[c])throw'sigma.addRenderer: The renderer "'+c+'" already exists.';if(d="function"==typeof g.type?g.type:b.renderers[g.type],d=d||b.renderers.def,e="camera"in g?g.camera instanceof b.classes.camera?g.camera:this.cameras[g.camera]||this.addCamera(g.camera):this.addCamera(),this.cameras[e.id]!==e)throw"sigma.addRenderer: The camera is not properly referenced.";return f=new d(this.graph,e,this.settings,g),this.renderers[c]=f,Object.defineProperty(f,"id",{value:c}),f.bind&&f.bind(["click","clickStage","doubleClickStage","clickNode","clickNodes","doubleClickNode","doubleClickNodes","overNode","overNodes","outNode","outNodes","downNode","downNodes","upNode","upNodes"],this._handler),this.renderersPerCamera[e.id].push(f),f},b.prototype.killRenderer=function(a){if(a="string"==typeof a?this.renderers[a]:a,!a)throw"sigma.killRenderer: The renderer is undefined.";var b=this.renderersPerCamera[a.camera.id],c=b.indexOf(a);return c>=0&&b.splice(c,1),a.kill&&a.kill(),delete this.renderers[a.id],this},b.prototype.refresh=function(){var a,c,d,e,f,g,h=0;for(e=this.middlewares||[],a=0,c=e.length;c>a;a++)e[a].call(this,0===a?"":"tmp"+h+":",a===c-1?"ready:":"tmp"+ ++h+":");for(d in this.cameras)f=this.cameras[d],f.settings("autoRescale")&&this.renderersPerCamera[f.id]&&this.renderersPerCamera[f.id].length?b.middlewares.rescale.call(this,e.length?"ready:":"",f.readPrefix,{width:this.renderersPerCamera[f.id][0].width,height:this.renderersPerCamera[f.id][0].height}):b.middlewares.copy.call(this,e.length?"ready:":"",f.readPrefix),g=b.utils.getBoundaries(this.graph,f.readPrefix),f.quadtree.index(this.graph.nodes(),{prefix:f.readPrefix,bounds:{x:g.minX,y:g.minY,width:g.maxX-g.minX,height:g.maxY-g.minY}});for(e=Object.keys(this.renderers),a=0,c=e.length;c>a;a++)if(this.renderers[e[a]].process)if(this.settings("skipErrors"))try{this.renderers[e[a]].process()}catch(i){console.log('Warning: The renderer "'+e[a]+'" crashed on ".process()"')}else this.renderers[e[a]].process();return this.render(),this},b.prototype.render=function(){var a,b,c;for(c=Object.keys(this.renderers),a=0,b=c.length;b>a;a++)if(this.settings("skipErrors"))try{this.renderers[c[a]].render()}catch(d){this.settings("verbose")&&console.log('Warning: The renderer "'+c[a]+'" crashed on ".render()"')}else this.renderers[c[a]].render();return this},b.prototype.renderCamera=function(a,b){var c,d,e,f=this;if(b)for(e=this.renderersPerCamera[a.id],c=0,d=e.length;d>c;c++)if(this.settings("skipErrors"))try{e[c].render()}catch(g){this.settings("verbose")&&console.log('Warning: The renderer "'+e[c].id+'" crashed on ".render()"')}else e[c].render();else if(!this.cameraFrames[a.id]){for(e=this.renderersPerCamera[a.id],c=0,d=e.length;d>c;c++)if(this.settings("skipErrors"))try{e[c].render()}catch(g){this.settings("verbose")&&console.log('Warning: The renderer "'+e[c].id+'" crashed on ".render()"')}else e[c].render();this.cameraFrames[a.id]=requestAnimationFrame(function(){delete f.cameraFrames[a.id]})}return this},b.prototype.kill=function(){var b;this.graph.kill(),delete this.middlewares;for(b in this.renderers)this.killRenderer(this.renderers[b]);for(b in this.cameras)this.killCamera(this.cameras[b]);delete this.renderers,delete this.cameras;for(b in this)this.hasOwnProperty(b)&&delete this[b];delete a[this.id]},b.instances=function(c){return arguments.length?a[c]:b.utils.extend({},a)},b.version="1.0.2","undefined"!=typeof this.sigma)throw"An object called sigma is already in the global scope.";"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=b),exports.sigma=b):this.sigma=b}).call(this),function(a){"use strict";function b(a,c){var d,e,f,g;if(arguments.length)if(1===arguments.length&&Object(arguments[0])===arguments[0])for(a in arguments[0])b(a,arguments[0][a]);else if(arguments.length>1)for(g=Array.isArray(a)?a:a.split(/ /),d=0,e=g.length;d!==e;d+=1)f=g[d],C[f]||(C[f]=[]),C[f].push({handler:c})}function c(a,b){var c,d,e,f,g,h,i=Array.isArray(a)?a:a.split(/ /);if(arguments.length)if(b)for(c=0,d=i.length;c!==d;c+=1){if(h=i[c],C[h]){for(g=[],e=0,f=C[h].length;e!==f;e+=1)C[h][e].handler!==b&&g.push(C[h][e]);C[h]=g}C[h]&&0===C[h].length&&delete C[h]}else for(c=0,d=i.length;c!==d;c+=1)delete C[i[c]];else C=Object.create(null)}function d(a,b){var c,d,e,f,g,h,i=Array.isArray(a)?a:a.split(/ /);for(b=void 0===b?{}:b,c=0,e=i.length;c!==e;c+=1)if(h=i[c],C[h])for(g={type:h,data:b||{}},d=0,f=C[h].length;d!==f;d+=1)try{C[h][d].handler(g)}catch(j){}}function e(){var a,b,c,d,e=!1,f=s(),g=x.shift();if(c=g.job(),f=s()-f,g.done++,g.time+=f,g.currentTime+=f,g.weightTime=g.currentTime/(g.weight||1),g.averageTime=g.time/g.done,d=g.count?g.count<=g.done:!c,!d){for(a=0,b=x.length;b>a;a++)if(x[a].weightTime>g.weightTime){x.splice(a,0,g),e=!0;break}e||x.push(g)}return d?g:null}function f(a){var b=x.length;w[a.id]=a,a.status="running",b&&(a.weightTime=x[b-1].weightTime,a.currentTime=a.weightTime*(a.weight||1)),a.startTime=s(),d("jobStarted",q(a)),x.push(a)}function g(){var a,b,c;for(a in v)b=v[a],b.after?y[a]=b:f(b),delete v[a];for(u=!!x.length;x.length&&s()-t<B.frameDuration;)if(c=e()){i(c.id);for(a in y)y[a].after===c.id&&(f(y[a]),delete y[a])}u?(t=s(),d("enterFrame"),setTimeout(g,0)):d("stop")}function h(a,b){var c,e,f;if(Array.isArray(a)){for(A=!0,c=0,e=a.length;e>c;c++)h(a[c].id,p(a[c],b));A=!1,u||(t=s(),d("start"),g())}else if("object"==typeof a)if("string"==typeof a.id)h(a.id,a);else{A=!0;for(c in a)"function"==typeof a[c]?h(c,p({job:a[c]},b)):h(c,p(a[c],b));A=!1,u||(t=s(),d("start"),g())}else{if("string"!=typeof a)throw new Error("[conrad.addJob] Wrong arguments.");if(k(a))throw new Error('[conrad.addJob] Job with id "'+a+'" already exists.');if("function"==typeof b)f={id:a,done:0,time:0,status:"waiting",currentTime:0,averageTime:0,weightTime:0,job:b};else{if("object"!=typeof b)throw new Error("[conrad.addJob] Wrong arguments.");f=p({id:a,done:0,time:0,status:"waiting",currentTime:0,averageTime:0,weightTime:0},b)}v[a]=f,d("jobAdded",q(f)),u||A||(t=s(),d("start"),g())}return this}function i(a){var b,c,e,f,g=!1;if(Array.isArray(a))for(b=0,c=a.length;c>b;b++)i(a[b]);else{if("string"!=typeof a)throw new Error("[conrad.killJob] Wrong arguments.");for(e=[w,y,v],b=0,c=e.length;c>b;b++)a in e[b]&&(f=e[b][a],B.history&&(f.status="done",z.push(f)),d("jobEnded",q(f)),delete e[b][a],"function"==typeof f.end&&f.end(),g=!0);for(e=x,b=0,c=e.length;c>b;b++)if(e[b].id===a){e.splice(b,1);break}if(!g)throw new Error('[conrad.killJob] Job "'+a+'" not found.')}return this}function j(){var a,b=p(v,w,y);if(B.history)for(a in b)b[a].status="done",z.push(b[a]),"function"==typeof b[a].end&&b[a].end();return v={},y={},w={},x=[],u=!1,this}function k(a){var b=v[a]||w[a]||y[a];return b?p(b):null}function l(){var a;if("string"==typeof a1&&1===arguments.length)return B[a1];a="object"==typeof a1&&1===arguments.length?a1||{}:{},"string"==typeof a1&&(a[a1]=a2);for(var b in a)void 0!==a[b]?B[b]=a[b]:delete B[b];return this}function m(){return u}function n(){return z=[],this}function o(a,b){var c,d,e,f,g,h,i;if(!arguments.length){g=[];for(d in v)g.push(v[d]);for(d in y)g.push(y[d]);for(d in w)g.push(w[d]);g=g.concat(z)}if("string"==typeof a)switch(a){case"waiting":g=r(y);break;case"running":g=r(w);break;case"done":g=z;break;default:h=a}if(a instanceof RegExp&&(h=a),!h&&("string"==typeof b||b instanceof RegExp)&&(h=b),h){if(i="string"==typeof h,g instanceof Array)c=g;else if("object"==typeof g){c=[];for(d in g)c=c.concat(g[d])}else{c=[];for(d in v)c.push(v[d]);for(d in y)c.push(y[d]);for(d in w)c.push(w[d]);c=c.concat(z)}for(g=[],e=0,f=c.length;f>e;e++)(i?c[e].id===h:c[e].id.match(h))&&g.push(c[e])}return q(g)}function p(){var a,b,c={},d=arguments.length;for(a=d-1;a>=0;a--)for(b in arguments[a])c[b]=arguments[a][b];return c}function q(a){var b,c,d;if(!a)return a;if(Array.isArray(a))for(b=[],c=0,d=a.length;d>c;c++)b.push(q(a[c]));else if("object"==typeof a){b={};for(c in a)b[c]=q(a[c])}else b=a;return b}function r(a){var b,c=[];for(b in a)c.push(a[b]);return c}function s(){return Date.now?Date.now():(new Date).getTime()}if(a.conrad)throw new Error("conrad already exists");var t,u=!1,v={},w={},x=[],y={},z=[],A=!1,B={frameDuration:20,history:!0},C=Object.create(null);Array.isArray||(Array.isArray=function(a){return"[object Array]"===Object.prototype.toString.call(a)});var D={hasJob:k,addJob:h,killJob:i,killAll:j,settings:l,getStats:o,isRunning:m,clearHistory:n,bind:b,unbind:c,version:"0.1.0"};"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=D),exports.conrad=D):a.conrad=D}(this),function(a){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";var b=this;sigma.utils=sigma.utils||{},sigma.utils.extend=function(){var a,b,c={},d=arguments.length;for(a=d-1;a>=0;a--)for(b in arguments[a])c[b]=arguments[a][b];return c},sigma.utils.dateNow=function(){return Date.now?Date.now():(new Date).getTime()},sigma.utils.pkg=function(a){return(a||"").split(".").reduce(function(a,b){return b in a?a[b]:a[b]={}},b)},sigma.utils.id=function(){var a=0;return function(){return++a}}(),sigma.utils.floatColor=function(a){var b=[0,0,0];return a.match(/^#/)?(a=(a||"").replace(/^#/,""),b=3===a.length?[parseInt(a.charAt(0)+a.charAt(0),16),parseInt(a.charAt(1)+a.charAt(1),16),parseInt(a.charAt(2)+a.charAt(2),16)]:[parseInt(a.charAt(0)+a.charAt(1),16),parseInt(a.charAt(2)+a.charAt(3),16),parseInt(a.charAt(4)+a.charAt(5),16)]):a.match(/^ *rgba? *\(/)&&(a=a.match(/^ *rgba? *\( *([0-9]*) *, *([0-9]*) *, *([0-9]*) *(,.*)?\) *$/),b=[+a[1],+a[2],+a[3]]),256*b[0]*256+256*b[1]+b[2]},sigma.utils.getX=function(b){return b.offsetX!==a&&b.offsetX||b.layerX!==a&&b.layerX||b.clientX!==a&&b.clientX},sigma.utils.getY=function(b){return b.offsetY!==a&&b.offsetY||b.layerY!==a&&b.layerY||b.clientY!==a&&b.clientY},sigma.utils.getDelta=function(b){return b.wheelDelta!==a&&b.wheelDelta||b.detail!==a&&-b.detail},sigma.utils.getOffset=function(a){for(var b=0,c=0;a;)c+=parseInt(a.offsetTop),b+=parseInt(a.offsetLeft),a=a.offsetParent;return{top:c,left:b}},sigma.utils.doubleClick=function(a,b,c){var d,e=0;a._doubleClickHandler=a._doubleClickHandler||{},a._doubleClickHandler[b]=a._doubleClickHandler[b]||[],d=a._doubleClickHandler[b],d.push(function(a){return e++,2===e?(e=0,c(a)):void(1===e&&setTimeout(function(){e=0},sigma.settings.doubleClickTimeout))}),a.addEventListener(b,d[d.length-1],!1)},sigma.utils.unbindDoubleClick=function(a,b){for(var c,d=(a._doubleClickHandler||{})[b]||[];c=d.pop();)a.removeEventListener(b,c);delete(a._doubleClickHandler||{})[b]},sigma.utils.easings=sigma.utils.easings||{},sigma.utils.easings.linearNone=function(a){return a},sigma.utils.easings.quadraticIn=function(a){return a*a},sigma.utils.easings.quadraticOut=function(a){return a*(2-a)},sigma.utils.easings.quadraticInOut=function(a){return(a*=2)<1?.5*a*a:-.5*(--a*(a-2)-1)},sigma.utils.easings.cubicIn=function(a){return a*a*a},sigma.utils.easings.cubicOut=function(a){return--a*a*a+1},sigma.utils.easings.cubicInOut=function(a){return(a*=2)<1?.5*a*a*a:.5*((a-=2)*a*a+2)},sigma.utils.loadShader=function(a,b,c,d){var e,f=a.createShader(c);return a.shaderSource(f,b),a.compileShader(f),e=a.getShaderParameter(f,a.COMPILE_STATUS),e?f:(d&&d('Error compiling shader "'+f+'":'+a.getShaderInfoLog(f)),a.deleteShader(f),null)},sigma.utils.loadProgram=function(a,b,c,d,e){var f,g,h=a.createProgram();for(f=0;f<b.length;++f)a.attachShader(h,b[f]);if(c)for(f=0;f<c.length;++f)a.bindAttribLocation(h,locations?locations[f]:f,opt_attribs[f]);return a.linkProgram(h),g=a.getProgramParameter(h,a.LINK_STATUS),g?h:(e&&e("Error in program linking: "+a.getProgramInfoLog(h)),a.deleteProgram(h),null)},sigma.utils.pkg("sigma.utils.matrices"),sigma.utils.matrices.translation=function(a,b){return[1,0,0,0,1,0,a,b,1]},sigma.utils.matrices.rotation=function(a,b){var c=Math.cos(a),d=Math.sin(a);return b?[c,-d,d,c]:[c,-d,0,d,c,0,0,0,1]},sigma.utils.matrices.scale=function(a,b){return b?[a,0,0,a]:[a,0,0,0,a,0,0,0,1]},sigma.utils.matrices.multiply=function(a,b,c){var d=c?2:3,e=a[0*d+0],f=a[0*d+1],g=a[0*d+2],h=a[1*d+0],i=a[1*d+1],j=a[1*d+2],k=a[2*d+0],l=a[2*d+1],m=a[2*d+2],n=b[0*d+0],o=b[0*d+1],p=b[0*d+2],q=b[1*d+0],r=b[1*d+1],s=b[1*d+2],t=b[2*d+0],u=b[2*d+1],v=b[2*d+2];return c?[e*n+f*q,e*o+f*r,h*n+i*q,h*o+i*r]:[e*n+f*q+g*t,e*o+f*r+g*u,e*p+f*s+g*v,h*n+i*q+j*t,h*o+i*r+j*u,h*p+i*s+j*v,k*n+l*q+m*t,k*o+l*r+m*u,k*p+l*s+m*v]}}.call(this),function(){"use strict";var a,b=0,c=["ms","moz","webkit","o"];for(a=0;a<c.length&&!window.requestAnimationFrame;a++)window.requestAnimationFrame=window[c[a]+"RequestAnimationFrame"],window.cancelAnimationFrame=window[c[a]+"CancelAnimationFrame"]||window[c[a]+"CancelRequestAnimationFrame"];window.requestAnimationFrame||(window.requestAnimationFrame=function(a){var c=(new Date).getTime(),d=Math.max(0,16-(c-b)),e=window.setTimeout(function(){a(c+d)},d);return b=c+d,e}),window.cancelAnimationFrame||(window.cancelAnimationFrame=function(a){clearTimeout(a)}),Function.prototype.bind||(Function.prototype.bind=function(a){if("function"!=typeof this)throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");var b,c,d=Array.prototype.slice.call(arguments,1),e=this;return b=function(){},c=function(){return e.apply(this instanceof b&&a?this:a,d.concat(Array.prototype.slice.call(arguments)))},b.prototype=this.prototype,c.prototype=new b,c})}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.settings");var a={clone:!0,immutable:!0,verbose:!1,defaultLabelColor:"#000",defaultEdgeColor:"#000",defaultNodeColor:"#000",defaultLabelSize:14,edgeColor:"source",font:"arial",fontStyle:"",labelColor:"default",labelSize:"fixed",labelSizeRatio:1,labelThreshold:8,webglOversamplingRatio:2,borderSize:0,defaultNodeBorderColor:"#000",hoverFont:"",hoverFontStyle:"",labelHoverShadow:"default",labelHoverShadowColor:"#000",nodeHoverColor:"node",defaultNodeHoverColor:"#000",labelHoverBGColor:"default",defaultHoverLabelBGColor:"#fff",labelHoverColor:"default",defaultLabelHoverColor:"#000",drawLabels:!0,drawEdges:!0,drawNodes:!0,batchEdgesDrawing:!1,hideEdgesOnMove:!1,canvasEdgesBatchSize:500,webglEdgesBatchSize:1e3,scalingMode:"inside",sideMargin:0,minEdgeSize:.5,maxEdgeSize:1,minNodeSize:1,maxNodeSize:8,touchEnabled:!0,mouseEnabled:!0,doubleClickEnabled:!0,eventsEnabled:!0,zoomingRatio:1.7,doubleClickZoomingRatio:2.2,zoomMin:.0625,zoomMax:2,mouseZoomDuration:200,doubleClickZoomDuration:200,mouseInertiaDuration:200,mouseInertiaRatio:3,touchInertiaDuration:200,touchInertiaRatio:3,doubleClickTimeout:300,doubleTapTimeout:300,dragTimeout:200,autoResize:!0,autoRescale:!0,enableCamera:!0,enableHovering:!0,rescaleIgnoreSize:!1,skipErrors:!1,nodesPowRatio:.5,edgesPowRatio:.5,animationsTime:200};sigma.settings=sigma.utils.extend(sigma.settings||{},a)}.call(this),function(){"use strict";var a=function(){Object.defineProperty(this,"_handlers",{value:{}})};a.prototype.bind=function(a,b){var c,d,e,f;if(1===arguments.length&&"object"==typeof arguments[0])for(a in arguments[0])this.bind(a,arguments[0][a]);else{if(2!==arguments.length||"function"!=typeof arguments[1])throw"bind: Wrong arguments.";for(f="string"==typeof a?a.split(" "):a,c=0,d=f.length;c!==d;c+=1)e=f[c],e&&(this._handlers[e]||(this._handlers[e]=[]),this._handlers[e].push({handler:b}))}return this},a.prototype.unbind=function(a,b){var c,d,e,f,g,h,i,j="string"==typeof a?a.split(" "):a;if(!arguments.length){for(g in this._handlers)delete this._handlers[g];return this}if(b)for(c=0,d=j.length;c!==d;c+=1){if(i=j[c],this._handlers[i]){for(h=[],e=0,f=this._handlers[i].length;e!==f;e+=1)this._handlers[i][e].handler!==b&&h.push(this._handlers[i][e]);this._handlers[i]=h}this._handlers[i]&&0===this._handlers[i].length&&delete this._handlers[i]}else for(c=0,d=j.length;c!==d;c+=1)delete this._handlers[j[c]];return this},a.prototype.dispatchEvent=function(a,b){var c,d,e,f,g,h,i,j=this,k="string"==typeof a?a.split(" "):a;for(b=void 0===b?{}:b,c=0,d=k.length;c!==d;c+=1)if(i=k[c],this._handlers[i]){for(h=j.getEvent(i,b),g=[],e=0,f=this._handlers[i].length;e!==f;e+=1)this._handlers[i][e].handler(h),this._handlers[i][e].one||g.push(this._handlers[i][e]);this._handlers[i]=g}return this},a.prototype.getEvent=function(a,b){return{type:a,data:b||{},target:this}},a.extend=function(b,c){var d;for(d in a.prototype)a.prototype.hasOwnProperty(d)&&(b[d]=a.prototype[d]);a.apply(b,c)},"undefined"!=typeof this.sigma?(this.sigma.classes=this.sigma.classes||{},this.sigma.classes.dispatcher=a):"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=a),exports.dispatcher=a):this.dispatcher=a}.call(this),function(){"use strict";var a=function(){var b,c,d={},e=Array.prototype.slice.call(arguments,0),f=function(a,g){var h,i;if(1===arguments.length&&"string"==typeof a){if(a in d&&void 0!==d[a])return d[a];for(b=0,c=e.length;c>b;b++)if(a in e[b]&&void 0!==e[b][a])return e[b][a];return void 0}if("object"==typeof a&&"string"==typeof g)return g in(a||{})?a[g]:f(g);h="object"==typeof a&&void 0===g?a:{},"string"==typeof a&&(h[a]=g);for(i in h)d[i]=h[i];return this};for(f.embedObjects=function(){var b=e.concat(d).concat(Array.prototype.splice.call(arguments,0));return a.apply({},b)},b=0,c=arguments.length;c>b;b++)f(arguments[b]);return f};"undefined"!=typeof this.sigma?(this.sigma.classes=this.sigma.classes||{},this.sigma.classes.configurable=a):"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=a),exports.configurable=a):this.configurable=a}.call(this),function(){"use strict";function a(a,b,c){var d=function(){var d,e;e=c.apply(b,arguments);for(d in f[a])f[a][d].apply(b,arguments);return e};return d}function b(a){var b;for(b in a)"hasOwnProperty"in a&&!a.hasOwnProperty(b)||delete a[b];return a}var c=Object.create(null),d=Object.create(null),e=Object.create(null),f=Object.create(null),g={immutable:!0,clone:!0},h=function(a){return g[a]},i=function(b){var d,f,g;g={settings:b||h,nodesArray:[],edgesArray:[],nodesIndex:Object.create(null),edgesIndex:Object.create(null),inNeighborsIndex:Object.create(null),outNeighborsIndex:Object.create(null),allNeighborsIndex:Object.create(null),inNeighborsCount:Object.create(null),outNeighborsCount:Object.create(null),allNeighborsCount:Object.create(null)};for(d in e)e[d].call(g);for(d in c)f=a(d,g,c[d]),this[d]=f,g[d]=f};i.addMethod=function(a,b){if("string"!=typeof a||"function"!=typeof b||2!==arguments.length)throw"addMethod: Wrong arguments.";if(c[a])throw'The method "'+a+'" already exists.';return c[a]=b,f[a]=Object.create(null),this},i.attach=function(a,b,c){if("string"!=typeof a||"string"!=typeof b||"function"!=typeof c||3!==arguments.length)throw"attach: Wrong arguments.";var d;if("constructor"===a)d=e;else{if(!f[a])throw'The method "'+a+'" does not exist.';d=f[a]}if(d[b])throw'A function "'+b+'" is already attached to the method "'+a+'".';return d[b]=c,this},i.addIndex=function(a,b){if("string"!=typeof a||Object(b)!==b||2!==arguments.length)throw"addIndex: Wrong arguments.";if(d[a])throw'The index "'+a+'" already exists.';var c;d[a]=b;for(c in b){if("function"!=typeof b[c])throw"The bindings must be functions.";i.attach(c,a,b[c])}return this},i.addMethod("addNode",function(a){if(Object(a)!==a||1!==arguments.length)throw"addNode: Wrong arguments.";if("string"!=typeof a.id)throw"The node must have a string id.";if(this.nodesIndex[a.id])throw'The node "'+a.id+'" already exists.';var b,c=a.id,d=Object.create(null);if(this.settings("clone"))for(b in a)"id"!==b&&(d[b]=a[b]);else d=a;return this.settings("immutable")?Object.defineProperty(d,"id",{value:c,enumerable:!0}):d.id=c,this.inNeighborsIndex[c]=Object.create(null),this.outNeighborsIndex[c]=Object.create(null),this.allNeighborsIndex[c]=Object.create(null),this.inNeighborsCount[c]=0,this.outNeighborsCount[c]=0,this.allNeighborsCount[c]=0,this.nodesArray.push(d),this.nodesIndex[d.id]=d,this}),i.addMethod("addEdge",function(a){if(Object(a)!==a||1!==arguments.length)throw"addEdge: Wrong arguments.";if("string"!=typeof a.id)throw"The edge must have a string id.";if("string"!=typeof a.source||!this.nodesIndex[a.source])throw"The edge source must have an existing node id.";if("string"!=typeof a.target||!this.nodesIndex[a.target])throw"The edge target must have an existing node id.";if(this.edgesIndex[a.id])throw'The edge "'+a.id+'" already exists.';var b,c=Object.create(null);if(this.settings("clone"))for(b in a)"id"!==b&&"source"!==b&&"target"!==b&&(c[b]=a[b]);else c=a;return this.settings("immutable")?(Object.defineProperty(c,"id",{value:a.id,enumerable:!0}),Object.defineProperty(c,"source",{value:a.source,enumerable:!0}),Object.defineProperty(c,"target",{value:a.target,enumerable:!0})):(c.id=a.id,c.source=a.source,c.target=a.target),this.edgesArray.push(c),this.edgesIndex[c.id]=c,this.inNeighborsIndex[a.target][a.source]||(this.inNeighborsIndex[a.target][a.source]=Object.create(null)),this.inNeighborsIndex[a.target][a.source][a.id]=a,this.outNeighborsIndex[a.source][a.target]||(this.outNeighborsIndex[a.source][a.target]=Object.create(null)),this.outNeighborsIndex[a.source][a.target][a.id]=a,this.allNeighborsIndex[a.source][a.target]||(this.allNeighborsIndex[a.source][a.target]=Object.create(null)),this.allNeighborsIndex[a.source][a.target][a.id]=a,this.allNeighborsIndex[a.target][a.source]||(this.allNeighborsIndex[a.target][a.source]=Object.create(null)),this.allNeighborsIndex[a.target][a.source][a.id]=a,this.inNeighborsCount[a.target]++,this.outNeighborsCount[a.source]++,this.allNeighborsCount[a.target]++,this.allNeighborsCount[a.source]++,this}),i.addMethod("dropNode",function(a){if("string"!=typeof a||1!==arguments.length)throw"dropNode: Wrong arguments.";if(!this.nodesIndex[a])throw'The node "'+a+'" does not exist.';var b,c,d;for(delete this.nodesIndex[a],b=0,d=this.nodesArray.length;d>b;b++)if(this.nodesArray[b].id===a){this.nodesArray.splice(b,1);break}for(b=this.edgesArray.length-1;b>=0;b--)(this.edgesArray[b].source===a||this.edgesArray[b].target===a)&&this.dropEdge(this.edgesArray[b].id);delete this.inNeighborsIndex[a],delete this.outNeighborsIndex[a],delete this.allNeighborsIndex[a],delete this.inNeighborsCount[a],delete this.outNeighborsCount[a],delete this.allNeighborsCount[a];for(c in this.nodesIndex)delete this.inNeighborsIndex[c][a],delete this.outNeighborsIndex[c][a],delete this.allNeighborsIndex[c][a];return this}),i.addMethod("dropEdge",function(a){if("string"!=typeof a||1!==arguments.length)throw"dropEdge: Wrong arguments.";if(!this.edgesIndex[a])throw'The edge "'+a+'" does not exist.';var b,c,d;for(d=this.edgesIndex[a],delete this.edgesIndex[a],b=0,c=this.edgesArray.length;c>b;b++)if(this.edgesArray[b].id===a){this.edgesArray.splice(b,1);break}return delete this.inNeighborsIndex[d.target][d.source][d.id],Object.keys(this.inNeighborsIndex[d.target][d.source]).length||delete this.inNeighborsIndex[d.target][d.source],delete this.outNeighborsIndex[d.source][d.target][d.id],Object.keys(this.outNeighborsIndex[d.source][d.target]).length||delete this.outNeighborsIndex[d.source][d.target],delete this.allNeighborsIndex[d.source][d.target][d.id],Object.keys(this.allNeighborsIndex[d.source][d.target]).length||delete this.allNeighborsIndex[d.source][d.target],delete this.allNeighborsIndex[d.target][d.source][d.id],Object.keys(this.allNeighborsIndex[d.target][d.source]).length||delete this.allNeighborsIndex[d.target][d.source],this.inNeighborsCount[d.target]--,this.outNeighborsCount[d.source]--,this.allNeighborsCount[d.source]--,this.allNeighborsCount[d.target]--,this}),i.addMethod("kill",function(){this.nodesArray.length=0,this.edgesArray.length=0,delete this.nodesArray,delete this.edgesArray,delete this.nodesIndex,delete this.edgesIndex,delete this.inNeighborsIndex,delete this.outNeighborsIndex,delete this.allNeighborsIndex,delete this.inNeighborsCount,delete this.outNeighborsCount,delete this.allNeighborsCount}),i.addMethod("clear",function(){return this.nodesArray.length=0,this.edgesArray.length=0,b(this.nodesIndex),b(this.edgesIndex),b(this.nodesIndex),b(this.inNeighborsIndex),b(this.outNeighborsIndex),b(this.allNeighborsIndex),b(this.inNeighborsCount),b(this.outNeighborsCount),b(this.allNeighborsCount),this}),i.addMethod("read",function(a){var b,c,d;for(c=a.nodes||[],b=0,d=c.length;d>b;b++)this.addNode(c[b]);for(c=a.edges||[],b=0,d=c.length;d>b;b++)this.addEdge(c[b]);return this}),i.addMethod("nodes",function(a){if(!arguments.length)return this.nodesArray.slice(0);if(1===arguments.length&&"string"==typeof a)return this.nodesIndex[a];if(1===arguments.length&&"[object Array]"===Object.prototype.toString.call(a)){var b,c,d=[];for(b=0,c=a.length;c>b;b++){if("string"!=typeof a[b])throw"nodes: Wrong arguments.";d.push(this.nodesIndex[a[b]])}return d}throw"nodes: Wrong arguments."}),i.addMethod("degree",function(a,b){if(b={"in":this.inNeighborsCount,out:this.outNeighborsCount}[b||""]||this.allNeighborsCount,"string"==typeof a)return b[a];if("[object Array]"===Object.prototype.toString.call(a)){var c,d,e=[];for(c=0,d=a.length;d>c;c++){if("string"!=typeof a[c])throw"degree: Wrong arguments.";e.push(b[a[c]])}return e}throw"degree: Wrong arguments."}),i.addMethod("edges",function(a){if(!arguments.length)return this.edgesArray.slice(0);if(1===arguments.length&&"string"==typeof a)return this.edgesIndex[a];if(1===arguments.length&&"[object Array]"===Object.prototype.toString.call(a)){var b,c,d=[];for(b=0,c=a.length;c>b;b++){if("string"!=typeof a[b])throw"edges: Wrong arguments.";d.push(this.edgesIndex[a[b]])}return d}throw"edges: Wrong arguments."}),"undefined"!=typeof sigma?(sigma.classes=sigma.classes||Object.create(null),sigma.classes.graph=i):"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=i),exports.graph=i):this.graph=i}.call(this),function(a){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.classes"),sigma.classes.camera=function(a,b,c,d){sigma.classes.dispatcher.extend(this),Object.defineProperty(this,"graph",{value:b}),Object.defineProperty(this,"id",{value:a}),Object.defineProperty(this,"readPrefix",{value:"read_cam"+a+":"}),Object.defineProperty(this,"prefix",{value:"cam"+a+":"}),this.x=0,this.y=0,this.ratio=1,this.angle=0,this.isAnimated=!1,this.settings="object"==typeof d&&d?c.embedObject(d):c},sigma.classes.camera.prototype.goTo=function(b){if(!this.settings("enableCamera"))return this;var c,d,e=b||{},f=["x","y","ratio","angle"];for(c=0,d=f.length;d>c;c++)if(e[f[c]]!==a){if("number"!=typeof e[f[c]]||isNaN(e[f[c]]))throw'Value for "'+f[c]+'" is not a number.';this[f[c]]=e[f[c]]}return this.dispatchEvent("coordinatesUpdated"),this},sigma.classes.camera.prototype.applyView=function(b,c,d){d=d||{},c=c!==a?c:this.prefix,b=b!==a?b:this.readPrefix;var e,f,g,h=d.nodes||this.graph.nodes(),i=d.edges||this.graph.edges(),j=Math.cos(this.angle),k=Math.sin(this.angle);for(e=0,f=h.length;f>e;e++)g=h[e],g[c+"x"]=(((g[b+"x"]||0)-this.x)*j+((g[b+"y"]||0)-this.y)*k)/this.ratio+(d.width||0)/2,g[c+"y"]=(((g[b+"y"]||0)-this.y)*j-((g[b+"x"]||0)-this.x)*k)/this.ratio+(d.height||0)/2,g[c+"size"]=(g[b+"size"]||0)/Math.pow(this.ratio,this.settings("nodesPowRatio"));for(e=0,f=i.length;f>e;e++)i[e][c+"size"]=(i[e][b+"size"]||0)/Math.pow(this.ratio,this.settings("edgesPowRatio"));return this},sigma.classes.camera.prototype.graphPosition=function(a,b,c){var d=0,e=0,f=Math.cos(this.angle),g=Math.sin(this.angle);return c||(d=-(this.x*f+this.y*g)/this.ratio,e=-(this.y*f-this.x*g)/this.ratio),{x:(a*f+b*g)/this.ratio+d,y:(b*f-a*g)/this.ratio+e}},sigma.classes.camera.prototype.cameraPosition=function(a,b,c){var d=0,e=0,f=Math.cos(this.angle),g=Math.sin(this.angle);return c||(d=-(this.x*f+this.y*g)/this.ratio,e=-(this.y*f-this.x*g)/this.ratio),{x:((a-d)*f-(b-e)*g)*this.ratio,y:((b-e)*f+(a-d)*g)*this.ratio}},sigma.classes.camera.prototype.getMatrix=function(){var a=sigma.utils.matrices.scale(1/this.ratio),b=sigma.utils.matrices.rotation(this.angle),c=sigma.utils.matrices.translation(-this.x,-this.y),d=sigma.utils.matrices.multiply(c,sigma.utils.matrices.multiply(b,a));return d},sigma.classes.camera.prototype.getRectangle=function(a,b){var c=this.cameraPosition(a,0,!0),d=this.cameraPosition(0,b,!0),e=this.cameraPosition(a/2,b/2,!0),f=this.cameraPosition(a/4,0,!0).x,g=this.cameraPosition(0,b/4,!0).y;return{x1:this.x-e.x-f,y1:this.y-e.y-g,x2:this.x-e.x+f+c.x,y2:this.y-e.y-g+c.y,height:Math.sqrt(Math.pow(d.x,2)+Math.pow(d.y+2*g,2))}}}.call(this),function(a){"use strict";function b(a,b){var c=b.x+b.width/2,d=b.y+b.height/2,e=a.y<d,f=a.x<c;return e?f?0:1:f?2:3}function c(a,b){for(var c=[],d=0;4>d;d++)a.x2>=b[d][0].x&&a.x1<=b[d][1].x&&a.y1+a.height>=b[d][0].y&&a.y1<=b[d][2].y&&c.push(d);return c}function d(a,b){for(var c=[],d=0;4>d;d++)j.collision(a,b[d])&&c.push(d);return c}function e(a,b){var c,d,e=b.level+1,f=Math.round(b.bounds.width/2),g=Math.round(b.bounds.height/2),h=Math.round(b.bounds.x),j=Math.round(b.bounds.y);switch(a){case 0:c=h,d=j;break;case 1:c=h+f,d=j;break;case 2:c=h,d=j+g;break;case 3:c=h+f,d=j+g}return i({x:c,y:d,width:f,height:g},e,b.maxElements,b.maxLevel)}function f(b,d,g){if(g.level<g.maxLevel)for(var h=c(d,g.corners),i=0,j=h.length;j>i;i++)g.nodes[h[i]]===a&&(g.nodes[h[i]]=e(h[i],g)),f(b,d,g.nodes[h[i]]);
+else g.elements.push(b)}function g(c,d){if(d.level<d.maxLevel){var e=b(c,d.bounds);return d.nodes[e]!==a?g(c,d.nodes[e]):[]}return d.elements}function h(b,c,d,e){if(e=e||{},c.level<c.maxLevel)for(var f=d(b,c.corners),g=0,i=f.length;i>g;g++)c.nodes[f[g]]!==a&&h(b,c.nodes[f[g]],d,e);else for(var j=0,k=c.elements.length;k>j;j++)e[c.elements[j].id]===a&&(e[c.elements[j].id]=c.elements[j]);return e}function i(a,b,c,d){return{level:b||0,bounds:a,corners:j.splitSquare(a),maxElements:c||20,maxLevel:d||4,elements:[],nodes:[]}}var j={pointToSquare:function(a){return{x1:a.x-a.size,y1:a.y-a.size,x2:a.x+a.size,y2:a.y-a.size,height:2*a.size}},isAxisAligned:function(a){return a.x1===a.x2||a.y1===a.y2},axisAlignedTopPoints:function(a){return a.y1===a.y2&&a.x1<a.x2?a:a.x1===a.x2&&a.y2>a.y1?{x1:a.x1-a.height,y1:a.y1,x2:a.x1,y2:a.y1,height:a.height}:a.x1===a.x2&&a.y2<a.y1?{x1:a.x1,y1:a.y2,x2:a.x2+a.height,y2:a.y2,height:a.height}:{x1:a.x2,y1:a.y1-a.height,x2:a.x1,y2:a.y1-a.height,height:a.height}},lowerLeftCoor:function(a){var b=Math.sqrt(Math.pow(a.x2-a.x1,2)+Math.pow(a.y2-a.y1,2));return{x:a.x1-(a.y2-a.y1)*a.height/b,y:a.y1+(a.x2-a.x1)*a.height/b}},lowerRightCoor:function(a,b){return{x:b.x-a.x1+a.x2,y:b.y-a.y1+a.y2}},rectangleCorners:function(a){var b=this.lowerLeftCoor(a),c=this.lowerRightCoor(a,b);return[{x:a.x1,y:a.y1},{x:a.x2,y:a.y2},{x:b.x,y:b.y},{x:c.x,y:c.y}]},splitSquare:function(a){return[[{x:a.x,y:a.y},{x:a.x+a.width/2,y:a.y},{x:a.x,y:a.y+a.height/2},{x:a.x+a.width/2,y:a.y+a.height/2}],[{x:a.x+a.width/2,y:a.y},{x:a.x+a.width,y:a.y},{x:a.x+a.width/2,y:a.y+a.height/2},{x:a.x+a.width,y:a.y+a.height/2}],[{x:a.x,y:a.y+a.height/2},{x:a.x+a.width/2,y:a.y+a.height/2},{x:a.x,y:a.y+a.height},{x:a.x+a.width/2,y:a.y+a.height}],[{x:a.x+a.width/2,y:a.y+a.height/2},{x:a.x+a.width,y:a.y+a.height/2},{x:a.x+a.width/2,y:a.y+a.height},{x:a.x+a.width,y:a.y+a.height}]]},axis:function(a,b){return[{x:a[1].x-a[0].x,y:a[1].y-a[0].y},{x:a[1].x-a[3].x,y:a[1].y-a[3].y},{x:b[0].x-b[2].x,y:b[0].y-b[2].y},{x:b[0].x-b[1].x,y:b[0].y-b[1].y}]},projection:function(a,b){var c=(a.x*b.x+a.y*b.y)/(Math.pow(b.x,2)+Math.pow(b.y,2));return{x:c*b.x,y:c*b.y}},axisCollision:function(a,b,c){for(var d=[],e=[],f=0;4>f;f++){var g=this.projection(b[f],a),h=this.projection(c[f],a);d.push(g.x*a.x+g.y*a.y),e.push(h.x*a.x+h.y*a.y)}var i=Math.max.apply(Math,d),j=Math.max.apply(Math,e),k=Math.min.apply(Math,d),l=Math.min.apply(Math,e);return i>=l&&j>=k},collision:function(a,b){for(var c=this.axis(a,b),d=!0,e=0;4>e;e++)d*=this.axisCollision(c[e],a,b);return!!d}},k=function(){this._geom=j,this._tree=null,this._cache={query:!1,result:!1}};k.prototype.index=function(a,b){if(!b.bounds)throw"sigma.classes.quad.index: bounds information not given.";var c=b.prefix||"";this._tree=i(b.bounds,0,b.maxElements,b.maxLevel);for(var d=0,e=a.length;e>d;d++)f(a[d],j.pointToSquare({x:a[d][c+"x"],y:a[d][c+"y"],size:a[d][c+"size"]}),this._tree);return this._cache={query:!1,result:!1},this._tree},k.prototype.point=function(a,b){return this._tree?g({x:a,y:b},this._tree)||[]:[]},k.prototype.area=function(a){var b,e,f=JSON.stringify(a);if(this._cache.query===f)return this._cache.result;j.isAxisAligned(a)?(b=c,e=j.axisAlignedTopPoints(a)):(b=d,e=j.rectangleCorners(a));var g=this._tree?h(e,this._tree,b):[],i=[];for(var k in g)i.push(g[k]);return this._cache.query=f,this._cache.result=i,i},"undefined"!=typeof this.sigma?(this.sigma.classes=this.sigma.classes||{},this.sigma.classes.quad=k):"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=k),exports.quad=k):this.quad=k}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.captors"),sigma.captors.mouse=function(a,b,c){function d(a){var b,c,d;return w("mouseEnabled")&&t.dispatchEvent("mousemove",{x:sigma.utils.getX(a)-a.target.width/2,y:sigma.utils.getY(a)-a.target.height/2}),w("mouseEnabled")&&q?(r=!0,s&&clearTimeout(s),s=setTimeout(function(){r=!1},w("dragTimeout")),sigma.misc.animation.killAll(v),v.isMoving=!0,d=v.cameraPosition(sigma.utils.getX(a)-o,sigma.utils.getY(a)-p,!0),b=k-d.x,c=l-d.y,(b!==v.x||c!==v.y)&&(m=v.x,n=v.y,v.goTo({x:b,y:c})),a.preventDefault?a.preventDefault():a.returnValue=!1,a.stopPropagation(),!1):void 0}function e(a){if(w("mouseEnabled")&&q){q=!1,s&&clearTimeout(s),v.isMoving=!1;var b=sigma.utils.getX(a),c=sigma.utils.getY(a);r?(sigma.misc.animation.killAll(v),sigma.misc.animation.camera(v,{x:v.x+w("mouseInertiaRatio")*(v.x-m),y:v.y+w("mouseInertiaRatio")*(v.y-n)},{easing:"quadraticOut",duration:w("mouseInertiaDuration")})):(o!==b||p!==c)&&v.goTo({x:v.x,y:v.y}),t.dispatchEvent("mouseup",{x:b-a.target.width/2,y:c-a.target.height/2}),r=!1}}function f(a){w("mouseEnabled")&&(q=!0,k=v.x,l=v.y,m=v.x,n=v.y,o=sigma.utils.getX(a),p=sigma.utils.getY(a),t.dispatchEvent("mouseup",{x:o-a.target.width/2,y:p-a.target.height/2}))}function g(){w("mouseEnabled")&&t.dispatchEvent("mouseout")}function h(a){return w("mouseEnabled")&&t.dispatchEvent("click",{x:sigma.utils.getX(a)-a.target.width/2,y:sigma.utils.getY(a)-a.target.height/2}),a.preventDefault?a.preventDefault():a.returnValue=!1,a.stopPropagation(),!1}function i(a){var b,c,d,e;return w("mouseEnabled")?(d=1/w("doubleClickZoomingRatio"),e=Math.max(w("zoomMin"),Math.min(w("zoomMax"),v.ratio*d)),d=e/v.ratio,t.dispatchEvent("doubleclick",{x:o-a.target.width/2,y:p-a.target.height/2}),w("doubleClickEnabled")&&e!==v.ratio&&(c=sigma.misc.animation.killAll(v),b=v.cameraPosition(sigma.utils.getX(a)-a.target.width/2,sigma.utils.getY(a)-a.target.height/2,!0),sigma.misc.animation.camera(v,{x:b.x*(1-d)+v.x,y:b.y*(1-d)+v.y,ratio:e},{easing:c?"quadraticOut":"quadraticInOut",duration:w("doubleClickZoomDuration")})),a.preventDefault?a.preventDefault():a.returnValue=!1,a.stopPropagation(),!1):void 0}function j(a){var b,c,d,e;return w("mouseEnabled")?(d=sigma.utils.getDelta(a)>0?1/w("zoomingRatio"):w("zoomingRatio"),e=Math.max(w("zoomMin"),Math.min(w("zoomMax"),v.ratio*d)),d=e/v.ratio,e!==v.ratio&&(c=sigma.misc.animation.killAll(v),b=v.cameraPosition(sigma.utils.getX(a)-a.target.width/2,sigma.utils.getY(a)-a.target.height/2,!0),sigma.misc.animation.camera(v,{x:b.x*(1-d)+v.x,y:b.y*(1-d)+v.y,ratio:e},{easing:c?"quadraticOut":"quadraticInOut",duration:w("mouseZoomDuration")})),a.preventDefault?a.preventDefault():a.returnValue=!1,a.stopPropagation(),!1):void 0}var k,l,m,n,o,p,q,r,s,t=this,u=a,v=b,w=c;sigma.classes.dispatcher.extend(this),sigma.utils.doubleClick(u,"click",i),u.addEventListener("DOMMouseScroll",j,!1),u.addEventListener("mousewheel",j,!1),u.addEventListener("mousemove",d,!1),u.addEventListener("mousedown",f,!1),u.addEventListener("click",h,!1),u.addEventListener("mouseout",g,!1),document.addEventListener("mouseup",e,!1),this.kill=function(){sigma.utils.unbindDoubleClick(u,"click"),u.removeEventListener("DOMMouseScroll",j),u.removeEventListener("mousewheel",j),u.removeEventListener("mousemove",d),u.removeEventListener("mousedown",f),u.removeEventListener("click",h),u.removeEventListener("mouseout",g),document.removeEventListener("mouseup",e)}}}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.captors"),sigma.captors.touch=function(a,b,c){function d(a){var b=sigma.utils.getOffset(B);return{x:a.pageX-b.left,y:a.pageY-b.top}}function e(a){if(D("touchEnabled")){var b,c,e,f,g,h;switch(E=a.touches,E.length){case 1:C.isMoving=!0,w=1,i=C.x,j=C.y,m=C.x,n=C.y,g=d(E[0]),q=g.x,r=g.y;break;case 2:return C.isMoving=!0,w=2,g=d(E[0]),h=d(E[1]),b=g.x,e=g.y,c=h.x,f=h.y,m=C.x,n=C.y,k=C.angle,l=C.ratio,i=C.x,j=C.y,q=b,r=e,s=c,t=f,u=Math.atan2(t-r,s-q),v=Math.sqrt(Math.pow(t-r,2)+Math.pow(s-q,2)),a.preventDefault(),!1}}}function f(a){if(D("touchEnabled")){E=a.touches;var b=D("touchInertiaRatio");switch(z&&(x=!1,clearTimeout(z)),w){case 2:if(1===a.touches.length){e(a),a.preventDefault();break}case 1:C.isMoving=!1,A.dispatchEvent("stopDrag"),x&&(y=!1,sigma.misc.animation.camera(C,{x:C.x+b*(C.x-m),y:C.y+b*(C.y-n)},{easing:"quadraticOut",duration:D("touchInertiaDuration")})),x=!1,w=0}}}function g(a){if(!y&&D("touchEnabled")){var b,c,e,f,g,h,B,F,G,H,I,J,K,L,M,N,O;switch(E=a.touches,x=!0,z&&clearTimeout(z),z=setTimeout(function(){x=!1},D("dragTimeout")),w){case 1:F=d(E[0]),b=F.x,e=F.y,H=C.cameraPosition(b-q,e-r,!0),L=i-H.x,M=j-H.y,(L!==C.x||M!==C.y)&&(m=C.x,n=C.y,C.goTo({x:L,y:M}),A.dispatchEvent("mousemove",{x:F.x-a.target.width/2,y:F.y-a.target.height/2}),A.dispatchEvent("drag"));break;case 2:F=d(E[0]),G=d(E[1]),b=F.x,e=F.y,c=G.x,f=G.y,I=C.cameraPosition((q+s)/2-a.target.width/2,(r+t)/2-a.target.height/2,!0),B=C.cameraPosition((b+c)/2-a.target.width/2,(e+f)/2-a.target.height/2,!0),J=Math.atan2(f-e,c-b)-u,K=Math.sqrt(Math.pow(f-e,2)+Math.pow(c-b,2))/v,b=I.x,e=I.y,N=l/K,b*=K,e*=K,O=k-J,g=Math.cos(-J),h=Math.sin(-J),c=b*g+e*h,f=e*g-b*h,b=c,e=f,L=b-B.x+i,M=e-B.y+j,(N!==C.ratio||O!==C.angle||L!==C.x||M!==C.y)&&(m=C.x,n=C.y,o=C.angle,p=C.ratio,C.goTo({x:L,y:M,angle:O,ratio:N}),A.dispatchEvent("drag"))}return a.preventDefault(),!1}}function h(a){var b,c,e,f;return a.touches&&1===a.touches.length&&D("touchEnabled")?(y=!0,e=1/D("doubleClickZoomingRatio"),f=Math.max(D("zoomMin"),Math.min(D("zoomMax"),C.ratio*e)),e=f/C.ratio,b=d(a.touches[0]),A.dispatchEvent("doubleclick",{x:b.x-a.target.width/2,y:b.y-a.target.height/2}),D("doubleClickEnabled")&&f!==C.ratio&&(c=sigma.misc.animation.killAll(C),b=C.cameraPosition(b.x-a.target.width/2,b.y-a.target.height/2,!0),sigma.misc.animation.camera(C,{x:b.x*(1-e)+C.x,y:b.y*(1-e)+C.y,ratio:f},{easing:c?"quadraticOut":"quadraticInOut",duration:D("doubleClickZoomDuration"),onComplete:function(){y=!1}})),a.preventDefault?a.preventDefault():a.returnValue=!1,a.stopPropagation(),!1):void 0}var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A=this,B=a,C=b,D=c,E=[];sigma.classes.dispatcher.extend(this),sigma.utils.doubleClick(B,"touchstart",h),B.addEventListener("touchstart",e,!1),B.addEventListener("touchend",f,!1),B.addEventListener("touchcancel",f,!1),B.addEventListener("touchleave",f,!1),B.addEventListener("touchmove",g,!1),this.kill=function(){sigma.utils.unbindDoubleClick(B,"touchstart"),B.addEventListener("touchstart",e),B.addEventListener("touchend",f),B.addEventListener("touchcancel",f),B.addEventListener("touchleave",f),B.addEventListener("touchmove",g)}}}.call(this),function(a){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";if("undefined"==typeof conrad)throw"conrad is not declared";sigma.utils.pkg("sigma.renderers"),sigma.renderers.canvas=function(a,b,c,d){if("object"!=typeof d)throw"sigma.renderers.canvas: Wrong arguments.";if(!(d.container instanceof HTMLElement))throw"Container not found.";var e,f,g,h;for(sigma.classes.dispatcher.extend(this),Object.defineProperty(this,"conradId",{value:sigma.utils.id()}),this.graph=a,this.camera=b,this.contexts={},this.domElements={},this.options=d,this.container=this.options.container,this.settings="object"==typeof d.settings&&d.settings?c.embedObjects(d.settings):c,this.nodesOnScreen=[],this.edgesOnScreen=[],this.jobs={},this.options.prefix="renderer"+this.conradId+":",this.settings("batchEdgesDrawing")?(this.initDOM("canvas","edges"),this.initDOM("canvas","scene"),this.contexts.nodes=this.contexts.scene,this.contexts.labels=this.contexts.scene):(this.initDOM("canvas","scene"),this.contexts.edges=this.contexts.scene,this.contexts.nodes=this.contexts.scene,this.contexts.labels=this.contexts.scene),this.initDOM("canvas","mouse"),this.contexts.hover=this.contexts.mouse,this.captors=[],g=this.options.captors||[sigma.captors.mouse,sigma.captors.touch],e=0,f=g.length;f>e;e++)h="function"==typeof g[e]?g[e]:sigma.captors[g[e]],this.captors.push(new h(this.domElements.mouse,this.camera,this.settings));window.addEventListener("resize",this.boundResize=this.resize.bind(this),!1),sigma.misc.bindEvents.call(this,this.options.prefix),sigma.misc.drawHovers.call(this,this.options.prefix),this.resize(!1)},sigma.renderers.canvas.prototype.render=function(b){b=b||{};var c,d,e,f,g,h,i,j,k,l,m,n,o={},p=this.graph,q=this.graph.nodes,r=(this.options.prefix||"",this.settings(b,"drawEdges")),s=this.settings(b,"drawNodes"),t=this.settings(b,"drawLabels"),u=this.settings.embedObjects(b,{prefix:this.options.prefix});this.settings(b,"hideEdgesOnMove")&&(this.camera.isAnimated||this.camera.isMoving)&&(r=!1),this.camera.applyView(a,this.options.prefix,{width:this.width,height:this.height}),this.clear();for(e in this.jobs)conrad.hasJob(e)&&conrad.killJob(e);for(this.edgesOnScreen=[],this.nodesOnScreen=this.camera.quadtree.area(this.camera.getRectangle(this.width,this.height)),c=this.nodesOnScreen,d=0,f=c.length;f>d;d++)o[c[d].id]=c[d];if(r){for(c=p.edges(),d=0,f=c.length;f>d;d++)g=c[d],!o[g.source]&&!o[g.target]||g.hidden||q(g.source).hidden||q(g.target).hidden||this.edgesOnScreen.push(g);if(this.settings(b,"batchEdgesDrawing"))h="edges_"+this.conradId,n=u("canvasEdgesBatchSize"),l=this.edgesOnScreen,f=l.length,k=0,i=Math.min(l.length,k+n),j=function(){for(m=sigma.canvas.edges,d=k;i>d;d++)g=l[d],(m[g.type]||m.def)(g,p.nodes(g.source),p.nodes(g.target),this.contexts.edges,u);return i===l.length?(delete this.jobs[h],!1):(k=i+1,i=Math.min(l.length,k+n),!0)},this.jobs[h]=j,conrad.addJob(h,j.bind(this));else for(m=sigma.canvas.edges,c=this.edgesOnScreen,d=0,f=c.length;f>d;d++)g=c[d],(m[g.type]||m.def)(g,p.nodes(g.source),p.nodes(g.target),this.contexts.edges,u)}if(s)for(m=sigma.canvas.nodes,c=this.nodesOnScreen,d=0,f=c.length;f>d;d++)c[d].hidden||(m[c[d].type]||m.def)(c[d],this.contexts.nodes,u);if(t)for(m=sigma.canvas.labels,c=this.nodesOnScreen,d=0,f=c.length;f>d;d++)c[d].hidden||(m[c[d].type]||m.def)(c[d],this.contexts.labels,u);return this.dispatchEvent("render"),this},sigma.renderers.canvas.prototype.initDOM=function(a,b){var c=document.createElement(a);c.style.position="absolute",c.setAttribute("class","sigma-"+b),this.domElements[b]=c,this.container.appendChild(c),"canvas"===a.toLowerCase()&&(this.contexts[b]=c.getContext("2d"))},sigma.renderers.canvas.prototype.resize=function(b,c){var d,e=this.width,f=this.height,g=1;if(b!==a&&c!==a?(this.width=b,this.height=c):(this.width=this.container.offsetWidth,this.height=this.container.offsetHeight,b=this.width,c=this.height),e!==this.width||f!==this.height)for(d in this.domElements)this.domElements[d].style.width=b+"px",this.domElements[d].style.height=c+"px","canvas"===this.domElements[d].tagName.toLowerCase()&&(this.domElements[d].setAttribute("width",b*g+"px"),this.domElements[d].setAttribute("height",c*g+"px"),1!==g&&this.contexts[d].scale(g,g));return this},sigma.renderers.canvas.prototype.clear=function(){var a;for(a in this.domElements)"CANVAS"===this.domElements[a].tagName&&(this.domElements[a].width=this.domElements[a].width);return this},sigma.renderers.canvas.prototype.kill=function(){var a,b;for(window.removeEventListener("resize",this.boundResize);b=this.captors.pop();)b.kill();delete this.captors;for(a in this.domElements)this.domElements[a].parentNode.removeChild(this.domElements[a]),delete this.domElements[a],delete this.contexts[a];delete this.domElements,delete this.contexts},sigma.utils.pkg("sigma.canvas.nodes"),sigma.utils.pkg("sigma.canvas.edges"),sigma.utils.pkg("sigma.canvas.labels")}.call(this),function(a){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.renderers"),sigma.renderers.webgl=function(a,b,c,d){if("object"!=typeof d)throw"sigma.renderers.webgl: Wrong arguments.";if(!(d.container instanceof HTMLElement))throw"Container not found.";var e,f,g,h;for(sigma.classes.dispatcher.extend(this),this.jobs={},Object.defineProperty(this,"conradId",{value:sigma.utils.id()}),this.graph=a,this.camera=b,this.contexts={},this.domElements={},this.options=d,this.container=this.options.container,this.settings="object"==typeof d.settings&&d.settings?c.embedObjects(d.settings):c,this.options.prefix=this.camera.readPrefix,Object.defineProperty(this,"nodePrograms",{value:{}}),Object.defineProperty(this,"edgePrograms",{value:{}}),Object.defineProperty(this,"nodeFloatArrays",{value:{}}),Object.defineProperty(this,"edgeFloatArrays",{value:{}}),this.settings(d,"batchEdgesDrawing")?(this.initDOM("canvas","edges",!0),this.initDOM("canvas","nodes",!0)):(this.initDOM("canvas","scene",!0),this.contexts.nodes=this.contexts.scene,this.contexts.edges=this.contexts.scene),this.initDOM("canvas","labels"),this.initDOM("canvas","mouse"),this.contexts.hover=this.contexts.mouse,this.captors=[],g=this.options.captors||[sigma.captors.mouse,sigma.captors.touch],e=0,f=g.length;f>e;e++)h="function"==typeof g[e]?g[e]:sigma.captors[g[e]],this.captors.push(new h(this.domElements.mouse,this.camera,this.settings));window.addEventListener("resize",this.boundResize=this.resize.bind(this),!1),sigma.misc.bindEvents.call(this,this.camera.prefix),sigma.misc.drawHovers.call(this,this.camera.prefix),this.resize()},sigma.renderers.webgl.prototype.process=function(){var a,b,c,d,e,f=this.graph,g=sigma.utils.extend(g,this.options);for(d in this.nodeFloatArrays)delete this.nodeFloatArrays[d];for(d in this.edgeFloatArrays)delete this.edgeFloatArrays[d];for(a=f.edges(),b=0,c=a.length;c>b;b++)d=a[b].type&&sigma.webgl.edges[a[b].type]?a[b].type:"def",this.edgeFloatArrays[d]||(this.edgeFloatArrays[d]={edges:[]}),this.edgeFloatArrays[d].edges.push(a[b]);for(a=f.nodes(),b=0,c=a.length;c>b;b++)d=a[b].type&&sigma.webgl.nodes[a[b].type]?d:"def",this.nodeFloatArrays[d]||(this.nodeFloatArrays[d]={nodes:[]}),this.nodeFloatArrays[d].nodes.push(a[b]);for(d in this.edgeFloatArrays)for(e=sigma.webgl.edges[d],a=this.edgeFloatArrays[d].edges,b=0,c=a.length;c>b;b++)this.edgeFloatArrays[d].array||(this.edgeFloatArrays[d].array=new Float32Array(a.length*e.POINTS*e.ATTRIBUTES)),a[b].hidden||f.nodes(a[b].source).hidden||f.nodes(a[b].target).hidden||e.addEdge(a[b],f.nodes(a[b].source),f.nodes(a[b].target),this.edgeFloatArrays[d].array,b*e.POINTS*e.ATTRIBUTES,g.prefix,this.settings);for(d in this.nodeFloatArrays)for(e=sigma.webgl.nodes[d],a=this.nodeFloatArrays[d].nodes,b=0,c=a.length;c>b;b++)this.nodeFloatArrays[d].array||(this.nodeFloatArrays[d].array=new Float32Array(a.length*e.POINTS*e.ATTRIBUTES)),a[b].hidden||e.addNode(a[b],this.nodeFloatArrays[d].array,b*e.POINTS*e.ATTRIBUTES,g.prefix,this.settings);return this},sigma.renderers.webgl.prototype.render=function(b){var c,d,e,f,g,h,i=this,j=(this.graph,this.contexts.nodes),k=this.contexts.edges,l=this.camera.getMatrix(),m=sigma.utils.extend(b,this.options),n=this.settings(m,"drawLabels"),o=this.settings(m,"drawEdges"),p=this.settings(m,"drawNodes");this.settings(m,"hideEdgesOnMove")&&(this.camera.isAnimated||this.camera.isMoving)&&(o=!1),this.clear(),l=sigma.utils.matrices.multiply(l,sigma.utils.matrices.translation(this.width/2,this.height/2));for(f in this.jobs)conrad.hasJob(f)&&conrad.killJob(f);if(o)if(this.settings(m,"batchEdgesDrawing"))(function(){var a,b,c,d,e,f,g,h,i;c="edges_"+this.conradId,i=this.settings(m,"webglEdgesBatchSize"),a=Object.keys(this.edgeFloatArrays),a.length&&(b=0,h=sigma.webgl.edges[a[b]],e=this.edgeFloatArrays[a[b]].array,g=0,f=Math.min(g+i*h.POINTS,e.length/h.ATTRIBUTES),d=function(){return this.edgePrograms[a[b]]||(this.edgePrograms[a[b]]=h.initProgram(k)),f>g&&(k.useProgram(this.edgePrograms[a[b]]),h.render(k,this.edgePrograms[a[b]],e,{settings:this.settings,matrix:l,width:this.width,height:this.height,ratio:this.camera.ratio,scalingRatio:this.settings("webglOversamplingRatio"),start:g,count:f-g})),f>=e.length/h.ATTRIBUTES&&b===a.length-1?(delete this.jobs[c],!1):(f>=e.length/h.ATTRIBUTES?(b++,e=this.edgeFloatArrays[a[b]].array,h=sigma.webgl.edges[a[b]],g=0,f=Math.min(g+i*h.POINTS,e.length/h.ATTRIBUTES)):(g=f,f=Math.min(g+i*h.POINTS,e.length/h.ATTRIBUTES)),!0)},this.jobs[c]=d,conrad.addJob(c,d.bind(this)))}).call(this);else for(f in this.edgeFloatArrays)h=sigma.webgl.edges[f],this.edgePrograms[f]||(this.edgePrograms[f]=h.initProgram(k)),this.edgeFloatArrays[f]&&(k.useProgram(this.edgePrograms[f]),h.render(k,this.edgePrograms[f],this.edgeFloatArrays[f].array,{settings:this.settings,matrix:l,width:this.width,height:this.height,ratio:this.camera.ratio,scalingRatio:this.settings("webglOversamplingRatio")}));if(p){j.blendFunc(j.SRC_ALPHA,j.ONE_MINUS_SRC_ALPHA),j.enable(j.BLEND);for(f in this.nodeFloatArrays)h=sigma.webgl.nodes[f],this.nodePrograms[f]||(this.nodePrograms[f]=h.initProgram(j)),this.nodeFloatArrays[f]&&(j.useProgram(this.nodePrograms[f]),h.render(j,this.nodePrograms[f],this.nodeFloatArrays[f].array,{settings:this.settings,matrix:l,width:this.width,height:this.height,ratio:this.camera.ratio,scalingRatio:this.settings("webglOversamplingRatio")}))}if(n)for(c=this.camera.quadtree.area(this.camera.getRectangle(this.width,this.height)),this.camera.applyView(a,a,{nodes:c,edges:[],width:this.width,height:this.height}),g=function(a){return i.settings({prefix:i.camera.prefix},a)},d=0,e=c.length;e>d;d++)c[d].hidden||(sigma.canvas.labels[c[d].type]||sigma.canvas.labels.def)(c[d],this.contexts.labels,g);return this.dispatchEvent("render"),this},sigma.renderers.webgl.prototype.initDOM=function(a,b,c){var d=document.createElement(a);d.style.position="absolute",d.setAttribute("class","sigma-"+b),this.domElements[b]=d,this.container.appendChild(d),"canvas"===a.toLowerCase()&&(this.contexts[b]=d.getContext(c?"experimental-webgl":"2d",{preserveDrawingBuffer:!0}))},sigma.renderers.webgl.prototype.resize=function(b,c){var d,e=this.width,f=this.height;if(b!==a&&c!==a?(this.width=b,this.height=c):(this.width=this.container.offsetWidth,this.height=this.container.offsetHeight,b=this.width,c=this.height),e!==this.width||f!==this.height)for(d in this.domElements)this.domElements[d].style.width=b+"px",this.domElements[d].style.height=c+"px","canvas"===this.domElements[d].tagName.toLowerCase()&&(this.contexts[d]&&this.contexts[d].scale?(this.domElements[d].setAttribute("width",b+"px"),this.domElements[d].setAttribute("height",c+"px")):(this.domElements[d].setAttribute("width",b*this.settings("webglOversamplingRatio")+"px"),this.domElements[d].setAttribute("height",c*this.settings("webglOversamplingRatio")+"px")));for(d in this.contexts)this.contexts[d]&&this.contexts[d].viewport&&this.contexts[d].viewport(0,0,this.width*this.settings("webglOversamplingRatio"),this.height*this.settings("webglOversamplingRatio"));return this},sigma.renderers.webgl.prototype.clear=function(){var a;for(a in this.domElements)"CANVAS"===this.domElements[a].tagName&&(this.domElements[a].width=this.domElements[a].width);return this.contexts.nodes.clear(this.contexts.nodes.COLOR_BUFFER_BIT),this.contexts.edges.clear(this.contexts.edges.COLOR_BUFFER_BIT),this},sigma.renderers.webgl.prototype.kill=function(){var a,b;for(window.removeEventListener("resize",this.boundResize);b=this.captors.pop();)b.kill();delete this.captors;for(a in this.domElements)this.domElements[a].parentNode.removeChild(this.domElements[a]),delete this.domElements[a],delete this.contexts[a];delete this.domElements,delete this.contexts},sigma.utils.pkg("sigma.webgl.nodes"),sigma.utils.pkg("sigma.webgl.edges"),sigma.utils.pkg("sigma.canvas.labels")}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.renderers");var a,b=!!window.WebGLRenderingContext;b&&(a=document.createElement("canvas"),b=!(!a.getContext("webgl")&&!a.getContext("experimental-webgl"))),sigma.renderers.def=b?sigma.renderers.webgl:sigma.renderers.canvas}.call(this),function(){"use strict";sigma.utils.pkg("sigma.webgl.nodes"),sigma.webgl.nodes.def={POINTS:3,ATTRIBUTES:5,addNode:function(a,b,c,d,e){var f=sigma.utils.floatColor(a.color||e("defaultNodeColor"));b[c++]=a[d+"x"],b[c++]=a[d+"y"],b[c++]=a[d+"size"],b[c++]=f,b[c++]=0,b[c++]=a[d+"x"],b[c++]=a[d+"y"],b[c++]=a[d+"size"],b[c++]=f,b[c++]=2*Math.PI/3,b[c++]=a[d+"x"],b[c++]=a[d+"y"],b[c++]=a[d+"size"],b[c++]=f,b[c++]=4*Math.PI/3},render:function(a,b,c,d){var e,f=a.getAttribLocation(b,"a_position"),g=a.getAttribLocation(b,"a_size"),h=a.getAttribLocation(b,"a_color"),i=a.getAttribLocation(b,"a_angle"),j=a.getUniformLocation(b,"u_resolution"),k=a.getUniformLocation(b,"u_matrix"),l=a.getUniformLocation(b,"u_ratio"),m=a.getUniformLocation(b,"u_scale");e=a.createBuffer(),a.bindBuffer(a.ARRAY_BUFFER,e),a.bufferData(a.ARRAY_BUFFER,c,a.DYNAMIC_DRAW),a.uniform2f(j,d.width,d.height),a.uniform1f(l,1/Math.pow(d.ratio,d.settings("nodesPowRatio"))),a.uniform1f(m,d.scalingRatio),a.uniformMatrix3fv(k,!1,d.matrix),a.enableVertexAttribArray(f),a.enableVertexAttribArray(g),a.enableVertexAttribArray(h),a.enableVertexAttribArray(i),a.vertexAttribPointer(f,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,0),a.vertexAttribPointer(g,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,8),a.vertexAttribPointer(h,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,12),a.vertexAttribPointer(i,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,16),a.drawArrays(a.TRIANGLES,d.start||0,d.count||c.length/this.ATTRIBUTES)},initProgram:function(a){var b,c,d;return b=sigma.utils.loadShader(a,["attribute vec2 a_position;","attribute float a_size;","attribute float a_color;","attribute float a_angle;","uniform vec2 u_resolution;","uniform float u_ratio;","uniform float u_scale;","uniform mat3 u_matrix;","varying vec4 color;","varying vec2 center;","varying float radius;","void main() {","radius = a_size * u_ratio;","vec2 position = (u_matrix * vec3(a_position, 1)).xy;","center = position * u_scale;","center = vec2(center.x, u_scale * u_resolution.y - center.y);","position = position +","2.0 * radius * vec2(cos(a_angle), sin(a_angle));","position = (position / u_resolution * 2.0 - 1.0) * vec2(1, -1);","radius = radius * u_scale;","gl_Position = vec4(position, 0, 1);","float c = a_color;","color.b = mod(c, 256.0); c = floor(c / 256.0);","color.g = mod(c, 256.0); c = floor(c / 256.0);","color.r = mod(c, 256.0); c = floor(c / 256.0); color /= 255.0;","color.a = 1.0;","}"].join("\n"),a.VERTEX_SHADER),c=sigma.utils.loadShader(a,["precision mediump float;","varying vec4 color;","varying vec2 center;","varying float radius;","void main(void) {","vec4 color0 = vec4(0.0, 0.0, 0.0, 0.0);","vec2 m = gl_FragCoord.xy - center;","float diff = radius - sqrt(m.x * m.x + m.y * m.y);","if (diff > 0.0)","gl_FragColor = color;","else","gl_FragColor = color0;","}"].join("\n"),a.FRAGMENT_SHADER),d=sigma.utils.loadProgram(a,[b,c])}}}(),function(){"use strict";sigma.utils.pkg("sigma.webgl.nodes"),sigma.webgl.nodes.fast={POINTS:1,ATTRIBUTES:4,addNode:function(a,b,c,d,e){b[c++]=a[d+"x"],b[c++]=a[d+"y"],b[c++]=a[d+"size"],b[c++]=sigma.utils.floatColor(a.color||e("defaultNodeColor"))},render:function(a,b,c,d){var e,f=a.getAttribLocation(b,"a_position"),g=a.getAttribLocation(b,"a_size"),h=a.getAttribLocation(b,"a_color"),i=a.getUniformLocation(b,"u_resolution"),j=a.getUniformLocation(b,"u_matrix"),k=a.getUniformLocation(b,"u_ratio"),l=a.getUniformLocation(b,"u_scale");e=a.createBuffer(),a.bindBuffer(a.ARRAY_BUFFER,e),a.bufferData(a.ARRAY_BUFFER,c,a.DYNAMIC_DRAW),a.uniform2f(i,d.width,d.height),a.uniform1f(k,1/Math.pow(d.ratio,d.settings("nodesPowRatio"))),a.uniform1f(l,d.scalingRatio),a.uniformMatrix3fv(j,!1,d.matrix),a.enableVertexAttribArray(f),a.enableVertexAttribArray(g),a.enableVertexAttribArray(h),a.vertexAttribPointer(f,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,0),a.vertexAttribPointer(g,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,8),a.vertexAttribPointer(h,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,12),a.drawArrays(a.POINTS,d.start||0,d.count||c.length/this.ATTRIBUTES)},initProgram:function(a){var b,c,d;return b=sigma.utils.loadShader(a,["attribute vec2 a_position;","attribute float a_size;","attribute float a_color;","uniform vec2 u_resolution;","uniform float u_ratio;","uniform float u_scale;","uniform mat3 u_matrix;","varying vec4 color;","void main() {","gl_Position = vec4(","((u_matrix * vec3(a_position, 1)).xy /","u_resolution * 2.0 - 1.0) * vec2(1, -1),","0,","1",");","gl_PointSize = a_size * u_ratio * u_scale * 2.0;","float c = a_color;","color.b = mod(c, 256.0); c = floor(c / 256.0);","color.g = mod(c, 256.0); c = floor(c / 256.0);","color.r = mod(c, 256.0); c = floor(c / 256.0); color /= 255.0;","color.a = 1.0;","}"].join("\n"),a.VERTEX_SHADER),c=sigma.utils.loadShader(a,["precision mediump float;","varying vec4 color;","void main(void) {","gl_FragColor = color;","}"].join("\n"),a.FRAGMENT_SHADER),d=sigma.utils.loadProgram(a,[b,c])}}}(),function(){"use strict";sigma.utils.pkg("sigma.webgl.edges"),sigma.webgl.edges.def={POINTS:6,ATTRIBUTES:7,addEdge:function(a,b,c,d,e,f,g){var h=(a[f+"size"]||1)/2,i=b[f+"x"],j=b[f+"y"],k=c[f+"x"],l=c[f+"y"],m=a.color;if(!m)switch(g("edgeColor")){case"source":m=b.color||g("defaultNodeColor");break;case"target":m=c.color||g("defaultNodeColor");break;default:m=g("defaultEdgeColor")}m=sigma.utils.floatColor(m),d[e++]=i,d[e++]=j,d[e++]=k,d[e++]=l,d[e++]=h,d[e++]=0,d[e++]=m,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=1,d[e++]=m,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=0,d[e++]=m,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=0,d[e++]=m,d[e++]=i,d[e++]=j,d[e++]=k,d[e++]=l,d[e++]=h,d[e++]=1,d[e++]=m,d[e++]=i,d[e++]=j,d[e++]=k,d[e++]=l,d[e++]=h,d[e++]=0,d[e++]=m},render:function(a,b,c,d){var e,f=a.getAttribLocation(b,"a_color"),g=a.getAttribLocation(b,"a_position1"),h=a.getAttribLocation(b,"a_position2"),i=a.getAttribLocation(b,"a_thickness"),j=a.getAttribLocation(b,"a_minus"),k=a.getUniformLocation(b,"u_resolution"),l=a.getUniformLocation(b,"u_matrix"),m=a.getUniformLocation(b,"u_matrixHalfPi"),n=a.getUniformLocation(b,"u_matrixHalfPiMinus"),o=a.getUniformLocation(b,"u_ratio"),p=a.getUniformLocation(b,"u_scale");e=a.createBuffer(),a.bindBuffer(a.ARRAY_BUFFER,e),a.bufferData(a.ARRAY_BUFFER,c,a.STATIC_DRAW),a.uniform2f(k,d.width,d.height),a.uniform1f(o,d.ratio/Math.pow(d.ratio,d.settings("edgesPowRatio"))),a.uniform1f(p,d.scalingRatio),a.uniformMatrix3fv(l,!1,d.matrix),a.uniformMatrix2fv(m,!1,sigma.utils.matrices.rotation(Math.PI/2,!0)),a.uniformMatrix2fv(n,!1,sigma.utils.matrices.rotation(-Math.PI/2,!0)),a.enableVertexAttribArray(f),a.enableVertexAttribArray(g),a.enableVertexAttribArray(h),a.enableVertexAttribArray(i),a.enableVertexAttribArray(j),a.vertexAttribPointer(g,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,0),a.vertexAttribPointer(h,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,8),a.vertexAttribPointer(i,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,16),a.vertexAttribPointer(j,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,20),a.vertexAttribPointer(f,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,24),a.drawArrays(a.TRIANGLES,d.start||0,d.count||c.length/this.ATTRIBUTES)},initProgram:function(a){var b,c,d;return b=sigma.utils.loadShader(a,["attribute vec2 a_position1;","attribute vec2 a_position2;","attribute float a_thickness;","attribute float a_minus;","attribute float a_color;","uniform vec2 u_resolution;","uniform float u_ratio;","uniform float u_scale;","uniform mat3 u_matrix;","uniform mat2 u_matrixHalfPi;","uniform mat2 u_matrixHalfPiMinus;","varying vec4 color;","void main() {","vec2 position = a_thickness * u_ratio *","normalize(a_position2 - a_position1);","mat2 matrix = a_minus * u_matrixHalfPiMinus +","(1.0 - a_minus) * u_matrixHalfPi;","position = matrix * position + a_position1;","gl_Position = vec4(","((u_matrix * vec3(position, 1)).xy /","u_resolution * 2.0 - 1.0) * vec2(1, -1),","0,","1",");","float c = a_color;","color.b = mod(c, 256.0); c = floor(c / 256.0);","color.g = mod(c, 256.0); c = floor(c / 256.0);","color.r = mod(c, 256.0); c = floor(c / 256.0); color /= 255.0;","color.a = 1.0;","}"].join("\n"),a.VERTEX_SHADER),c=sigma.utils.loadShader(a,["precision mediump float;","varying vec4 color;","void main(void) {","gl_FragColor = color;","}"].join("\n"),a.FRAGMENT_SHADER),d=sigma.utils.loadProgram(a,[b,c])
+}}}(),function(){"use strict";sigma.utils.pkg("sigma.webgl.edges"),sigma.webgl.edges.fast={POINTS:2,ATTRIBUTES:3,addEdge:function(a,b,c,d,e,f,g){var h=((a[f+"size"]||1)/2,b[f+"x"]),i=b[f+"y"],j=c[f+"x"],k=c[f+"y"],l=a.color;if(!l)switch(g("edgeColor")){case"source":l=b.color||g("defaultNodeColor");break;case"target":l=c.color||g("defaultNodeColor");break;default:l=g("defaultEdgeColor")}l=sigma.utils.floatColor(l),d[e++]=h,d[e++]=i,d[e++]=l,d[e++]=j,d[e++]=k,d[e++]=l},render:function(a,b,c,d){var e,f=a.getAttribLocation(b,"a_color"),g=a.getAttribLocation(b,"a_position"),h=a.getUniformLocation(b,"u_resolution"),i=a.getUniformLocation(b,"u_matrix");e=a.createBuffer(),a.bindBuffer(a.ARRAY_BUFFER,e),a.bufferData(a.ARRAY_BUFFER,c,a.DYNAMIC_DRAW),a.uniform2f(h,d.width,d.height),a.uniformMatrix3fv(i,!1,d.matrix),a.enableVertexAttribArray(g),a.enableVertexAttribArray(f),a.vertexAttribPointer(g,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,0),a.vertexAttribPointer(f,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,8),a.lineWidth(3),a.drawArrays(a.LINES,d.start||0,d.count||c.length/this.ATTRIBUTES)},initProgram:function(a){var b,c,d;return b=sigma.utils.loadShader(a,["attribute vec2 a_position;","attribute float a_color;","uniform vec2 u_resolution;","uniform mat3 u_matrix;","varying vec4 color;","void main() {","gl_Position = vec4(","((u_matrix * vec3(a_position, 1)).xy /","u_resolution * 2.0 - 1.0) * vec2(1, -1),","0,","1",");","float c = a_color;","color.b = mod(c, 256.0); c = floor(c / 256.0);","color.g = mod(c, 256.0); c = floor(c / 256.0);","color.r = mod(c, 256.0); c = floor(c / 256.0); color /= 255.0;","color.a = 1.0;","}"].join("\n"),a.VERTEX_SHADER),c=sigma.utils.loadShader(a,["precision mediump float;","varying vec4 color;","void main(void) {","gl_FragColor = color;","}"].join("\n"),a.FRAGMENT_SHADER),d=sigma.utils.loadProgram(a,[b,c])}}}(),function(){"use strict";sigma.utils.pkg("sigma.webgl.edges"),sigma.webgl.edges.arrow={POINTS:9,ATTRIBUTES:11,addEdge:function(a,b,c,d,e,f,g){var h=(a[f+"size"]||1)/2,i=b[f+"x"],j=b[f+"y"],k=c[f+"x"],l=c[f+"y"],m=c[f+"size"],n=a.color;if(!n)switch(g("edgeColor")){case"source":n=b.color||g("defaultNodeColor");break;case"target":n=c.color||g("defaultNodeColor");break;default:n=g("defaultEdgeColor")}n=sigma.utils.floatColor(n),d[e++]=i,d[e++]=j,d[e++]=k,d[e++]=l,d[e++]=h,d[e++]=m,d[e++]=0,d[e++]=0,d[e++]=0,d[e++]=0,d[e++]=n,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=m,d[e++]=1,d[e++]=1,d[e++]=0,d[e++]=0,d[e++]=n,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=m,d[e++]=1,d[e++]=0,d[e++]=0,d[e++]=0,d[e++]=n,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=m,d[e++]=1,d[e++]=0,d[e++]=0,d[e++]=0,d[e++]=n,d[e++]=i,d[e++]=j,d[e++]=k,d[e++]=l,d[e++]=h,d[e++]=m,d[e++]=0,d[e++]=1,d[e++]=0,d[e++]=0,d[e++]=n,d[e++]=i,d[e++]=j,d[e++]=k,d[e++]=l,d[e++]=h,d[e++]=m,d[e++]=0,d[e++]=0,d[e++]=0,d[e++]=0,d[e++]=n,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=m,d[e++]=1,d[e++]=0,d[e++]=1,d[e++]=-1,d[e++]=n,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=m,d[e++]=1,d[e++]=0,d[e++]=1,d[e++]=0,d[e++]=n,d[e++]=k,d[e++]=l,d[e++]=i,d[e++]=j,d[e++]=h,d[e++]=m,d[e++]=1,d[e++]=0,d[e++]=1,d[e++]=1,d[e++]=n},render:function(a,b,c,d){var e,f=a.getAttribLocation(b,"a_pos1"),g=a.getAttribLocation(b,"a_pos2"),h=a.getAttribLocation(b,"a_thickness"),i=a.getAttribLocation(b,"a_tSize"),j=a.getAttribLocation(b,"a_delay"),k=a.getAttribLocation(b,"a_minus"),l=a.getAttribLocation(b,"a_head"),m=a.getAttribLocation(b,"a_headPosition"),n=a.getAttribLocation(b,"a_color"),o=a.getUniformLocation(b,"u_resolution"),p=a.getUniformLocation(b,"u_matrix"),q=a.getUniformLocation(b,"u_matrixHalfPi"),r=a.getUniformLocation(b,"u_matrixHalfPiMinus"),s=a.getUniformLocation(b,"u_ratio"),t=a.getUniformLocation(b,"u_nodeRatio"),u=a.getUniformLocation(b,"u_arrowHead"),v=a.getUniformLocation(b,"u_scale");e=a.createBuffer(),a.bindBuffer(a.ARRAY_BUFFER,e),a.bufferData(a.ARRAY_BUFFER,c,a.STATIC_DRAW),a.uniform2f(o,d.width,d.height),a.uniform1f(s,d.ratio/Math.pow(d.ratio,d.settings("edgesPowRatio"))),a.uniform1f(t,Math.pow(d.ratio,d.settings("nodesPowRatio"))/d.ratio),a.uniform1f(u,5),a.uniform1f(v,d.scalingRatio),a.uniformMatrix3fv(p,!1,d.matrix),a.uniformMatrix2fv(q,!1,sigma.utils.matrices.rotation(Math.PI/2,!0)),a.uniformMatrix2fv(r,!1,sigma.utils.matrices.rotation(-Math.PI/2,!0)),a.enableVertexAttribArray(f),a.enableVertexAttribArray(g),a.enableVertexAttribArray(h),a.enableVertexAttribArray(i),a.enableVertexAttribArray(j),a.enableVertexAttribArray(k),a.enableVertexAttribArray(l),a.enableVertexAttribArray(m),a.enableVertexAttribArray(n),a.vertexAttribPointer(f,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,0),a.vertexAttribPointer(g,2,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,8),a.vertexAttribPointer(h,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,16),a.vertexAttribPointer(i,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,20),a.vertexAttribPointer(j,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,24),a.vertexAttribPointer(k,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,28),a.vertexAttribPointer(l,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,32),a.vertexAttribPointer(m,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,36),a.vertexAttribPointer(n,1,a.FLOAT,!1,this.ATTRIBUTES*Float32Array.BYTES_PER_ELEMENT,40),a.drawArrays(a.TRIANGLES,d.start||0,d.count||c.length/this.ATTRIBUTES)},initProgram:function(a){var b,c,d;return b=sigma.utils.loadShader(a,["attribute vec2 a_pos1;","attribute vec2 a_pos2;","attribute float a_thickness;","attribute float a_tSize;","attribute float a_delay;","attribute float a_minus;","attribute float a_head;","attribute float a_headPosition;","attribute float a_color;","uniform vec2 u_resolution;","uniform float u_ratio;","uniform float u_nodeRatio;","uniform float u_arrowHead;","uniform float u_scale;","uniform mat3 u_matrix;","uniform mat2 u_matrixHalfPi;","uniform mat2 u_matrixHalfPiMinus;","varying vec4 color;","void main() {","vec2 pos = normalize(a_pos2 - a_pos1);","mat2 matrix = (1.0 - a_head) *","(","a_minus * u_matrixHalfPiMinus +","(1.0 - a_minus) * u_matrixHalfPi",") + a_head * (","a_headPosition * u_matrixHalfPiMinus * 0.6 +","(a_headPosition * a_headPosition - 1.0) * mat2(1.0)",");","pos = a_pos1 + (","(1.0 - a_head) * a_thickness * u_ratio * matrix * pos +","a_head * u_arrowHead * a_thickness * u_ratio * matrix * pos +","a_delay * pos * (","a_tSize / u_nodeRatio +","u_arrowHead * a_thickness * u_ratio",")",");","gl_Position = vec4(","((u_matrix * vec3(pos, 1)).xy /","u_resolution * 2.0 - 1.0) * vec2(1, -1),","0,","1",");","float c = a_color;","color.b = mod(c, 256.0); c = floor(c / 256.0);","color.g = mod(c, 256.0); c = floor(c / 256.0);","color.r = mod(c, 256.0); c = floor(c / 256.0); color /= 255.0;","color.a = 1.0;","}"].join("\n"),a.VERTEX_SHADER),c=sigma.utils.loadShader(a,["precision mediump float;","varying vec4 color;","void main(void) {","gl_FragColor = color;","}"].join("\n"),a.FRAGMENT_SHADER),d=sigma.utils.loadProgram(a,[b,c])}}}(),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.canvas.labels"),sigma.canvas.labels.def=function(a,b,c){var d,e=c("prefix")||"",f=a[e+"size"];f<c("labelThreshold")||"string"==typeof a.label&&(d="fixed"===c("labelSize")?c("defaultLabelSize"):c("labelSizeRatio")*f,b.font=(c("fontStyle")?c("fontStyle")+" ":"")+d+"px "+c("font"),b.fillStyle="node"===c("labelColor")?a.color||c("defaultNodeColor"):c("defaultLabelColor"),b.fillText(a.label,Math.round(a[e+"x"]+f+3),Math.round(a[e+"y"]+d/3)))}}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.canvas.hovers"),sigma.canvas.hovers.def=function(a,b,c){var d,e,f,g,h,i=c("hoverFontStyle")||c("fontStyle"),j=c("prefix")||"",k=a[j+"size"],l="fixed"===c("labelSize")?c("defaultLabelSize"):c("labelSizeRatio")*k;b.font=(i?i+" ":"")+l+"px "+(c("hoverFont")||c("font")),b.beginPath(),b.fillStyle="node"===c("labelHoverBGColor")?a.color||c("defaultNodeColor"):c("defaultHoverLabelBGColor"),c("labelHoverShadow")&&(b.shadowOffsetX=0,b.shadowOffsetY=0,b.shadowBlur=8,b.shadowColor=c("labelHoverShadowColor")),"string"==typeof a.label&&(d=Math.round(a[j+"x"]-l/2-2),e=Math.round(a[j+"y"]-l/2-2),f=Math.round(b.measureText(a.label).width+l/2+k+7),g=Math.round(l+4),h=Math.round(l/2+2),b.moveTo(d,e+h),b.arcTo(d,e,d+h,e,h),b.lineTo(d+f,e),b.lineTo(d+f,e+g),b.lineTo(d+h,e+g),b.arcTo(d,e+g,d,e+g-h,h),b.lineTo(d,e+h),b.closePath(),b.fill(),b.shadowOffsetX=0,b.shadowOffsetY=0,b.shadowBlur=0),c("borderSize")>0&&(b.beginPath(),b.fillStyle="node"===c("nodeBorderColor")?a.color||c("defaultNodeColor"):c("defaultNodeBorderColor"),b.arc(a[j+"x"],a[j+"y"],k+c("borderSize"),0,2*Math.PI,!0),b.closePath(),b.fill());var m=sigma.canvas.nodes[a.type]||sigma.canvas.nodes.def;m(a,b,c),"string"==typeof a.label&&(b.fillStyle="node"===c("labelHoverColor")?a.color||c("defaultNodeColor"):c("defaultLabelHoverColor"),b.fillText(a.label,Math.round(a[j+"x"]+k+3),Math.round(a[j+"y"]+l/3)))}}.call(this),function(){"use strict";sigma.utils.pkg("sigma.canvas.nodes"),sigma.canvas.nodes.def=function(a,b,c){var d=c("prefix")||"";b.fillStyle=a.color||c("defaultNodeColor"),b.beginPath(),b.arc(a[d+"x"],a[d+"y"],a[d+"size"],0,2*Math.PI,!0),b.closePath(),b.fill()}}(),function(){"use strict";sigma.utils.pkg("sigma.canvas.edges"),sigma.canvas.edges.def=function(a,b,c,d,e){var f=a.color,g=e("prefix")||"",h=e("edgeColor"),i=e("defaultNodeColor"),j=e("defaultEdgeColor");if(!f)switch(h){case"source":f=b.color||i;break;case"target":f=c.color||i;break;default:f=j}d.strokeStyle=f,d.lineWidth=a[g+"size"]||1,d.beginPath(),d.moveTo(b[g+"x"],b[g+"y"]),d.lineTo(c[g+"x"],c[g+"y"]),d.stroke(),e("drawEdgeLabels")&&sigma.canvas.labels.edges.def(a,b,c,d,e)}}(),function(){"use strict";sigma.utils.pkg("sigma.canvas.edges"),sigma.canvas.edges.curve=function(a,b,c,d,e){var f=a.color,g=e("prefix")||"",h=e("edgeColor"),i=e("defaultNodeColor"),j=e("defaultEdgeColor");if(!f)switch(h){case"source":f=b.color||i;break;case"target":f=c.color||i;break;default:f=j}d.strokeStyle=f,d.lineWidth=a[g+"size"]||1,d.beginPath(),d.moveTo(b[g+"x"],b[g+"y"]),d.quadraticCurveTo((b[g+"x"]+c[g+"x"])/2+(c[g+"y"]-b[g+"y"])/4,(b[g+"y"]+c[g+"y"])/2+(b[g+"x"]-c[g+"x"])/4,c[g+"x"],c[g+"y"]),d.stroke()}}(),function(){"use strict";sigma.utils.pkg("sigma.canvas.edges"),sigma.canvas.edges.arrow=function(a,b,c,d,e){var f=a.color,g=e("prefix")||"",h=e("edgeColor"),i=e("defaultNodeColor"),j=e("defaultEdgeColor"),k=a[g+"size"]||1,l=c[g+"size"],m=b[g+"x"],n=b[g+"y"],o=c[g+"x"],p=c[g+"y"],q=2.5*k,r=Math.sqrt(Math.pow(o-m,2)+Math.pow(p-n,2)),s=m+(o-m)*(r-q-l)/r,t=n+(p-n)*(r-q-l)/r,u=(o-m)*q/r,v=(p-n)*q/r;if(!f)switch(h){case"source":f=b.color||i;break;case"target":f=c.color||i;break;default:f=j}d.strokeStyle=f,d.lineWidth=k,d.beginPath(),d.moveTo(m,n),d.lineTo(s,t),d.stroke(),d.fillStyle=f,d.beginPath(),d.moveTo(s+u,t+v),d.lineTo(s+.6*v,t-.6*u),d.lineTo(s-.6*v,t+.6*u),d.lineTo(s+u,t+v),d.closePath(),d.fill(),e("drawEdgeLabels")&&sigma.canvas.labels.edges.def(a,b,c,d,e)}}(),function(){"use strict";var a=sigma.utils.pkg("sigma.canvas.edges");a.curvedArrow=function(a,b,c,d,e){var f=a.color,g=e("prefix")||"",h=e("edgeColor"),i=e("defaultNodeColor"),j=e("defaultEdgeColor"),k=a[g+"size"]||1,l=c[g+"size"],m=b[g+"x"],n=b[g+"y"],o=(b[g+"x"]+c[g+"x"])/2+(c[g+"y"]-b[g+"y"])/4,p=(b[g+"y"]+c[g+"y"])/2+(b[g+"x"]-c[g+"x"])/4,q=c[g+"x"],r=c[g+"y"],s=2.5*k,t=Math.sqrt(Math.pow(q-o,2)+Math.pow(r-p,2)),u=o+(q-o)*(t-s-l)/t,v=p+(r-p)*(t-s-l)/t,w=(q-o)*s/t,x=(r-p)*s/t;if(!f)switch(h){case"source":f=b.color||i;break;case"target":f=c.color||i;break;default:f=j}d.strokeStyle=f,d.lineWidth=k,d.beginPath(),d.moveTo(m,n),d.quadraticCurveTo(o,p,u,v),d.stroke(),d.fillStyle=f,d.beginPath(),d.moveTo(u+w,v+x),d.lineTo(u+.6*x,v-.6*w),d.lineTo(u-.6*x,v+.6*w),d.lineTo(u+w,v+x),d.closePath(),d.fill()}}(),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.middlewares"),sigma.utils.pkg("sigma.utils"),sigma.middlewares.rescale=function(a,b,c){var d,e,f,g,h,i,j,k,l=this.graph.nodes(),m=this.graph.edges(),n=this.settings.embedObjects(c||{}),o=n("bounds")||sigma.utils.getBoundaries(this.graph,a,!0),p=o.minX,q=o.minY,r=o.maxX,s=o.maxY,t=o.sizeMax,u=o.weightMax,v=n("width")||1,w=n("height")||1;for(j="outside"===n("scalingMode")?Math.max(v/Math.max(r-p,1),w/Math.max(s-q,1)):Math.min(v/Math.max(r-p,1),w/Math.max(s-q,1)),k=(n("rescaleIgnoreSize")?0:(n("maxNodeSize")||t)/j)+(n("sideMargin")||0),r+=k,p-=k,s+=k,q-=k,j="outside"===n("scalingMode")?Math.max(v/Math.max(r-p,1),w/Math.max(s-q,1)):Math.min(v/Math.max(r-p,1),w/Math.max(s-q,1)),n("maxNodeSize")||n("minNodeSize")?n("maxNodeSize")===n("minNodeSize")?(f=0,g=n("maxNodeSize")):(f=(n("maxNodeSize")-n("minNodeSize"))/t,g=n("minNodeSize")):(f=1,g=0),n("maxEdgeSize")||n("minEdgeSize")?n("maxEdgeSize")===n("minEdgeSize")?(h=0,i=n("minEdgeSize")):(h=(n("maxEdgeSize")-n("minEdgeSize"))/u,i=n("minEdgeSize")):(h=1,i=0),d=0,e=m.length;e>d;d++)m[d][b+"size"]=m[d][a+"size"]*h+i;for(d=0,e=l.length;e>d;d++)l[d][b+"size"]=l[d][a+"size"]*f+g,l[d][b+"x"]=(l[d][a+"x"]-(r+p)/2)*j,l[d][b+"y"]=(l[d][a+"y"]-(s+q)/2)*j},sigma.utils.getBoundaries=function(a,b,c){var d,e,f=a.edges(),g=a.nodes(),h=-1/0,i=-1/0,j=1/0,k=1/0,l=-1/0,m=-1/0;if(c)for(d=0,e=f.length;e>d;d++)h=Math.max(f[d][b+"size"],h);for(d=0,e=g.length;e>d;d++)i=Math.max(g[d][b+"size"],i),l=Math.max(g[d][b+"x"],l),j=Math.min(g[d][b+"x"],j),m=Math.max(g[d][b+"y"],m),k=Math.min(g[d][b+"y"],k);return h=h||1,i=i||1,{weightMax:h,sizeMax:i,minX:j,minY:k,maxX:l,maxY:m}}}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.middlewares"),sigma.middlewares.copy=function(a,b){var c,d,e;if(b+""!=a+""){for(e=this.graph.nodes(),c=0,d=e.length;d>c;c++)e[c][b+"x"]=e[c][a+"x"],e[c][b+"y"]=e[c][a+"y"],e[c][b+"size"]=e[c][a+"size"];for(e=this.graph.edges(),c=0,d=e.length;d>c;c++)e[c][b+"size"]=e[c][a+"size"]}}}.call(this),function(a){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.misc.animation.running");var b=function(){var a=0;return function(){return""+ ++a}}();sigma.misc.animation.camera=function(c,d,e){if(!(c instanceof sigma.classes.camera&&"object"==typeof d&&d))throw"animation.camera: Wrong arguments.";if("number"!=typeof d.x&&"number"!=typeof d.y&&"number"!=typeof d.ratio&&"number"!=typeof d.angle)throw"There must be at least one valid coordinate in the given val.";var f,g,h,i,j,k,l=e||{},m=sigma.utils.dateNow();return k={x:c.x,y:c.y,ratio:c.ratio,angle:c.angle},j=l.duration,i="function"!=typeof l.easing?sigma.utils.easings[l.easing||"quadraticInOut"]:l.easing,f=function(){var b,e=l.duration?(sigma.utils.dateNow()-m)/l.duration:1;e>=1?(c.isAnimated=!1,c.goTo({x:d.x!==a?d.x:k.x,y:d.y!==a?d.y:k.y,ratio:d.ratio!==a?d.ratio:k.ratio,angle:d.angle!==a?d.angle:k.angle}),cancelAnimationFrame(g),delete sigma.misc.animation.running[g],"function"==typeof l.onComplete&&l.onComplete()):(b=i(e),c.isAnimated=!0,c.goTo({x:d.x!==a?k.x+(d.x-k.x)*b:k.x,y:d.y!==a?k.y+(d.y-k.y)*b:k.y,ratio:d.ratio!==a?k.ratio+(d.ratio-k.ratio)*b:k.ratio,angle:d.angle!==a?k.angle+(d.angle-k.angle)*b:k.angle}),"function"==typeof l.onNewFrame&&l.onNewFrame(),h.frameId=requestAnimationFrame(f))},g=b(),h={frameId:requestAnimationFrame(f),target:c,type:"camera",options:l,fn:f},sigma.misc.animation.running[g]=h,g},sigma.misc.animation.kill=function(a){if(1!==arguments.length||"number"!=typeof a)throw"animation.kill: Wrong arguments.";var b=sigma.misc.animation.running[a];return b&&(cancelAnimationFrame(a),delete sigma.misc.animation.running[b.frameId],"camera"===b.type&&(b.target.isAnimated=!1),"function"==typeof(b.options||{}).onComplete&&b.options.onComplete()),this},sigma.misc.animation.killAll=function(a){var b,c,d=0,e="string"==typeof a?a:null,f="object"==typeof a?a:null,g=sigma.misc.animation.running;for(c in g)e&&g[c].type!==e||f&&g[c].target!==f||(b=sigma.misc.animation.running[c],cancelAnimationFrame(b.frameId),delete sigma.misc.animation.running[c],"camera"===b.type&&(b.target.isAnimated=!1),d++,"function"==typeof(b.options||{}).onComplete&&b.options.onComplete());return d},sigma.misc.animation.has=function(a){var b,c="string"==typeof a?a:null,d="object"==typeof a?a:null,e=sigma.misc.animation.running;for(b in e)if(!(c&&e[b].type!==c||d&&e[b].target!==d))return!0;return!1}}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.misc"),sigma.misc.bindEvents=function(a){function b(b){b&&(f="x"in b.data?b.data.x:f,g="y"in b.data?b.data.y:g);var c,d,e,i,j,k,l,m,n=[],o=f+h.width/2,p=g+h.height/2,q=h.camera.cameraPosition(f,g),r=h.camera.quadtree.point(q.x,q.y);if(r.length)for(c=0,e=r.length;e>c;c++)if(i=r[c],j=i[a+"x"],k=i[a+"y"],l=i[a+"size"],!i.hidden&&o>j-l&&j+l>o&&p>k-l&&k+l>p&&Math.sqrt(Math.pow(o-j,2)+Math.pow(p-k,2))<l){for(m=!1,d=0;d<n.length;d++)if(i.size>n[d].size){n.splice(d,0,i),m=!0;break}m||n.push(i)}return n}function c(a){function c(a){h.settings("eventsEnabled")&&(h.dispatchEvent("click",a.data),g=b(a),g.length?(h.dispatchEvent("clickNode",{node:g[0]}),h.dispatchEvent("clickNodes",{node:g})):h.dispatchEvent("clickStage"))}function d(a){h.settings("eventsEnabled")&&(h.dispatchEvent("doubleClick",a.data),g=b(a),g.length?(h.dispatchEvent("doubleClickNode",{node:g[0]}),h.dispatchEvent("doubleClickNodes",{node:g})):h.dispatchEvent("doubleClickStage"))}function e(){if(h.settings("eventsEnabled")){var a,b,c,d=[];for(a in i)d.push(i[a]);for(i={},b=0,c=d.length;c>b;b++)h.dispatchEvent("outNode",{node:d[b]});d.length&&h.dispatchEvent("outNodes",{nodes:d})}}function f(a){if(h.settings("eventsEnabled")){g=b(a);var c,d,e,f=[],j=[],k={},l=g.length;for(c=0;l>c;c++)e=g[c],k[e.id]=e,i[e.id]||(j.push(e),i[e.id]=e);for(d in i)k[d]||(f.push(i[d]),delete i[d]);for(c=0,l=j.length;l>c;c++)h.dispatchEvent("overNode",{node:j[c]});for(c=0,l=f.length;l>c;c++)h.dispatchEvent("outNode",{node:f[c]});j.length&&h.dispatchEvent("overNodes",{nodes:j}),f.length&&h.dispatchEvent("outNodes",{nodes:f})}}var g,i={};a.bind("click",c),a.bind("mouseup",f),a.bind("mousemove",f),a.bind("mouseout",e),a.bind("doubleclick",d),h.bind("render",f)}var d,e,f,g,h=this;for(d=0,e=this.captors.length;e>d;d++)c(this.captors[d])}}.call(this),function(){"use strict";if("undefined"==typeof sigma)throw"sigma is not declared";sigma.utils.pkg("sigma.misc"),sigma.misc.drawHovers=function(a){function b(){c.contexts.hover.canvas.width=c.contexts.hover.canvas.width;var b,e=sigma.canvas.hovers,f=c.settings.embedObjects({prefix:a});if(f("enableHovering"))for(b in d)d[b].hidden||(e[d[b].type]||e.def)(d[b],c.contexts.hover,f)}var c=this,d={};this.bind("overNodes",function(a){var c,e=a.data.nodes,f=e.length;for(c=0;f>c;c++)d[e[c].id]=e[c];b()}),this.bind("outNodes",function(a){var c,e=a.data.nodes,f=e.length;for(c=0;f>c;c++)delete d[e[c].id];b()}),this.bind("render",function(){b()})}}.call(this);
\ No newline at end of file
diff --git a/vendor/github.com/google/cayley/svg/requirements.txt b/vendor/github.com/google/cayley/svg/requirements.txt
new file mode 100644
index 00000000..09305b62
--- /dev/null
+++ b/vendor/github.com/google/cayley/svg/requirements.txt
@@ -0,0 +1,5 @@
+argparse==1.2.1
+ipython==2.0.0
+pyparsing==2.0.2
+svgwrite==1.1.5
+wsgiref==0.1.2
diff --git a/vendor/github.com/google/cayley/svg/svg.py b/vendor/github.com/google/cayley/svg/svg.py
new file mode 100644
index 00000000..0be8bcab
--- /dev/null
+++ b/vendor/github.com/google/cayley/svg/svg.py
@@ -0,0 +1,136 @@
+# Copyright 2014 The Cayley Authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import svgwrite
+import math
+import random
+
+dwg = svgwrite.Drawing((210,130))
+
+
+node_radius = 15
+big_radius = 50
+fan_dist = 90
+center = (105,65)
+edge_stroke = 2.5
+edge_color = '#555555'
+fan_color = '#aa0000'
+
+b = '#4285F4'
+r = '#DB4437'
+g = '#0F9D58'
+y = '#F4B400'
+n = '#999999'
+
+center_colors = [b, r, y, b, r, y]
+edge_color = n
+fan_color = n
+
+def center_list(center, big_r):
+    x, y = center
+    out = []
+    for i in range(0,6):
+        ox = x + (math.cos(2 * math.pi * i / 6.0) * big_r)
+        oy = y - (math.sin(2 * math.pi * i / 6.0) * big_r)
+        out.append((ox, oy))
+    return out
+
+cx, cy = center
+ring_centers = center_list(center, big_radius)
+outer_left = (cx - fan_dist, cy)
+outer_right = (cx + fan_dist, cy)
+left = ring_centers[3]
+right = ring_centers[0]
+
+all_lines = []
+l = dwg.add(dwg.line(outer_left, left))
+l.stroke(edge_color, edge_stroke)
+all_lines.append(l)
+l = dwg.add(dwg.line(outer_right, right))
+l.stroke(edge_color, edge_stroke)
+all_lines.append(l)
+
+for i, c in enumerate(ring_centers):
+    for j, d in enumerate(ring_centers):
+        if i > j or i == j:
+            continue
+        if (i % 3) == (j % 3):
+            continue
+        if (i % 3) == 1 and (j % 3) == 2:
+            continue
+        if (j % 3) == 1 and (i % 3) == 2:
+            continue
+        if i == 0 and j == 3:
+            continue
+        if i == 3 and j == 0:
+            continue
+        l = dwg.add(dwg.line(c,d))
+        l.stroke(edge_color, edge_stroke)
+        all_lines.append(l)
+
+circle_elems = []
+for i, c in enumerate(ring_centers):
+    elem = dwg.add(dwg.circle(c, node_radius, fill=center_colors[i]))
+    circle_elems.append(elem)
+
+left_circle = dwg.add(dwg.circle(outer_left, node_radius, fill=fan_color))
+right_circle = dwg.add(dwg.circle(outer_right, node_radius, fill=fan_color))
+
+
+anims = []
+def flash(element, orig_color, start, is_line=False):
+    prop = "fill"
+    if is_line:
+        prop = "stroke"
+
+    a = svgwrite.animate.Animate(prop, href=element)
+    a['from'] = orig_color
+    a['to'] = g
+    a['begin'] = "+%0.2fs" % start
+    a['dur'] = "1.0s"
+    dwg.add(a)
+    anims.append(a)
+
+    a = svgwrite.animate.Animate(prop, href=element)
+    a['from'] = g
+    a['to'] = orig_color
+    a['begin'] = "+%0.2fs" % (start + 1.0)
+    a['dur'] = "1.2s"
+
+    dwg.add(a)
+    anims.append(a)
+    return a
+
+dwg.saveas("cayley.svg")
+first = flash(left_circle, n, 0)
+flash(all_lines[0], n, 0.5, True)
+flash(all_lines[7], n, 1.0, True)
+flash(all_lines[3], n, 1.5, True)
+flash(all_lines[9], n, 1.0, True)
+flash(all_lines[5], n, 1.5, True)
+flash(all_lines[1], n, 2.0, True)
+flash(right_circle, n, 2.5)
+flash(left_circle, n, 3.5)
+flash(all_lines[0], n, 4.0, True)
+flash(all_lines[6], n, 4.5, True)
+flash(all_lines[4], n, 5.0, True)
+flash(all_lines[8], n, 4.5, True)
+flash(all_lines[2], n, 5.0, True)
+flash(all_lines[1], n, 5.5, True)
+final = flash(right_circle, n, 6.0)
+
+for anim in anims:
+    anim["begin"] = anim["begin"] + "; " + final.get_id() + ".end" + anim["begin"]
+
+dwg.saveas("cayley_active.svg")
diff --git a/vendor/github.com/google/cayley/templates/head.tmpl b/vendor/github.com/google/cayley/templates/head.tmpl
new file mode 100644
index 00000000..13ca0f98
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/head.tmpl
@@ -0,0 +1,62 @@
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+{{define "head"}}
+    <title>Cayley</title>
+    <meta charset="utf-8" />
+    <!-- Latest compiled and minified CSS -->
+    <!--<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css">-->
+    <link rel="stylesheet" href="/static/third_party/flatly/bootstrap.min.css">
+    <!-- IE -->
+    <link rel="shortcut icon" type="image/x-icon" href="/static/favicon.ico" />
+    <!-- other browsers -->
+    <link rel="icon" type="image/x-icon" href="/static/favicon.ico" />
+    <link href='http://fonts.googleapis.com/css?family=Open+Sans:400,300' rel='stylesheet' type='text/css'>
+    <link href='http://fonts.googleapis.com/css?family=Inconsolata' rel='stylesheet' type='text/css'>
+    <!--<link href="//netdna.bootstrapcdn.com/bootstrap/3.1.0/css/bootstrap.min.css" rel="stylesheet">-->
+    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/codemirror/3.21.0/codemirror.min.css">
+    <link rel="stylesheet" href="/static/css/grid.css">
+    <link rel="stylesheet" href="/static/css/query_editor.css">
+
+    <!-- Optional theme -->
+    <!--<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-theme.min.css">-->
+
+    <!-- Latest compiled and minified JavaScript -->
+    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
+    <script src="//netdna.bootstrapcdn.com/bootstrap/3.0.0/js/bootstrap.min.js"></script>
+
+    <!-- Codemirror -->
+    <script src="//cdnjs.cloudflare.com/ajax/libs/codemirror/3.21.0/codemirror.min.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/codemirror/3.21.0/addon/edit/matchbrackets.min.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/codemirror/3.21.0/addon/comment/continuecomment.min.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/codemirror/3.21.0/mode/javascript/javascript.min.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/snap.svg/0.2.0/snap.svg-min.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/fabric.js/1.4.0/fabric.min.js"></script>
+
+    <!-- D3.js -->
+    <script src="//cdnjs.cloudflare.com/ajax/libs/d3/3.4.1/d3.min.js"></script>
+{{end}}
+
+{{define "foot"}}
+    <script type='text/javascript'>
+
+    $(document).ready(function() {
+        $('[data-toggle=offcanvas]').click(function() {
+          $('.row-offcanvas').toggleClass('active');
+          });
+        });
+
+    </script>
+{{end}}
diff --git a/vendor/github.com/google/cayley/templates/query.html b/vendor/github.com/google/cayley/templates/query.html
new file mode 100644
index 00000000..ca8efc06
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/query.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<html>
+<head>
+{{template "head"}}
+</head>
+<body>
+<div class="page-container">
+
+  {{template "top_navbar"}}
+
+  <div class="container-fluid">
+    <div class="row row-offcanvas row-offcanvas-left">
+      {{template "sidebar"}}
+      <!-- main area -->
+      <div class="col-sm-10 col-xs-12" id="main">
+        <div class="row">
+          <div class="col-sm-12 col-xs-12 codecol">
+            <textarea id="code">g.Emit("Hello World")</textarea>
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-sm-12 col-xs-12">
+            <textarea id="output" name="output"></textarea>
+          </div>
+        </div>
+      </div> <!--/#main-->
+    </div> <!--/.row-->
+  </div><!--/.container-->
+</div><!--/.page-container-->
+</body>
+{{template "foot"}}
+<script src="/static/js/cayley_main.js" type="text/javascript" charset="utf-8"></script>
+<script src="/static/js/cayley_query.js" type="text/javascript" charset="utf-8"></script>
+</html>
diff --git a/vendor/github.com/google/cayley/templates/query_shape.html b/vendor/github.com/google/cayley/templates/query_shape.html
new file mode 100644
index 00000000..9f620c56
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/query_shape.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<html>
+<head>
+{{template "head"}}
+</head>
+<body>
+<div class="page-container">
+
+  {{template "top_navbar"}}
+
+  <div class="container-fluid">
+    <div class="row row-offcanvas row-offcanvas-left">
+      {{template "sidebar"}}
+      <!-- main area -->
+      <div class="col-sm-10 col-xs-12" id="main">
+        <div class="row">
+          <div class="col-sm-12 col-xs-12 codecol">
+            <textarea id="code">g.Emit("Hello World")</textarea>
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-xs-12 col-sm-12" id="viz">
+          </div><!-- /.col-xs-12 main -->
+        </div>
+      </div> <!--/#main-->
+    </div> <!--/.row-->
+  </div><!--/.container-->
+</div><!--/.page-container-->
+</body>
+{{template "foot"}}
+<script src="/static/js/cayley_main.js" type="text/javascript" charset="utf-8"></script>
+<script src="/static/js/cayley_shape.js" type="text/javascript" charset="utf-8"></script>
+<script src="/static/js/query_viz.js" type="text/javascript" charset="utf-8"></script>
+</html>
diff --git a/vendor/github.com/google/cayley/templates/sidebar.tmpl b/vendor/github.com/google/cayley/templates/sidebar.tmpl
new file mode 100644
index 00000000..e7197b04
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/sidebar.tmpl
@@ -0,0 +1,63 @@
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+{{define "sidebar"}}
+<!-- sidebar -->
+<div class="col-xs-6 col-sm-2 sidebar-offcanvas" id="sidebar" role="navigation">
+  <div class="row bottompad">
+    <div class="col-xs-8 col-sm-8 col-xs-offset-2 col-sm-offset-2">
+      <div class="btn-group-vertical center-block">
+        <button id="run_button" type="button" class="btn btn-primary center-block">Run Query</button>
+        <div class="btn-group center-block">
+          <button id="selected-query-lang" type="button" class="btn btn-default dropdown-toggle" data-toggle="dropdown">
+            Gremlin &nbsp; <span class="caret"></span>
+          </button>
+          <ul class="dropdown-menu" role="menu">
+            <li class="dropdown-header">Query Languauge</li>
+            <li><a id="gremlin-dropdown" href="#">Gremlin</a></li>
+            <li><a id="mql-dropdown" href="#">MQL</a></li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  </div>
+  <ul class="nav">
+    <li id="sbQuery"><a href="/">Query</a></li>
+    <li id="sbQueryShape"><a href="/ui/query_shape">Query Shape</a></li>
+    <li id="sbVisualize"><a href="/ui/visualize">Visualize</a></li>
+    <li ></li>
+    <li id="sbWrite"><a href="/ui/write">Write</a></li>
+  </ul>
+
+  <div class="row bottompad at-bottom">
+    <div class="col-xs-8 col-sm-8 col-xs-offset-2 col-sm-offset-2">
+      <!--<div class="btn-group-vertical center-block">-->
+      <div class="btn-group center-block dropup">
+        <button class="btn btn-sm center-block dropdown-toggle" type="button" data-toggle="dropdown"> Documentation <span class="caret"></span>
+        </button>
+        <ul class="dropdown-menu">
+            <li><a href="/docs/Overview" target="_blank">Overview</a></li>
+            <li><a href="/docs/GremlinAPI" target="_blank">Gremlin API</a></li>
+            <li><a href="/docs/MQL" target="_blank">MQL</a></li>
+            <li><a href="/docs/Configuration" target="_blank">Configuration</a></li>
+            <li><a href="/docs/HTTP" target="_blank">HTTP API</a></li>
+        </ul>
+      </div>
+      <!--</div>-->
+    </div>
+  </div>
+
+</div>
+{{end}}
diff --git a/vendor/github.com/google/cayley/templates/top_navbar.tmpl b/vendor/github.com/google/cayley/templates/top_navbar.tmpl
new file mode 100644
index 00000000..8dd68bc5
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/top_navbar.tmpl
@@ -0,0 +1,37 @@
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+{{define "top_navbar"}}
+  <!-- top navbar -->
+  <div class="navbar navbar-fixed-top" role="navigation">
+    <div id="alertBox" class="alert" >
+      Wrote a quad!
+    </div>
+    <div class="container-fluid">
+      <div class="navbar-header">
+        <button type="button" class="navbar-toggle navbar-color-back" data-toggle="offcanvas" data-target=".sidebar-nav">
+          <span class="icon-bar"></span>
+          <span class="icon-bar"></span>
+          <span class="icon-bar"></span>
+          More
+        </button>
+        <div id="logo-div">
+        <div id="logo" width="105" height="65" class="hide-small"></div>
+        <h1>Cayley</h1>
+        </div>
+      </div>
+    </div>
+  </div>
+{{end}}
diff --git a/vendor/github.com/google/cayley/templates/visualize.html b/vendor/github.com/google/cayley/templates/visualize.html
new file mode 100644
index 00000000..27e0f245
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/visualize.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<html>
+<head>
+{{template "head"}}
+<script src="/static/third_party/sigmajs/sigma.min.js"></script>
+<script src="/static/third_party/sigmajs/plugins/sigma.layout.forceAtlas2.min.js"></script>
+<script src="/static/third_party/sigmajs/plugins/sigma.parsers.json.min.js"></script>
+<script src="/static/third_party/sigmajs/plugins/sigma.plugins.animate.min.js"></script>
+</head>
+<body>
+<div class="page-container">
+
+  {{template "top_navbar"}}
+
+  <div class="container-fluid">
+    <div class="row row-offcanvas row-offcanvas-left">
+      {{template "sidebar"}}
+      <!-- main area -->
+      <div class="col-sm-10 col-xs-12" id="main">
+        <div class="row">
+          <div class="col-sm-12 col-xs-12 codecol">
+            <textarea id="code">g.Emit("Hello World")</textarea>
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-xs-12 col-sm-12">
+            <div id="visualize" width=100% height=100%>
+              </div>
+          </div><!-- /.col-xs-12 main -->
+        </div>
+      </div> <!--/#main-->
+    </div> <!--/.row-->
+  </div><!--/.container-->
+</div><!--/.page-container-->
+</body>
+{{template "foot"}}
+<script src="/static/js/cayley_main.js" type="text/javascript" charset="utf-8"></script>
+<script src="/static/js/cayley_visualize.js" type="text/javascript" charset="utf-8"></script>
+</html>
diff --git a/vendor/github.com/google/cayley/templates/write.html b/vendor/github.com/google/cayley/templates/write.html
new file mode 100644
index 00000000..0a726d16
--- /dev/null
+++ b/vendor/github.com/google/cayley/templates/write.html
@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<!--
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<html>
+<head>
+{{template "head"}}
+</head>
+<body>
+<div class="page-container">
+
+  {{template "top_navbar"}}
+
+  <div class="container-fluid">
+    <div class="row row-offcanvas row-offcanvas-left">
+      {{template "sidebar"}}
+      <!-- main area -->
+      <div class="col-sm-10 col-xs-12" id="main">
+        <div class="row">
+          <div class="col-xs-12 col-sm-12">
+            <h2> Write an N-Quads file: </h2>
+              <input id="nquad_file" type="file"></input>
+            </div>
+          </div><!-- /.col-xs-12 main -->
+        <div class="row button-row">
+          <div class="col-sm-12 col-xs-12">
+              <button id="write_file" type="button" class="btn btn-primary">Write File</button>
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-sm-12 col-xs-12">
+              <h2> Write a quad: </h2>
+              <input id="subject" type="text" placeholder="Subject"></input>
+              <input id="predicate" type="text" placeholder="Predicate"></input>
+              <input id="object" type="text" placeholder="Object"></input>
+              <input id="label" type="text" placeholder="Label"></input>
+          </div>
+        </div>
+        <div class="row button-row">
+          <div class="col-sm-12 col-xs-12">
+              <button id="add_quad" type="button" class="btn">Add Quad</button>
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-xs-12 col-sm-12">
+              <h2> Remove a quad: </h2>
+              <input id="rsubject" type="text" placeholder="Subject"></input>
+              <input id="rpredicate" type="text" placeholder="Predicate"></input>
+              <input id="robject" type="text" placeholder="Object"></input>
+              <input id="rlabel" type="text" placeholder="Label"></input>
+              </div>
+          </div><!-- /.col-xs-12 main -->
+        <div class="row button-row">
+          <div class="col-sm-12 col-xs-12">
+              <button id="delete_quad" type="button" class="btn">Delete Quad</button>
+          </div>
+        </div>
+        </div>
+      </div> <!--/#main-->
+    </div> <!--/.row-->
+  </div><!--/.container-->
+</div><!--/.page-container-->
+</body>
+{{template "foot"}}
+<script src="/static/js/cayley_main.js" type="text/javascript" charset="utf-8"></script>
+<script src="/static/js/cayley_write.js" type="text/javascript" charset="utf-8"></script>
+</html>
diff --git a/vendor/github.com/google/cayley/writer/single.go b/vendor/github.com/google/cayley/writer/single.go
new file mode 100644
index 00000000..376f9e19
--- /dev/null
+++ b/vendor/github.com/google/cayley/writer/single.go
@@ -0,0 +1,119 @@
+// Copyright 2014 The Cayley Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package writer
+
+import (
+	"time"
+
+	"github.com/google/cayley/graph"
+	"github.com/google/cayley/quad"
+)
+
+func init() {
+	graph.RegisterWriter("single", NewSingleReplication)
+}
+
+type Single struct {
+	currentID  graph.PrimaryKey
+	qs         graph.QuadStore
+	ignoreOpts graph.IgnoreOpts
+}
+
+func NewSingleReplication(qs graph.QuadStore, opts graph.Options) (graph.QuadWriter, error) {
+	var (
+		ignoreMissing   bool
+		ignoreDuplicate bool
+		err             error
+	)
+
+	if *graph.IgnoreMissing {
+		ignoreMissing = true
+	} else {
+		ignoreMissing, _, err = opts.BoolKey("ignore_missing")
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if *graph.IgnoreDup {
+		ignoreDuplicate = true
+	} else {
+		ignoreDuplicate, _, err = opts.BoolKey("ignore_duplicate")
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return &Single{
+		currentID: qs.Horizon(),
+		qs:        qs,
+		ignoreOpts: graph.IgnoreOpts{
+			IgnoreDup:     ignoreDuplicate,
+			IgnoreMissing: ignoreMissing,
+		},
+	}, nil
+}
+
+func (s *Single) AddQuad(q quad.Quad) error {
+	deltas := make([]graph.Delta, 1)
+	deltas[0] = graph.Delta{
+		ID:        s.currentID.Next(),
+		Quad:      q,
+		Action:    graph.Add,
+		Timestamp: time.Now(),
+	}
+	return s.qs.ApplyDeltas(deltas, s.ignoreOpts)
+}
+
+func (s *Single) AddQuadSet(set []quad.Quad) error {
+	deltas := make([]graph.Delta, len(set))
+	for i, q := range set {
+		deltas[i] = graph.Delta{
+			ID:        s.currentID.Next(),
+			Quad:      q,
+			Action:    graph.Add,
+			Timestamp: time.Now(),
+		}
+	}
+
+	return s.qs.ApplyDeltas(deltas, s.ignoreOpts)
+}
+
+func (s *Single) RemoveQuad(q quad.Quad) error {
+	deltas := make([]graph.Delta, 1)
+	deltas[0] = graph.Delta{
+		ID:        s.currentID.Next(),
+		Quad:      q,
+		Action:    graph.Delete,
+		Timestamp: time.Now(),
+	}
+	return s.qs.ApplyDeltas(deltas, s.ignoreOpts)
+}
+
+func (s *Single) Close() error {
+	// Nothing to clean up locally.
+	return nil
+}
+
+func (s *Single) ApplyTransaction(t *graph.Transaction) error {
+	ts := time.Now()
+	deltas := make([]graph.Delta, 0, len(t.Deltas))
+	for d := range t.Deltas {
+		d.ID = s.currentID.Next()
+		d.Timestamp = ts
+		deltas = append(deltas, d)
+	}
+	return s.qs.ApplyDeltas(deltas, s.ignoreOpts)
+}
diff --git a/vendor/github.com/julienschmidt/httprouter/.travis.yml b/vendor/github.com/julienschmidt/httprouter/.travis.yml
new file mode 100644
index 00000000..a4d6cc53
--- /dev/null
+++ b/vendor/github.com/julienschmidt/httprouter/.travis.yml
@@ -0,0 +1,8 @@
+sudo: false
+language: go
+go:
+  - 1.1
+  - 1.2
+  - 1.3
+  - 1.4
+  - tip
diff --git a/vendor/github.com/julienschmidt/httprouter/LICENSE b/vendor/github.com/julienschmidt/httprouter/LICENSE
new file mode 100644
index 00000000..b829abc8
--- /dev/null
+++ b/vendor/github.com/julienschmidt/httprouter/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2013 Julien Schmidt. 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.
+    * The names of the contributors may not 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 JULIEN SCHMIDT 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.
\ No newline at end of file
diff --git a/vendor/github.com/julienschmidt/httprouter/README.md b/vendor/github.com/julienschmidt/httprouter/README.md
new file mode 100644
index 00000000..9875c700
--- /dev/null
+++ b/vendor/github.com/julienschmidt/httprouter/README.md
@@ -0,0 +1,323 @@
+# HttpRouter [![Build Status](https://travis-ci.org/julienschmidt/httprouter.png?branch=master)](https://travis-ci.org/julienschmidt/httprouter) [![Coverage](http://gocover.io/_badge/github.com/julienschmidt/httprouter?0)](http://gocover.io/github.com/julienschmidt/httprouter) [![GoDoc](http://godoc.org/github.com/julienschmidt/httprouter?status.png)](http://godoc.org/github.com/julienschmidt/httprouter)
+
+HttpRouter is a lightweight high performance HTTP request router
+(also called *multiplexer* or just *mux* for short) for [Go](http://golang.org/).
+
+In contrast to the [default mux](http://golang.org/pkg/net/http/#ServeMux) of Go's net/http package, this router supports
+variables in the routing pattern and matches against the request method.
+It also scales better.
+
+The router is optimized for high performance and a small memory footprint.
+It scales well even with very long paths and a large number of routes.
+A compressing dynamic trie (radix tree) structure is used for efficient matching.
+
+## Features
+**Only explicit matches:** With other routers, like [http.ServeMux](http://golang.org/pkg/net/http/#ServeMux),
+a requested URL path could match multiple patterns. Therefore they have some
+awkward pattern priority rules, like *longest match* or *first registered,
+first matched*. By design of this router, a request can only match exactly one
+or no route. As a result, there are also no unintended matches, which makes it
+great for SEO and improves the user experience.
+
+**Stop caring about trailing slashes:** Choose the URL style you like, the
+router automatically redirects the client if a trailing slash is missing or if
+there is one extra. Of course it only does so, if the new path has a handler.
+If you don't like it, you can [turn off this behavior](http://godoc.org/github.com/julienschmidt/httprouter#Router.RedirectTrailingSlash).
+
+**Path auto-correction:** Besides detecting the missing or additional trailing
+slash at no extra cost, the router can also fix wrong cases and remove
+superfluous path elements (like `../` or `//`).
+Is [CAPTAIN CAPS LOCK](http://www.urbandictionary.com/define.php?term=Captain+Caps+Lock) one of your users?
+HttpRouter can help him by making a case-insensitive look-up and redirecting him
+to the correct URL.
+
+**Parameters in your routing pattern:** Stop parsing the requested URL path,
+just give the path segment a name and the router delivers the dynamic value to
+you. Because of the design of the router, path parameters are very cheap.
+
+**Zero Garbage:** The matching and dispatching process generates zero bytes of
+garbage. In fact, the only heap allocations that are made, is by building the
+slice of the key-value pairs for path parameters. If the request path contains
+no parameters, not a single heap allocation is necessary.
+
+**Best Performance:** [Benchmarks speak for themselves](https://github.com/julienschmidt/go-http-routing-benchmark).
+See below for technical details of the implementation.
+
+**No more server crashes:** You can set a [Panic handler](http://godoc.org/github.com/julienschmidt/httprouter#Router.PanicHandler) to deal with panics
+occurring during handling a HTTP request. The router then recovers and lets the
+PanicHandler log what happened and deliver a nice error page.
+
+Of course you can also set **custom [NotFound](http://godoc.org/github.com/julienschmidt/httprouter#Router.NotFound) and  [MethodNotAllowed](http://godoc.org/github.com/julienschmidt/httprouter#Router.MethodNotAllowed) handlers** and [**serve static files**](http://godoc.org/github.com/julienschmidt/httprouter#Router.ServeFiles).
+
+## Usage
+This is just a quick introduction, view the [GoDoc](http://godoc.org/github.com/julienschmidt/httprouter) for details.
+
+Let's start with a trivial example:
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/julienschmidt/httprouter"
+    "net/http"
+    "log"
+)
+
+func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+    fmt.Fprint(w, "Welcome!\n")
+}
+
+func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+    fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
+}
+
+func main() {
+    router := httprouter.New()
+    router.GET("/", Index)
+    router.GET("/hello/:name", Hello)
+
+    log.Fatal(http.ListenAndServe(":8080", router))
+}
+```
+
+### Named parameters
+As you can see, `:name` is a *named parameter*.
+The values are accessible via `httprouter.Params`, which is just a slice of `httprouter.Param`s.
+You can get the value of a parameter either by its index in the slice, or by using the `ByName(name)` method:
+`:name` can be retrived by `ByName("name")`.
+
+Named parameters only match a single path segment:
+```
+Pattern: /user/:user
+
+ /user/gordon              match
+ /user/you                 match
+ /user/gordon/profile      no match
+ /user/                    no match
+```
+
+**Note:** Since this router has only explicit matches, you can not register static routes and parameters for the same path segment. For example you can not register the patterns `/user/new` and `/user/:user` for the same request method at the same time. The routing of different request methods is independent from each other.
+
+### Catch-All parameters
+The second type are *catch-all* parameters and have the form `*name`.
+Like the name suggests, they match everything.
+Therefore they must always be at the **end** of the pattern:
+```
+Pattern: /src/*filepath
+
+ /src/                     match
+ /src/somefile.go          match
+ /src/subdir/somefile.go   match
+```
+
+## How does it work?
+The router relies on a tree structure which makes heavy use of *common prefixes*,
+it is basically a *compact* [*prefix tree*](http://en.wikipedia.org/wiki/Trie)
+(or just [*Radix tree*](http://en.wikipedia.org/wiki/Radix_tree)).
+Nodes with a common prefix also share a common parent. Here is a short example
+what the routing tree for the `GET` request method could look like:
+
+```
+Priority   Path             Handle
+9          \                *<1>
+3          ├s               nil
+2          |├earch\         *<2>
+1          |└upport\        *<3>
+2          ├blog\           *<4>
+1          |    └:post      nil
+1          |         └\     *<5>
+2          ├about-us\       *<6>
+1          |        └team\  *<7>
+1          └contact\        *<8>
+```
+Every `*<num>` represents the memory address of a handler function (a pointer).
+If you follow a path trough the tree from the root to the leaf, you get the
+complete route path, e.g `\blog\:post\`, where `:post` is just a placeholder
+([*parameter*](#named-parameters)) for an actual post name. Unlike hash-maps, a
+tree structure also allows us to use dynamic parts like the `:post` parameter,
+since we actually match against the routing patterns instead of just comparing
+hashes. [As benchmarks show](https://github.com/julienschmidt/go-http-routing-benchmark),
+this works very well and efficient.
+
+Since URL paths have a hierarchical structure and make use only of a limited set
+of characters (byte values), it is very likely that there are a lot of common
+prefixes. This allows us to easily reduce the routing into ever smaller problems.
+Moreover the router manages a separate tree for every request method.
+For one thing it is more space efficient than holding a method->handle map in
+every single node, for another thing is also allows us to greatly reduce the
+routing problem before even starting the look-up in the prefix-tree.
+
+For even better scalability, the child nodes on each tree level are ordered by
+priority, where the priority is just the number of handles registered in sub
+nodes (children, grandchildren, and so on..).
+This helps in two ways:
+
+1. Nodes which are part of the most routing paths are evaluated first. This
+helps to make as much routes as possible to be reachable as fast as possible.
+2. It is some sort of cost compensation. The longest reachable path (highest
+cost) can always be evaluated first. The following scheme visualizes the tree
+structure. Nodes are evaluated from top to bottom and from left to right.
+
+```
+├------------
+├---------
+├-----
+├----
+├--
+├--
+└-
+```
+
+
+## Why doesn't this work with http.Handler?
+**It does!** The router itself implements the http.Handler interface.
+Moreover the router provides convenient [adapters for http.Handler](http://godoc.org/github.com/julienschmidt/httprouter#Router.Handler)s and [http.HandlerFunc](http://godoc.org/github.com/julienschmidt/httprouter#Router.HandlerFunc)s
+which allows them to be used as a [httprouter.Handle](http://godoc.org/github.com/julienschmidt/httprouter#Router.Handle) when registering a route.
+The only disadvantage is, that no parameter values can be retrieved when a
+http.Handler or http.HandlerFunc is used, since there is no efficient way to
+pass the values with the existing function parameters.
+Therefore [httprouter.Handle](http://godoc.org/github.com/julienschmidt/httprouter#Router.Handle) has a third function parameter.
+
+Just try it out for yourself, the usage of HttpRouter is very straightforward. The package is compact and minimalistic, but also probably one of the easiest routers to set up.
+
+
+## Where can I find Middleware *X*?
+This package just provides a very efficient request router with a few extra
+features. The router is just a [http.Handler](http://golang.org/pkg/net/http/#Handler),
+you can chain any http.Handler compatible middleware before the router,
+for example the [Gorilla handlers](http://www.gorillatoolkit.org/pkg/handlers).
+Or you could [just write your own](http://justinas.org/writing-http-middleware-in-go/),
+it's very easy!
+
+Alternatively, you could try [a web framework based on HttpRouter](#web-frameworks-based-on-httprouter).
+
+### Multi-domain / Sub-domains
+Here is a quick example: Does your server serve multiple domains / hosts?
+You want to use sub-domains?
+Define a router per host!
+```go
+// We need an object that implements the http.Handler interface.
+// Therefore we need a type for which we implement the ServeHTTP method.
+// We just use a map here, in which we map host names (with port) to http.Handlers
+type HostSwitch map[string]http.Handler
+
+// Implement the ServerHTTP method on our new type
+func (hs HostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Check if a http.Handler is registered for the given host.
+	// If yes, use it to handle the request.
+	if handler := hs[r.Host]; handler != nil {
+		handler.ServeHTTP(w, r)
+	} else {
+		// Handle host names for wich no handler is registered
+		http.Error(w, "Forbidden", 403) // Or Redirect?
+	}
+}
+
+func main() {
+	// Initialize a router as usual
+	router := httprouter.New()
+	router.GET("/", Index)
+	router.GET("/hello/:name", Hello)
+
+	// Make a new HostSwitch and insert the router (our http handler)
+	// for example.com and port 12345
+	hs := make(HostSwitch)
+	hs["example.com:12345"] = router
+
+	// Use the HostSwitch to listen and serve on port 12345
+	log.Fatal(http.ListenAndServe(":12345", hs))
+}
+```
+
+### Basic Authentication
+Another quick example: Basic Authentification (RFC 2617) for handles:
+
+```go
+package main
+
+import (
+    "bytes"
+    "encoding/base64"
+    "fmt"
+    "github.com/julienschmidt/httprouter"
+    "net/http"
+    "log"
+    "strings"
+)
+
+func BasicAuth(h httprouter.Handle, user, pass []byte) httprouter.Handle {
+	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		const basicAuthPrefix string = "Basic "
+
+		// Get the Basic Authentication credentials
+		auth := r.Header.Get("Authorization")
+		if strings.HasPrefix(auth, basicAuthPrefix) {
+			// Check credentials
+			payload, err := base64.StdEncoding.DecodeString(auth[len(basicAuthPrefix):])
+			if err == nil {
+				pair := bytes.SplitN(payload, []byte(":"), 2)
+				if len(pair) == 2 &&
+					bytes.Equal(pair[0], user) &&
+					bytes.Equal(pair[1], pass) {
+
+					// Delegate request to the given handle
+					h(w, r, ps)
+					return
+				}
+			}
+		}
+
+		// Request Basic Authentication otherwise
+		w.Header().Set("WWW-Authenticate", "Basic realm=Restricted")
+		http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
+	}
+}
+
+func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+    fmt.Fprint(w, "Not protected!\n")
+}
+
+func Protected(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+    fmt.Fprint(w, "Protected!\n")
+}
+
+func main() {
+    user := []byte("gordon")
+    pass := []byte("secret!")
+    
+    router := httprouter.New()
+    router.GET("/", Index)
+    router.GET("/protected/", BasicAuth(Protected, user, pass))
+
+    log.Fatal(http.ListenAndServe(":8080", router))
+}
+```
+
+## Chaining with the NotFound handler
+
+**NOTE: It might be required to set [Router.HandleMethodNotAllowed](http://godoc.org/github.com/julienschmidt/httprouter#Router.HandleMethodNotAllowed) to `false` to avoid problems.**
+
+You can use another [http.HandlerFunc](http://golang.org/pkg/net/http/#HandlerFunc), for example another router, to handle requests which could not be matched by this router by using the [Router.NotFound](http://godoc.org/github.com/julienschmidt/httprouter#Router.NotFound) handler. This allows chaining.
+
+### Static files
+The `NotFound` handler can for example be used to serve static files from the root path `/` (like an index.html file along with other assets):
+```go
+// Serve static files from the ./public directory
+router.NotFound = http.FileServer(http.Dir("public")).ServeHTTP
+```
+
+But this approach sidesteps the strict core rules of this router to avoid routing problems. A cleaner approach is to use a distinct sub-path for serving files, like `/static/*filepath` or `/files/*filepath`.
+
+## Web Frameworks based on HttpRouter
+If the HttpRouter is a bit too minimalistic for you, you might try one of the following more high-level 3rd-party web frameworks building upon the HttpRouter package:
+* [Ace](https://github.com/plimble/ace): Blazing fast Go Web Framework
+* [api2go](https://github.com/univedo/api2go): A JSON API Implementation for Go
+* [Gin](https://github.com/gin-gonic/gin): Features a martini-like API with much better performance
+* [Goat](https://github.com/bahlo/goat): A minimalistic REST API server in Go
+* [Hikaru](https://github.com/najeira/hikaru): Supports standalone and Google AppEngine
+* [Hitch](https://github.com/nbio/hitch): Hitch ties httprouter, [httpcontext](https://github.com/nbio/httpcontext), and middleware up in a bow
+* [kami](https://github.com/guregu/kami): A tiny web framework using x/net/context
+* [Medeina](https://github.com/imdario/medeina): Inspired by Ruby's Roda and Cuba
+* [Neko](https://github.com/rocwong/neko): A lightweight web application framework for Golang
+* [Roxanna](https://github.com/iamthemuffinman/Roxanna): An amalgamation of httprouter, better logging, and hot reload
+* [siesta](https://github.com/VividCortex/siesta): Composable HTTP handlers with contexts
diff --git a/vendor/github.com/julienschmidt/httprouter/path.go b/vendor/github.com/julienschmidt/httprouter/path.go
new file mode 100644
index 00000000..486134db
--- /dev/null
+++ b/vendor/github.com/julienschmidt/httprouter/path.go
@@ -0,0 +1,123 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Based on the path package, Copyright 2009 The Go Authors.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package httprouter
+
+// CleanPath is the URL version of path.Clean, it returns a canonical URL path
+// for p, eliminating . and .. elements.
+//
+// The following rules are applied iteratively until no further processing can
+// be done:
+//	1. Replace multiple slashes with a single slash.
+//	2. Eliminate each . path name element (the current directory).
+//	3. Eliminate each inner .. path name element (the parent directory)
+//	   along with the non-.. element that precedes it.
+//	4. Eliminate .. elements that begin a rooted path:
+//	   that is, replace "/.." by "/" at the beginning of a path.
+//
+// If the result of this process is an empty string, "/" is returned
+func CleanPath(p string) string {
+	// Turn empty string into "/"
+	if p == "" {
+		return "/"
+	}
+
+	n := len(p)
+	var buf []byte
+
+	// Invariants:
+	//      reading from path; r is index of next byte to process.
+	//      writing to buf; w is index of next byte to write.
+
+	// path must start with '/'
+	r := 1
+	w := 1
+
+	if p[0] != '/' {
+		r = 0
+		buf = make([]byte, n+1)
+		buf[0] = '/'
+	}
+
+	trailing := n > 2 && p[n-1] == '/'
+
+	// A bit more clunky without a 'lazybuf' like the path package, but the loop
+	// gets completely inlined (bufApp). So in contrast to the path package this
+	// loop has no expensive function calls (except 1x make)
+
+	for r < n {
+		switch {
+		case p[r] == '/':
+			// empty path element, trailing slash is added after the end
+			r++
+
+		case p[r] == '.' && r+1 == n:
+			trailing = true
+			r++
+
+		case p[r] == '.' && p[r+1] == '/':
+			// . element
+			r++
+
+		case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+			// .. element: remove to last /
+			r += 2
+
+			if w > 1 {
+				// can backtrack
+				w--
+
+				if buf == nil {
+					for w > 1 && p[w] != '/' {
+						w--
+					}
+				} else {
+					for w > 1 && buf[w] != '/' {
+						w--
+					}
+				}
+			}
+
+		default:
+			// real path element.
+			// add slash if needed
+			if w > 1 {
+				bufApp(&buf, p, w, '/')
+				w++
+			}
+
+			// copy element
+			for r < n && p[r] != '/' {
+				bufApp(&buf, p, w, p[r])
+				w++
+				r++
+			}
+		}
+	}
+
+	// re-append trailing slash
+	if trailing && w > 1 {
+		bufApp(&buf, p, w, '/')
+		w++
+	}
+
+	if buf == nil {
+		return p[:w]
+	}
+	return string(buf[:w])
+}
+
+// internal helper to lazily create a buffer if necessary
+func bufApp(buf *[]byte, s string, w int, c byte) {
+	if *buf == nil {
+		if s[w] == c {
+			return
+		}
+
+		*buf = make([]byte, len(s))
+		copy(*buf, s[:w])
+	}
+	(*buf)[w] = c
+}
diff --git a/vendor/github.com/julienschmidt/httprouter/router.go b/vendor/github.com/julienschmidt/httprouter/router.go
new file mode 100644
index 00000000..155b871c
--- /dev/null
+++ b/vendor/github.com/julienschmidt/httprouter/router.go
@@ -0,0 +1,363 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+// Package httprouter is a trie based high performance HTTP request router.
+//
+// A trivial example is:
+//
+//  package main
+//
+//  import (
+//      "fmt"
+//      "github.com/julienschmidt/httprouter"
+//      "net/http"
+//      "log"
+//  )
+//
+//  func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+//      fmt.Fprint(w, "Welcome!\n")
+//  }
+//
+//  func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+//      fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
+//  }
+//
+//  func main() {
+//      router := httprouter.New()
+//      router.GET("/", Index)
+//      router.GET("/hello/:name", Hello)
+//
+//      log.Fatal(http.ListenAndServe(":8080", router))
+//  }
+//
+// The router matches incoming requests by the request method and the path.
+// If a handle is registered for this path and method, the router delegates the
+// request to that function.
+// For the methods GET, POST, PUT, PATCH and DELETE shortcut functions exist to
+// register handles, for all other methods router.Handle can be used.
+//
+// The registered path, against which the router matches incoming requests, can
+// contain two types of parameters:
+//  Syntax    Type
+//  :name     named parameter
+//  *name     catch-all parameter
+//
+// Named parameters are dynamic path segments. They match anything until the
+// next '/' or the path end:
+//  Path: /blog/:category/:post
+//
+//  Requests:
+//   /blog/go/request-routers            match: category="go", post="request-routers"
+//   /blog/go/request-routers/           no match, but the router would redirect
+//   /blog/go/                           no match
+//   /blog/go/request-routers/comments   no match
+//
+// Catch-all parameters match anything until the path end, including the
+// directory index (the '/' before the catch-all). Since they match anything
+// until the end, catch-all paramerters must always be the final path element.
+//  Path: /files/*filepath
+//
+//  Requests:
+//   /files/                             match: filepath="/"
+//   /files/LICENSE                      match: filepath="/LICENSE"
+//   /files/templates/article.html       match: filepath="/templates/article.html"
+//   /files                              no match, but the router would redirect
+//
+// The value of parameters is saved as a slice of the Param struct, consisting
+// each of a key and a value. The slice is passed to the Handle func as a third
+// parameter.
+// There are two ways to retrieve the value of a parameter:
+//  // by the name of the parameter
+//  user := ps.ByName("user") // defined by :user or *user
+//
+//  // by the index of the parameter. This way you can also get the name (key)
+//  thirdKey   := ps[2].Key   // the name of the 3rd parameter
+//  thirdValue := ps[2].Value // the value of the 3rd parameter
+package httprouter
+
+import (
+	"net/http"
+)
+
+// Handle is a function that can be registered to a route to handle HTTP
+// requests. Like http.HandlerFunc, but has a third parameter for the values of
+// wildcards (variables).
+type Handle func(http.ResponseWriter, *http.Request, Params)
+
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+	Key   string
+	Value string
+}
+
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) ByName(name string) string {
+	for i := range ps {
+		if ps[i].Key == name {
+			return ps[i].Value
+		}
+	}
+	return ""
+}
+
+// Router is a http.Handler which can be used to dispatch requests to different
+// handler functions via configurable routes
+type Router struct {
+	trees map[string]*node
+
+	// Enables automatic redirection if the current route can't be matched but a
+	// handler for the path with (without) the trailing slash exists.
+	// For example if /foo/ is requested but a route only exists for /foo, the
+	// client is redirected to /foo with http status code 301 for GET requests
+	// and 307 for all other request methods.
+	RedirectTrailingSlash bool
+
+	// If enabled, the router tries to fix the current request path, if no
+	// handle is registered for it.
+	// First superfluous path elements like ../ or // are removed.
+	// Afterwards the router does a case-insensitive lookup of the cleaned path.
+	// If a handle can be found for this route, the router makes a redirection
+	// to the corrected path with status code 301 for GET requests and 307 for
+	// all other request methods.
+	// For example /FOO and /..//Foo could be redirected to /foo.
+	// RedirectTrailingSlash is independent of this option.
+	RedirectFixedPath bool
+
+	// If enabled, the router checks if another method is allowed for the
+	// current route, if the current request can not be routed.
+	// If this is the case, the request is answered with 'Method Not Allowed'
+	// and HTTP status code 405.
+	// If no other Method is allowed, the request is delegated to the NotFound
+	// handler.
+	HandleMethodNotAllowed bool
+
+	// Configurable http.HandlerFunc which is called when no matching route is
+	// found. If it is not set, http.NotFound is used.
+	NotFound http.HandlerFunc
+
+	// Configurable http.HandlerFunc which is called when a request
+	// cannot be routed and HandleMethodNotAllowed is true.
+	// If it is not set, http.Error with http.StatusMethodNotAllowed is used.
+	MethodNotAllowed http.HandlerFunc
+
+	// Function to handle panics recovered from http handlers.
+	// It should be used to generate a error page and return the http error code
+	// 500 (Internal Server Error).
+	// The handler can be used to keep your server from crashing because of
+	// unrecovered panics.
+	PanicHandler func(http.ResponseWriter, *http.Request, interface{})
+}
+
+// Make sure the Router conforms with the http.Handler interface
+var _ http.Handler = New()
+
+// New returns a new initialized Router.
+// Path auto-correction, including trailing slashes, is enabled by default.
+func New() *Router {
+	return &Router{
+		RedirectTrailingSlash:  true,
+		RedirectFixedPath:      true,
+		HandleMethodNotAllowed: true,
+	}
+}
+
+// GET is a shortcut for router.Handle("GET", path, handle)
+func (r *Router) GET(path string, handle Handle) {
+	r.Handle("GET", path, handle)
+}
+
+// HEAD is a shortcut for router.Handle("HEAD", path, handle)
+func (r *Router) HEAD(path string, handle Handle) {
+	r.Handle("HEAD", path, handle)
+}
+
+// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle)
+func (r *Router) OPTIONS(path string, handle Handle) {
+	r.Handle("OPTIONS", path, handle)
+}
+
+// POST is a shortcut for router.Handle("POST", path, handle)
+func (r *Router) POST(path string, handle Handle) {
+	r.Handle("POST", path, handle)
+}
+
+// PUT is a shortcut for router.Handle("PUT", path, handle)
+func (r *Router) PUT(path string, handle Handle) {
+	r.Handle("PUT", path, handle)
+}
+
+// PATCH is a shortcut for router.Handle("PATCH", path, handle)
+func (r *Router) PATCH(path string, handle Handle) {
+	r.Handle("PATCH", path, handle)
+}
+
+// DELETE is a shortcut for router.Handle("DELETE", path, handle)
+func (r *Router) DELETE(path string, handle Handle) {
+	r.Handle("DELETE", path, handle)
+}
+
+// Handle registers a new request handle with the given path and method.
+//
+// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
+// functions can be used.
+//
+// This function is intended for bulk loading and to allow the usage of less
+// frequently used, non-standardized or custom methods (e.g. for internal
+// communication with a proxy).
+func (r *Router) Handle(method, path string, handle Handle) {
+	if path[0] != '/' {
+		panic("path must begin with '/' in path '" + path + "'")
+	}
+
+	if r.trees == nil {
+		r.trees = make(map[string]*node)
+	}
+
+	root := r.trees[method]
+	if root == nil {
+		root = new(node)
+		r.trees[method] = root
+	}
+
+	root.addRoute(path, handle)
+}
+
+// Handler is an adapter which allows the usage of an http.Handler as a
+// request handle.
+func (r *Router) Handler(method, path string, handler http.Handler) {
+	r.Handle(method, path,
+		func(w http.ResponseWriter, req *http.Request, _ Params) {
+			handler.ServeHTTP(w, req)
+		},
+	)
+}
+
+// HandlerFunc is an adapter which allows the usage of an http.HandlerFunc as a
+// request handle.
+func (r *Router) HandlerFunc(method, path string, handler http.HandlerFunc) {
+	r.Handler(method, path, handler)
+}
+
+// ServeFiles serves files from the given file system root.
+// The path must end with "/*filepath", files are then served from the local
+// path /defined/root/dir/*filepath.
+// For example if root is "/etc" and *filepath is "passwd", the local file
+// "/etc/passwd" would be served.
+// Internally a http.FileServer is used, therefore http.NotFound is used instead
+// of the Router's NotFound handler.
+// To use the operating system's file system implementation,
+// use http.Dir:
+//     router.ServeFiles("/src/*filepath", http.Dir("/var/www"))
+func (r *Router) ServeFiles(path string, root http.FileSystem) {
+	if len(path) < 10 || path[len(path)-10:] != "/*filepath" {
+		panic("path must end with /*filepath in path '" + path + "'")
+	}
+
+	fileServer := http.FileServer(root)
+
+	r.GET(path, func(w http.ResponseWriter, req *http.Request, ps Params) {
+		req.URL.Path = ps.ByName("filepath")
+		fileServer.ServeHTTP(w, req)
+	})
+}
+
+func (r *Router) recv(w http.ResponseWriter, req *http.Request) {
+	if rcv := recover(); rcv != nil {
+		r.PanicHandler(w, req, rcv)
+	}
+}
+
+// Lookup allows the manual lookup of a method + path combo.
+// This is e.g. useful to build a framework around this router.
+// If the path was found, it returns the handle function and the path parameter
+// values. Otherwise the third return value indicates whether a redirection to
+// the same path with an extra / without the trailing slash should be performed.
+func (r *Router) Lookup(method, path string) (Handle, Params, bool) {
+	if root := r.trees[method]; root != nil {
+		return root.getValue(path)
+	}
+	return nil, nil, false
+}
+
+// ServeHTTP makes the router implement the http.Handler interface.
+func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	if r.PanicHandler != nil {
+		defer r.recv(w, req)
+	}
+
+	if root := r.trees[req.Method]; root != nil {
+		path := req.URL.Path
+
+		if handle, ps, tsr := root.getValue(path); handle != nil {
+			handle(w, req, ps)
+			return
+		} else if req.Method != "CONNECT" && path != "/" {
+			code := 301 // Permanent redirect, request with GET method
+			if req.Method != "GET" {
+				// Temporary redirect, request with same method
+				// As of Go 1.3, Go does not support status code 308.
+				code = 307
+			}
+
+			if tsr && r.RedirectTrailingSlash {
+				if len(path) > 1 && path[len(path)-1] == '/' {
+					req.URL.Path = path[:len(path)-1]
+				} else {
+					req.URL.Path = path + "/"
+				}
+				http.Redirect(w, req, req.URL.String(), code)
+				return
+			}
+
+			// Try to fix the request path
+			if r.RedirectFixedPath {
+				fixedPath, found := root.findCaseInsensitivePath(
+					CleanPath(path),
+					r.RedirectTrailingSlash,
+				)
+				if found {
+					req.URL.Path = string(fixedPath)
+					http.Redirect(w, req, req.URL.String(), code)
+					return
+				}
+			}
+		}
+	}
+
+	// Handle 405
+	if r.HandleMethodNotAllowed {
+		for method := range r.trees {
+			// Skip the requested method - we already tried this one
+			if method == req.Method {
+				continue
+			}
+
+			handle, _, _ := r.trees[method].getValue(req.URL.Path)
+			if handle != nil {
+				if r.MethodNotAllowed != nil {
+					r.MethodNotAllowed(w, req)
+				} else {
+					http.Error(w,
+						http.StatusText(http.StatusMethodNotAllowed),
+						http.StatusMethodNotAllowed,
+					)
+				}
+				return
+			}
+		}
+	}
+
+	// Handle 404
+	if r.NotFound != nil {
+		r.NotFound(w, req)
+	} else {
+		http.NotFound(w, req)
+	}
+}
diff --git a/vendor/github.com/julienschmidt/httprouter/tree.go b/vendor/github.com/julienschmidt/httprouter/tree.go
new file mode 100644
index 00000000..a15bc2cb
--- /dev/null
+++ b/vendor/github.com/julienschmidt/httprouter/tree.go
@@ -0,0 +1,555 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// in the LICENSE file.
+
+package httprouter
+
+import (
+	"strings"
+	"unicode"
+)
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+func countParams(path string) uint8 {
+	var n uint
+	for i := 0; i < len(path); i++ {
+		if path[i] != ':' && path[i] != '*' {
+			continue
+		}
+		n++
+	}
+	if n >= 255 {
+		return 255
+	}
+	return uint8(n)
+}
+
+type nodeType uint8
+
+const (
+	static   nodeType = 0
+	param    nodeType = 1
+	catchAll nodeType = 2
+)
+
+type node struct {
+	path      string
+	wildChild bool
+	nType     nodeType
+	maxParams uint8
+	indices   string
+	children  []*node
+	handle    Handle
+	priority  uint32
+}
+
+// increments priority of the given child and reorders if necessary
+func (n *node) incrementChildPrio(pos int) int {
+	n.children[pos].priority++
+	prio := n.children[pos].priority
+
+	// adjust position (move to front)
+	newPos := pos
+	for newPos > 0 && n.children[newPos-1].priority < prio {
+		// swap node positions
+		tmpN := n.children[newPos-1]
+		n.children[newPos-1] = n.children[newPos]
+		n.children[newPos] = tmpN
+
+		newPos--
+	}
+
+	// build new index char string
+	if newPos != pos {
+		n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
+			n.indices[pos:pos+1] + // the index char we move
+			n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
+	}
+
+	return newPos
+}
+
+// addRoute adds a node with the given handle to the path.
+// Not concurrency-safe!
+func (n *node) addRoute(path string, handle Handle) {
+	fullPath := path
+	n.priority++
+	numParams := countParams(path)
+
+	// non-empty tree
+	if len(n.path) > 0 || len(n.children) > 0 {
+	walk:
+		for {
+			// Update maxParams of the current node
+			if numParams > n.maxParams {
+				n.maxParams = numParams
+			}
+
+			// Find the longest common prefix.
+			// This also implies that the common prefix contains no ':' or '*'
+			// since the existing key can't contain those chars.
+			i := 0
+			max := min(len(path), len(n.path))
+			for i < max && path[i] == n.path[i] {
+				i++
+			}
+
+			// Split edge
+			if i < len(n.path) {
+				child := node{
+					path:      n.path[i:],
+					wildChild: n.wildChild,
+					indices:   n.indices,
+					children:  n.children,
+					handle:    n.handle,
+					priority:  n.priority - 1,
+				}
+
+				// Update maxParams (max of all children)
+				for i := range child.children {
+					if child.children[i].maxParams > child.maxParams {
+						child.maxParams = child.children[i].maxParams
+					}
+				}
+
+				n.children = []*node{&child}
+				// []byte for proper unicode char conversion, see #65
+				n.indices = string([]byte{n.path[i]})
+				n.path = path[:i]
+				n.handle = nil
+				n.wildChild = false
+			}
+
+			// Make new node a child of this node
+			if i < len(path) {
+				path = path[i:]
+
+				if n.wildChild {
+					n = n.children[0]
+					n.priority++
+
+					// Update maxParams of the child node
+					if numParams > n.maxParams {
+						n.maxParams = numParams
+					}
+					numParams--
+
+					// Check if the wildcard matches
+					if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
+						// check for longer wildcard, e.g. :name and :names
+						if len(n.path) >= len(path) || path[len(n.path)] == '/' {
+							continue walk
+						}
+					}
+
+					panic("path segment '" + path +
+						"' conflicts with existing wildcard '" + n.path +
+						"' in path '" + fullPath + "'")
+				}
+
+				c := path[0]
+
+				// slash after param
+				if n.nType == param && c == '/' && len(n.children) == 1 {
+					n = n.children[0]
+					n.priority++
+					continue walk
+				}
+
+				// Check if a child with the next path byte exists
+				for i := 0; i < len(n.indices); i++ {
+					if c == n.indices[i] {
+						i = n.incrementChildPrio(i)
+						n = n.children[i]
+						continue walk
+					}
+				}
+
+				// Otherwise insert it
+				if c != ':' && c != '*' {
+					// []byte for proper unicode char conversion, see #65
+					n.indices += string([]byte{c})
+					child := &node{
+						maxParams: numParams,
+					}
+					n.children = append(n.children, child)
+					n.incrementChildPrio(len(n.indices) - 1)
+					n = child
+				}
+				n.insertChild(numParams, path, fullPath, handle)
+				return
+
+			} else if i == len(path) { // Make node a (in-path) leaf
+				if n.handle != nil {
+					panic("a handle is already registered for path ''" + fullPath + "'")
+				}
+				n.handle = handle
+			}
+			return
+		}
+	} else { // Empty tree
+		n.insertChild(numParams, path, fullPath, handle)
+	}
+}
+
+func (n *node) insertChild(numParams uint8, path, fullPath string, handle Handle) {
+	var offset int // already handled bytes of the path
+
+	// find prefix until first wildcard (beginning with ':'' or '*'')
+	for i, max := 0, len(path); numParams > 0; i++ {
+		c := path[i]
+		if c != ':' && c != '*' {
+			continue
+		}
+
+		// find wildcard end (either '/' or path end)
+		end := i + 1
+		for end < max && path[end] != '/' {
+			switch path[end] {
+			// the wildcard name must not contain ':' and '*'
+			case ':', '*':
+				panic("only one wildcard per path segment is allowed, has: '" +
+					path[i:] + "' in path '" + fullPath + "'")
+			default:
+				end++
+			}
+		}
+
+		// check if this Node existing children which would be
+		// unreachable if we insert the wildcard here
+		if len(n.children) > 0 {
+			panic("wildcard route '" + path[i:end] +
+				"' conflicts with existing children in path '" + fullPath + "'")
+		}
+
+		// check if the wildcard has a name
+		if end-i < 2 {
+			panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
+		}
+
+		if c == ':' { // param
+			// split path at the beginning of the wildcard
+			if i > 0 {
+				n.path = path[offset:i]
+				offset = i
+			}
+
+			child := &node{
+				nType:     param,
+				maxParams: numParams,
+			}
+			n.children = []*node{child}
+			n.wildChild = true
+			n = child
+			n.priority++
+			numParams--
+
+			// if the path doesn't end with the wildcard, then there
+			// will be another non-wildcard subpath starting with '/'
+			if end < max {
+				n.path = path[offset:end]
+				offset = end
+
+				child := &node{
+					maxParams: numParams,
+					priority:  1,
+				}
+				n.children = []*node{child}
+				n = child
+			}
+
+		} else { // catchAll
+			if end != max || numParams > 1 {
+				panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
+			}
+
+			if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
+				panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
+			}
+
+			// currently fixed width 1 for '/'
+			i--
+			if path[i] != '/' {
+				panic("no / before catch-all in path '" + fullPath + "'")
+			}
+
+			n.path = path[offset:i]
+
+			// first node: catchAll node with empty path
+			child := &node{
+				wildChild: true,
+				nType:     catchAll,
+				maxParams: 1,
+			}
+			n.children = []*node{child}
+			n.indices = string(path[i])
+			n = child
+			n.priority++
+
+			// second node: node holding the variable
+			child = &node{
+				path:      path[i:],
+				nType:     catchAll,
+				maxParams: 1,
+				handle:    handle,
+				priority:  1,
+			}
+			n.children = []*node{child}
+
+			return
+		}
+	}
+
+	// insert remaining path part and handle to the leaf
+	n.path = path[offset:]
+	n.handle = handle
+}
+
+// Returns the handle registered with the given path (key). The values of
+// wildcards are saved to a map.
+// If no handle can be found, a TSR (trailing slash redirect) recommendation is
+// made if a handle exists with an extra (without the) trailing slash for the
+// given path.
+func (n *node) getValue(path string) (handle Handle, p Params, tsr bool) {
+walk: // Outer loop for walking the tree
+	for {
+		if len(path) > len(n.path) {
+			if path[:len(n.path)] == n.path {
+				path = path[len(n.path):]
+				// If this node does not have a wildcard (param or catchAll)
+				// child,  we can just look up the next child node and continue
+				// to walk down the tree
+				if !n.wildChild {
+					c := path[0]
+					for i := 0; i < len(n.indices); i++ {
+						if c == n.indices[i] {
+							n = n.children[i]
+							continue walk
+						}
+					}
+
+					// Nothing found.
+					// We can recommend to redirect to the same URL without a
+					// trailing slash if a leaf exists for that path.
+					tsr = (path == "/" && n.handle != nil)
+					return
+
+				}
+
+				// handle wildcard child
+				n = n.children[0]
+				switch n.nType {
+				case param:
+					// find param end (either '/' or path end)
+					end := 0
+					for end < len(path) && path[end] != '/' {
+						end++
+					}
+
+					// save param value
+					if p == nil {
+						// lazy allocation
+						p = make(Params, 0, n.maxParams)
+					}
+					i := len(p)
+					p = p[:i+1] // expand slice within preallocated capacity
+					p[i].Key = n.path[1:]
+					p[i].Value = path[:end]
+
+					// we need to go deeper!
+					if end < len(path) {
+						if len(n.children) > 0 {
+							path = path[end:]
+							n = n.children[0]
+							continue walk
+						}
+
+						// ... but we can't
+						tsr = (len(path) == end+1)
+						return
+					}
+
+					if handle = n.handle; handle != nil {
+						return
+					} else if len(n.children) == 1 {
+						// No handle found. Check if a handle for this path + a
+						// trailing slash exists for TSR recommendation
+						n = n.children[0]
+						tsr = (n.path == "/" && n.handle != nil)
+					}
+
+					return
+
+				case catchAll:
+					// save param value
+					if p == nil {
+						// lazy allocation
+						p = make(Params, 0, n.maxParams)
+					}
+					i := len(p)
+					p = p[:i+1] // expand slice within preallocated capacity
+					p[i].Key = n.path[2:]
+					p[i].Value = path
+
+					handle = n.handle
+					return
+
+				default:
+					panic("invalid node type")
+				}
+			}
+		} else if path == n.path {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if handle = n.handle; handle != nil {
+				return
+			}
+
+			// No handle found. Check if a handle for this path + a
+			// trailing slash exists for trailing slash recommendation
+			for i := 0; i < len(n.indices); i++ {
+				if n.indices[i] == '/' {
+					n = n.children[i]
+					tsr = (len(n.path) == 1 && n.handle != nil) ||
+						(n.nType == catchAll && n.children[0].handle != nil)
+					return
+				}
+			}
+
+			return
+		}
+
+		// Nothing found. We can recommend to redirect to the same URL with an
+		// extra trailing slash if a leaf exists for that path
+		tsr = (path == "/") ||
+			(len(n.path) == len(path)+1 && n.path[len(path)] == '/' &&
+				path == n.path[:len(n.path)-1] && n.handle != nil)
+		return
+	}
+}
+
+// Makes a case-insensitive lookup of the given path and tries to find a handler.
+// It can optionally also fix trailing slashes.
+// It returns the case-corrected path and a bool indicating whether the lookup
+// was successful.
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
+	ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
+
+	// Outer loop for walking the tree
+	for len(path) >= len(n.path) && strings.ToLower(path[:len(n.path)]) == strings.ToLower(n.path) {
+		path = path[len(n.path):]
+		ciPath = append(ciPath, n.path...)
+
+		if len(path) > 0 {
+			// If this node does not have a wildcard (param or catchAll) child,
+			// we can just look up the next child node and continue to walk down
+			// the tree
+			if !n.wildChild {
+				r := unicode.ToLower(rune(path[0]))
+				for i, index := range n.indices {
+					// must use recursive approach since both index and
+					// ToLower(index) could exist. We must check both.
+					if r == unicode.ToLower(index) {
+						out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
+						if found {
+							return append(ciPath, out...), true
+						}
+					}
+				}
+
+				// Nothing found. We can recommend to redirect to the same URL
+				// without a trailing slash if a leaf exists for that path
+				found = (fixTrailingSlash && path == "/" && n.handle != nil)
+				return
+			}
+
+			n = n.children[0]
+			switch n.nType {
+			case param:
+				// find param end (either '/' or path end)
+				k := 0
+				for k < len(path) && path[k] != '/' {
+					k++
+				}
+
+				// add param value to case insensitive path
+				ciPath = append(ciPath, path[:k]...)
+
+				// we need to go deeper!
+				if k < len(path) {
+					if len(n.children) > 0 {
+						path = path[k:]
+						n = n.children[0]
+						continue
+					}
+
+					// ... but we can't
+					if fixTrailingSlash && len(path) == k+1 {
+						return ciPath, true
+					}
+					return
+				}
+
+				if n.handle != nil {
+					return ciPath, true
+				} else if fixTrailingSlash && len(n.children) == 1 {
+					// No handle found. Check if a handle for this path + a
+					// trailing slash exists
+					n = n.children[0]
+					if n.path == "/" && n.handle != nil {
+						return append(ciPath, '/'), true
+					}
+				}
+				return
+
+			case catchAll:
+				return append(ciPath, path...), true
+
+			default:
+				panic("invalid node type")
+			}
+		} else {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if n.handle != nil {
+				return ciPath, true
+			}
+
+			// No handle found.
+			// Try to fix the path by adding a trailing slash
+			if fixTrailingSlash {
+				for i := 0; i < len(n.indices); i++ {
+					if n.indices[i] == '/' {
+						n = n.children[i]
+						if (len(n.path) == 1 && n.handle != nil) ||
+							(n.nType == catchAll && n.children[0].handle != nil) {
+							return append(ciPath, '/'), true
+						}
+						return
+					}
+				}
+			}
+			return
+		}
+	}
+
+	// Nothing found.
+	// Try to fix the path by adding / removing a trailing slash
+	if fixTrailingSlash {
+		if path == "/" {
+			return ciPath, true
+		}
+		if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
+			strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) &&
+			n.handle != nil {
+			return append(ciPath, n.path...), true
+		}
+	}
+	return
+}
diff --git a/vendor/github.com/lib/pq/.gitignore b/vendor/github.com/lib/pq/.gitignore
new file mode 100644
index 00000000..0f1d00e1
--- /dev/null
+++ b/vendor/github.com/lib/pq/.gitignore
@@ -0,0 +1,4 @@
+.db
+*.test
+*~
+*.swp
diff --git a/vendor/github.com/lib/pq/.travis.yml b/vendor/github.com/lib/pq/.travis.yml
new file mode 100644
index 00000000..9bf68373
--- /dev/null
+++ b/vendor/github.com/lib/pq/.travis.yml
@@ -0,0 +1,68 @@
+language: go
+
+go:
+  - 1.1
+  - 1.2
+  - 1.3
+  - 1.4
+  - tip
+
+before_install:
+  - psql --version
+  - sudo /etc/init.d/postgresql stop
+  - sudo apt-get -y --purge remove postgresql libpq-dev libpq5 postgresql-client-common postgresql-common
+  - sudo rm -rf /var/lib/postgresql
+  - wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
+  - sudo sh -c "echo deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main $PGVERSION >> /etc/apt/sources.list.d/postgresql.list"
+  - sudo apt-get update -qq
+  - sudo apt-get -y -o Dpkg::Options::=--force-confdef -o Dpkg::Options::="--force-confnew" install postgresql-$PGVERSION postgresql-server-dev-$PGVERSION postgresql-contrib-$PGVERSION
+  - sudo chmod 777 /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "local     all         postgres                          trust" > /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "local     all         all                               trust" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostnossl all         pqgossltest 127.0.0.1/32          reject" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostnossl all         pqgosslcert 127.0.0.1/32          reject" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostssl   all         pqgossltest 127.0.0.1/32          trust"  >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostssl   all         pqgosslcert 127.0.0.1/32          cert"  >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "host      all         all         127.0.0.1/32          trust" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostnossl all         pqgossltest ::1/128               reject" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostnossl all         pqgosslcert ::1/128               reject" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostssl   all         pqgossltest ::1/128               trust" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "hostssl   all         pqgosslcert ::1/128               cert" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - echo "host      all         all         ::1/128               trust" >> /etc/postgresql/$PGVERSION/main/pg_hba.conf
+  - sudo install -o postgres -g postgres -m 600 -t /var/lib/postgresql/$PGVERSION/main/ certs/server.key certs/server.crt certs/root.crt
+  - sudo bash -c "[[ '${PGVERSION}' < '9.2' ]] || (echo \"ssl_cert_file = 'server.crt'\" >> /etc/postgresql/$PGVERSION/main/postgresql.conf)"
+  - sudo bash -c "[[ '${PGVERSION}' < '9.2' ]] || (echo \"ssl_key_file = 'server.key'\" >> /etc/postgresql/$PGVERSION/main/postgresql.conf)"
+  - sudo bash -c "[[ '${PGVERSION}' < '9.2' ]] || (echo \"ssl_ca_file = 'root.crt'\" >> /etc/postgresql/$PGVERSION/main/postgresql.conf)"
+  - sudo sh -c "echo 127.0.0.1 postgres >> /etc/hosts"
+  - sudo ls -l /var/lib/postgresql/$PGVERSION/main/
+  - sudo cat /etc/postgresql/$PGVERSION/main/postgresql.conf
+  - sudo chmod 600 $PQSSLCERTTEST_PATH/postgresql.key
+  - sudo /etc/init.d/postgresql restart
+
+env:
+  global:
+    - PGUSER=postgres
+    - PQGOSSLTESTS=1
+    - PQSSLCERTTEST_PATH=$PWD/certs
+    - PGHOST=127.0.0.1
+  matrix:
+    - PGVERSION=9.4 PQTEST_BINARY_PARAMETERS=yes
+    - PGVERSION=9.3 PQTEST_BINARY_PARAMETERS=yes
+    - PGVERSION=9.2 PQTEST_BINARY_PARAMETERS=yes
+    - PGVERSION=9.1 PQTEST_BINARY_PARAMETERS=yes
+    - PGVERSION=9.0 PQTEST_BINARY_PARAMETERS=yes
+    - PGVERSION=8.4 PQTEST_BINARY_PARAMETERS=yes
+    - PGVERSION=9.4 PQTEST_BINARY_PARAMETERS=no
+    - PGVERSION=9.3 PQTEST_BINARY_PARAMETERS=no
+    - PGVERSION=9.2 PQTEST_BINARY_PARAMETERS=no
+    - PGVERSION=9.1 PQTEST_BINARY_PARAMETERS=no
+    - PGVERSION=9.0 PQTEST_BINARY_PARAMETERS=no
+    - PGVERSION=8.4 PQTEST_BINARY_PARAMETERS=no
+
+script:
+ - go test -v ./...
+
+before_script:
+ - psql -c 'create database pqgotest' -U postgres
+ - psql -c 'create user pqgossltest' -U postgres
+ - psql -c 'create user pqgosslcert' -U postgres
diff --git a/vendor/github.com/lib/pq/CONTRIBUTING.md b/vendor/github.com/lib/pq/CONTRIBUTING.md
new file mode 100644
index 00000000..84c937f1
--- /dev/null
+++ b/vendor/github.com/lib/pq/CONTRIBUTING.md
@@ -0,0 +1,29 @@
+## Contributing to pq
+
+`pq` has a backlog of pull requests, but contributions are still very
+much welcome. You can help with patch review, submitting bug reports,
+or adding new functionality. There is no formal style guide, but
+please conform to the style of existing code and general Go formatting
+conventions when submitting patches.
+
+### Patch review
+
+Help review existing open pull requests by commenting on the code or
+proposed functionality.
+
+### Bug reports
+
+We appreciate any bug reports, but especially ones with self-contained
+(doesn't depend on code outside of pq), minimal (can't be simplified
+further) test cases. It's especially helpful if you can submit a pull
+request with just the failing test case (you'll probably want to
+pattern it after the tests in
+[conn_test.go](https://github.com/lib/pq/blob/master/conn_test.go).
+
+### New functionality
+
+There are a number of pending patches for new functionality, so
+additional feature patches will take a while to merge. Still, patches
+are generally reviewed based on usefulness and complexity in addition
+to time-in-queue, so if you have a knockout idea, take a shot. Feel
+free to open an issue discussion your proposed patch beforehand.
diff --git a/vendor/github.com/lib/pq/LICENSE.md b/vendor/github.com/lib/pq/LICENSE.md
new file mode 100644
index 00000000..5773904a
--- /dev/null
+++ b/vendor/github.com/lib/pq/LICENSE.md
@@ -0,0 +1,8 @@
+Copyright (c) 2011-2013, 'pq' Contributors
+Portions Copyright (C) 2011 Blake Mizerany
+
+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.
diff --git a/vendor/github.com/lib/pq/README.md b/vendor/github.com/lib/pq/README.md
new file mode 100644
index 00000000..358d644f
--- /dev/null
+++ b/vendor/github.com/lib/pq/README.md
@@ -0,0 +1,103 @@
+# pq - A pure Go postgres driver for Go's database/sql package
+
+[![Build Status](https://travis-ci.org/lib/pq.png?branch=master)](https://travis-ci.org/lib/pq)
+
+## Install
+
+	go get github.com/lib/pq
+
+## Docs
+
+For detailed documentation and basic usage examples, please see the package
+documentation at <http://godoc.org/github.com/lib/pq>.
+
+## Tests
+
+`go test` is used for testing.  A running PostgreSQL server is
+required, with the ability to log in.  The default database to connect
+to test with is "pqgotest," but it can be overridden using environment
+variables.
+
+Example:
+
+	PGHOST=/var/run/postgresql go test github.com/lib/pq
+
+Optionally, a benchmark suite can be run as part of the tests:
+
+	PGHOST=/var/run/postgresql go test -bench .
+
+## Features
+
+* SSL
+* Handles bad connections for `database/sql`
+* Scan `time.Time` correctly (i.e. `timestamp[tz]`, `time[tz]`, `date`)
+* Scan binary blobs correctly (i.e. `bytea`)
+* Package for `hstore` support
+* COPY FROM support
+* pq.ParseURL for converting urls to connection strings for sql.Open.
+* Many libpq compatible environment variables
+* Unix socket support
+* Notifications: `LISTEN`/`NOTIFY`
+
+## Future / Things you can help with
+
+* Better COPY FROM / COPY TO (see discussion in #181)
+
+## Thank you (alphabetical)
+
+Some of these contributors are from the original library `bmizerany/pq.go` whose
+code still exists in here.
+
+* Andy Balholm (andybalholm)
+* Ben Berkert (benburkert)
+* Benjamin Heatwole (bheatwole)
+* Bill Mill (llimllib)
+* Bjørn Madsen (aeons)
+* Blake Gentry (bgentry)
+* Brad Fitzpatrick (bradfitz)
+* Charlie Melbye (cmelbye)
+* Chris Bandy (cbandy)
+* Chris Gilling (cgilling)
+* Chris Walsh (cwds)
+* Dan Sosedoff (sosedoff)
+* Daniel Farina (fdr)
+* Eric Chlebek (echlebek)
+* Eric Garrido (minusnine)
+* Eric Urban (hydrogen18)
+* Everyone at The Go Team
+* Evan Shaw (edsrzf)
+* Ewan Chou (coocood)
+* Federico Romero (federomero)
+* Fumin (fumin)
+* Gary Burd (garyburd)
+* Heroku (heroku)
+* James Pozdena (jpoz)
+* Jason McVetta (jmcvetta)
+* Jeremy Jay (pbnjay)
+* Joakim Sernbrant (serbaut)
+* John Gallagher (jgallagher)
+* Jonathan Rudenberg (titanous)
+* Joël Stemmer (jstemmer)
+* Kamil Kisiel (kisielk)
+* Kelly Dunn (kellydunn)
+* Keith Rarick (kr)
+* Kir Shatrov (kirs)
+* Lann Martin (lann)
+* Maciek Sakrejda (deafbybeheading)
+* Marc Brinkmann (mbr)
+* Marko Tiikkaja (johto)
+* Matt Newberry (MattNewberry)
+* Matt Robenolt (mattrobenolt)
+* Martin Olsen (martinolsen)
+* Mike Lewis (mikelikespie)
+* Nicolas Patry (Narsil)
+* Oliver Tonnhofer (olt)
+* Patrick Hayes (phayes)
+* Paul Hammond (paulhammond)
+* Ryan Smith (ryandotsmith)
+* Samuel Stauffer (samuel)
+* Timothée Peignier (cyberdelia)
+* Travis Cline (tmc)
+* TruongSinh Tran-Nguyen (truongsinh)
+* Yaismel Miranda (ympons)
+* notedit (notedit)
diff --git a/vendor/github.com/lib/pq/buf.go b/vendor/github.com/lib/pq/buf.go
new file mode 100644
index 00000000..e7ff5777
--- /dev/null
+++ b/vendor/github.com/lib/pq/buf.go
@@ -0,0 +1,90 @@
+package pq
+
+import (
+	"bytes"
+	"encoding/binary"
+
+	"github.com/lib/pq/oid"
+)
+
+type readBuf []byte
+
+func (b *readBuf) int32() (n int) {
+	n = int(int32(binary.BigEndian.Uint32(*b)))
+	*b = (*b)[4:]
+	return
+}
+
+func (b *readBuf) oid() (n oid.Oid) {
+	n = oid.Oid(binary.BigEndian.Uint32(*b))
+	*b = (*b)[4:]
+	return
+}
+
+func (b *readBuf) int16() (n int) {
+	n = int(binary.BigEndian.Uint16(*b))
+	*b = (*b)[2:]
+	return
+}
+
+func (b *readBuf) string() string {
+	i := bytes.IndexByte(*b, 0)
+	if i < 0 {
+		errorf("invalid message format; expected string terminator")
+	}
+	s := (*b)[:i]
+	*b = (*b)[i+1:]
+	return string(s)
+}
+
+func (b *readBuf) next(n int) (v []byte) {
+	v = (*b)[:n]
+	*b = (*b)[n:]
+	return
+}
+
+func (b *readBuf) byte() byte {
+	return b.next(1)[0]
+}
+
+type writeBuf struct {
+	buf []byte
+	pos int
+}
+
+func (b *writeBuf) int32(n int) {
+	x := make([]byte, 4)
+	binary.BigEndian.PutUint32(x, uint32(n))
+	b.buf = append(b.buf, x...)
+}
+
+func (b *writeBuf) int16(n int) {
+	x := make([]byte, 2)
+	binary.BigEndian.PutUint16(x, uint16(n))
+	b.buf = append(b.buf, x...)
+}
+
+func (b *writeBuf) string(s string) {
+	b.buf = append(b.buf, (s + "\000")...)
+}
+
+func (b *writeBuf) byte(c byte) {
+	b.buf = append(b.buf, c)
+}
+
+func (b *writeBuf) bytes(v []byte) {
+	b.buf = append(b.buf, v...)
+}
+
+func (b *writeBuf) wrap() []byte {
+	p := b.buf[b.pos:]
+	binary.BigEndian.PutUint32(p, uint32(len(p)))
+	return b.buf
+}
+
+func (b *writeBuf) next(c byte) {
+	p := b.buf[b.pos:]
+	binary.BigEndian.PutUint32(p, uint32(len(p)))
+	b.pos = len(b.buf) + 1
+	b.buf = append(b.buf, c, 0, 0, 0, 0)
+}
diff --git a/vendor/github.com/lib/pq/certs/README b/vendor/github.com/lib/pq/certs/README
new file mode 100644
index 00000000..24ab7b25
--- /dev/null
+++ b/vendor/github.com/lib/pq/certs/README
@@ -0,0 +1,3 @@
+This directory contains certificates and private keys for testing some
+SSL-related functionality in Travis.  Do NOT use these certificates for
+anything other than testing.
diff --git a/vendor/github.com/lib/pq/certs/postgresql.crt b/vendor/github.com/lib/pq/certs/postgresql.crt
new file mode 100644
index 00000000..6e6b4284
--- /dev/null
+++ b/vendor/github.com/lib/pq/certs/postgresql.crt
@@ -0,0 +1,69 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number: 2 (0x2)
+        Signature Algorithm: sha256WithRSAEncryption
+        Issuer: C=US, ST=Nevada, L=Las Vegas, O=github.com/lib/pq, CN=pq CA
+        Validity
+            Not Before: Oct 11 15:10:11 2014 GMT
+            Not After : Oct  8 15:10:11 2024 GMT
+        Subject: C=US, ST=Nevada, L=Las Vegas, O=github.com/lib/pq, CN=pqgosslcert
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+            RSA Public Key: (1024 bit)
+                Modulus (1024 bit):
+                    00:e3:8c:06:9a:70:54:51:d1:34:34:83:39:cd:a2:
+                    59:0f:05:ed:8d:d8:0e:34:d0:92:f4:09:4d:ee:8c:
+                    78:55:49:24:f8:3c:e0:34:58:02:b2:e7:94:58:c1:
+                    e8:e5:bb:d1:af:f6:54:c1:40:b1:90:70:79:0d:35:
+                    54:9c:8f:16:e9:c2:f0:92:e6:64:49:38:c1:76:f8:
+                    47:66:c4:5b:4a:b6:a9:43:ce:c8:be:6c:4d:2b:94:
+                    97:3c:55:bc:d1:d0:6e:b7:53:ae:89:5c:4b:6b:86:
+                    40:be:c1:ae:1e:64:ce:9c:ae:87:0a:69:e5:c8:21:
+                    12:be:ae:1d:f6:45:df:16:a7
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Key Identifier: 
+                9B:25:31:63:A2:D8:06:FF:CB:E3:E9:96:FF:0D:BA:DC:12:7D:04:CF
+            X509v3 Authority Key Identifier: 
+                keyid:52:93:ED:1E:76:0A:9F:65:4F:DE:19:66:C1:D5:22:40:35:CB:A0:72
+
+            X509v3 Basic Constraints: 
+                CA:FALSE
+            X509v3 Key Usage: 
+                Digital Signature, Non Repudiation, Key Encipherment
+    Signature Algorithm: sha256WithRSAEncryption
+        3e:f5:f8:0b:4e:11:bd:00:86:1f:ce:dc:97:02:98:91:11:f5:
+        65:f6:f2:8a:b2:3e:47:92:05:69:28:c9:e9:b4:f7:cf:93:d1:
+        2d:81:5d:00:3c:23:be:da:70:ea:59:e1:2c:d3:25:49:ae:a6:
+        95:54:c1:10:df:23:e3:fe:d6:e4:76:c7:6b:73:ad:1b:34:7c:
+        e2:56:cc:c0:37:ae:c5:7a:11:20:6c:3d:05:0e:99:cd:22:6c:
+        cf:59:a1:da:28:d4:65:ba:7d:2f:2b:3d:69:6d:a6:c1:ae:57:
+        bf:56:64:13:79:f8:48:46:65:eb:81:67:28:0b:7b:de:47:10:
+        b3:80:3c:31:d1:58:94:01:51:4a:c7:c8:1a:01:a8:af:c4:cd:
+        bb:84:a5:d9:8b:b4:b9:a1:64:3e:95:d9:90:1d:d5:3f:67:cc:
+        3b:ba:f5:b4:d1:33:77:ee:c2:d2:3e:7e:c5:66:6e:b7:35:4c:
+        60:57:b0:b8:be:36:c8:f3:d3:95:8c:28:4a:c9:f7:27:a4:0d:
+        e5:96:99:eb:f5:c8:bd:f3:84:6d:ef:02:f9:8a:36:7d:6b:5f:
+        36:68:37:41:d9:74:ae:c6:78:2e:44:86:a1:ad:43:ca:fb:b5:
+        3e:ba:10:23:09:02:ac:62:d1:d0:83:c8:95:b9:e3:5e:30:ff:
+        5b:2b:38:fa
+-----BEGIN CERTIFICATE-----
+MIIDEzCCAfugAwIBAgIBAjANBgkqhkiG9w0BAQsFADBeMQswCQYDVQQGEwJVUzEP
+MA0GA1UECBMGTmV2YWRhMRIwEAYDVQQHEwlMYXMgVmVnYXMxGjAYBgNVBAoTEWdp
+dGh1Yi5jb20vbGliL3BxMQ4wDAYDVQQDEwVwcSBDQTAeFw0xNDEwMTExNTEwMTFa
+Fw0yNDEwMDgxNTEwMTFaMGQxCzAJBgNVBAYTAlVTMQ8wDQYDVQQIEwZOZXZhZGEx
+EjAQBgNVBAcTCUxhcyBWZWdhczEaMBgGA1UEChMRZ2l0aHViLmNvbS9saWIvcHEx
+FDASBgNVBAMTC3BxZ29zc2xjZXJ0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
+gQDjjAaacFRR0TQ0gznNolkPBe2N2A400JL0CU3ujHhVSST4POA0WAKy55RYwejl
+u9Gv9lTBQLGQcHkNNVScjxbpwvCS5mRJOMF2+EdmxFtKtqlDzsi+bE0rlJc8VbzR
+0G63U66JXEtrhkC+wa4eZM6crocKaeXIIRK+rh32Rd8WpwIDAQABo1owWDAdBgNV
+HQ4EFgQUmyUxY6LYBv/L4+mW/w263BJ9BM8wHwYDVR0jBBgwFoAUUpPtHnYKn2VP
+3hlmwdUiQDXLoHIwCQYDVR0TBAIwADALBgNVHQ8EBAMCBeAwDQYJKoZIhvcNAQEL
+BQADggEBAD71+AtOEb0Ahh/O3JcCmJER9WX28oqyPkeSBWkoyem098+T0S2BXQA8
+I77acOpZ4SzTJUmuppVUwRDfI+P+1uR2x2tzrRs0fOJWzMA3rsV6ESBsPQUOmc0i
+bM9Zodoo1GW6fS8rPWltpsGuV79WZBN5+EhGZeuBZygLe95HELOAPDHRWJQBUUrH
+yBoBqK/EzbuEpdmLtLmhZD6V2ZAd1T9nzDu69bTRM3fuwtI+fsVmbrc1TGBXsLi+
+Nsjz05WMKErJ9yekDeWWmev1yL3zhG3vAvmKNn1rXzZoN0HZdK7GeC5EhqGtQ8r7
+tT66ECMJAqxi0dCDyJW5414w/1srOPo=
+-----END CERTIFICATE-----
diff --git a/vendor/github.com/lib/pq/certs/postgresql.key b/vendor/github.com/lib/pq/certs/postgresql.key
new file mode 100644
index 00000000..eb8b20be
--- /dev/null
+++ b/vendor/github.com/lib/pq/certs/postgresql.key
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQDjjAaacFRR0TQ0gznNolkPBe2N2A400JL0CU3ujHhVSST4POA0
+WAKy55RYwejlu9Gv9lTBQLGQcHkNNVScjxbpwvCS5mRJOMF2+EdmxFtKtqlDzsi+
+bE0rlJc8VbzR0G63U66JXEtrhkC+wa4eZM6crocKaeXIIRK+rh32Rd8WpwIDAQAB
+AoGAM5dM6/kp9P700i8qjOgRPym96Zoh5nGfz/rIE5z/r36NBkdvIg8OVZfR96nH
+b0b9TOMR5lsPp0sI9yivTWvX6qyvLJRWy2vvx17hXK9NxXUNTAm0PYZUTvCtcPeX
+RnJpzQKNZQPkFzF0uXBc4CtPK2Vz0+FGvAelrhYAxnw1dIkCQQD+9qaW5QhXjsjb
+Nl85CmXgxPmGROcgLQCO+omfrjf9UXrituU9Dz6auym5lDGEdMFnkzfr+wpasEy9
+mf5ZZOhDAkEA5HjXfVGaCtpydOt6hDon/uZsyssCK2lQ7NSuE3vP+sUsYMzIpEoy
+t3VWXqKbo+g9KNDTP4WEliqp1aiSIylzzQJANPeqzihQnlgEdD4MdD4rwhFJwVIp
+Le8Lcais1KaN7StzOwxB/XhgSibd2TbnPpw+3bSg5n5lvUdo+e62/31OHwJAU1jS
+I+F09KikQIr28u3UUWT2IzTT4cpVv1AHAQyV3sG3YsjSGT0IK20eyP9BEBZU2WL0
+7aNjrvR5aHxKc5FXsQJABsFtyGpgI5X4xufkJZVZ+Mklz2n7iXa+XPatMAHFxAtb
+EEMt60rngwMjXAzBSC6OYuYogRRAY3UCacNC5VhLYQ==
+-----END RSA PRIVATE KEY-----
diff --git a/vendor/github.com/lib/pq/certs/root.crt b/vendor/github.com/lib/pq/certs/root.crt
new file mode 100644
index 00000000..aecf8f62
--- /dev/null
+++ b/vendor/github.com/lib/pq/certs/root.crt
@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEAzCCAuugAwIBAgIJANmheROCdW1NMA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV
+BAYTAlVTMQ8wDQYDVQQIEwZOZXZhZGExEjAQBgNVBAcTCUxhcyBWZWdhczEaMBgG
+A1UEChMRZ2l0aHViLmNvbS9saWIvcHExDjAMBgNVBAMTBXBxIENBMB4XDTE0MTAx
+MTE1MDQyOVoXDTI0MTAwODE1MDQyOVowXjELMAkGA1UEBhMCVVMxDzANBgNVBAgT
+Bk5ldmFkYTESMBAGA1UEBxMJTGFzIFZlZ2FzMRowGAYDVQQKExFnaXRodWIuY29t
+L2xpYi9wcTEOMAwGA1UEAxMFcHEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
+ggEKAoIBAQCV4PxP7ShzWBzUCThcKk3qZtOLtHmszQVtbqhvgTpm1kTRtKBdVMu0
+pLAHQ3JgJCnAYgH0iZxVGoMP16T3irdgsdC48+nNTFM2T0cCdkfDURGIhSFN47cb
+Pgy306BcDUD2q7ucW33+dlFSRuGVewocoh4BWM/vMtMvvWzdi4Ag/L/jhb+5wZxZ
+sWymsadOVSDePEMKOvlCa3EdVwVFV40TVyDb+iWBUivDAYsS2a3KajuJrO6MbZiE
+Sp2RCIkZS2zFmzWxVRi9ZhzIZhh7EVF9JAaNC3T52jhGUdlRq3YpBTMnd89iOh74
+6jWXG7wSuPj3haFzyNhmJ0ZUh+2Ynoh1AgMBAAGjgcMwgcAwHQYDVR0OBBYEFFKT
+7R52Cp9lT94ZZsHVIkA1y6ByMIGQBgNVHSMEgYgwgYWAFFKT7R52Cp9lT94ZZsHV
+IkA1y6ByoWKkYDBeMQswCQYDVQQGEwJVUzEPMA0GA1UECBMGTmV2YWRhMRIwEAYD
+VQQHEwlMYXMgVmVnYXMxGjAYBgNVBAoTEWdpdGh1Yi5jb20vbGliL3BxMQ4wDAYD
+VQQDEwVwcSBDQYIJANmheROCdW1NMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEF
+BQADggEBAAEhCLWkqJNMI8b4gkbmj5fqQ/4+oO83bZ3w2Oqf6eZ8I8BC4f2NOyE6
+tRUlq5+aU7eqC1cOAvGjO+YHN/bF/DFpwLlzvUSXt+JP/pYcUjL7v+pIvwqec9hD
+ndvM4iIbkD/H/OYQ3L+N3W+G1x7AcFIX+bGCb3PzYVQAjxreV6//wgKBosMGFbZo
+HPxT9RPMun61SViF04H5TNs0derVn1+5eiiYENeAhJzQNyZoOOUuX1X/Inx9bEPh
+C5vFBtSMgIytPgieRJVWAiMLYsfpIAStrHztRAbBs2DU01LmMgRvHdxgFEKinC/d
+UHZZQDP+6pT+zADrGhQGXe4eThaO6f0=
+-----END CERTIFICATE-----
diff --git a/vendor/github.com/lib/pq/certs/server.crt b/vendor/github.com/lib/pq/certs/server.crt
new file mode 100644
index 00000000..ddc995a6
--- /dev/null
+++ b/vendor/github.com/lib/pq/certs/server.crt
@@ -0,0 +1,81 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number: 1 (0x1)
+        Signature Algorithm: sha256WithRSAEncryption
+        Issuer: C=US, ST=Nevada, L=Las Vegas, O=github.com/lib/pq, CN=pq CA
+        Validity
+            Not Before: Oct 11 15:05:15 2014 GMT
+            Not After : Oct  8 15:05:15 2024 GMT
+        Subject: C=US, ST=Nevada, L=Las Vegas, O=github.com/lib/pq, CN=postgres
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+            RSA Public Key: (2048 bit)
+                Modulus (2048 bit):
+                    00:d7:8a:4c:85:fb:17:a5:3c:8f:e0:72:11:29:ce:
+                    3f:b0:1f:3f:7d:c6:ee:7f:a7:fc:02:2b:35:47:08:
+                    a6:3d:90:df:5c:56:14:94:00:c7:6d:d1:d2:e2:61:
+                    95:77:b8:e3:a6:66:31:f9:1f:21:7d:62:e1:27:da:
+                    94:37:61:4a:ea:63:53:a0:61:b8:9c:bb:a5:e2:e7:
+                    b7:a6:d8:0f:05:04:c7:29:e2:ea:49:2b:7f:de:15:
+                    00:a6:18:70:50:c7:0c:de:9a:f9:5a:96:b0:e1:94:
+                    06:c6:6d:4a:21:3b:b4:0f:a5:6d:92:86:34:b2:4e:
+                    d7:0e:a7:19:c0:77:0b:7b:87:c8:92:de:42:ff:86:
+                    d2:b7:9a:a4:d4:15:23:ca:ad:a5:69:21:b8:ce:7e:
+                    66:cb:85:5d:b9:ed:8b:2d:09:8d:94:e4:04:1e:72:
+                    ec:ef:d0:76:90:15:5a:a4:f7:91:4b:e9:ce:4e:9d:
+                    5d:9a:70:17:9c:d8:e9:73:83:ea:3d:61:99:a6:cd:
+                    ac:91:40:5a:88:77:e5:4e:2a:8e:3d:13:f3:f9:38:
+                    6f:81:6b:8a:95:ca:0e:07:ab:6f:da:b4:8c:d9:ff:
+                    aa:78:03:aa:c7:c2:cf:6f:64:92:d3:d8:83:d5:af:
+                    f1:23:18:a7:2e:7b:17:0b:e7:7d:f1:fa:a8:41:a3:
+                    04:57
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Key Identifier: 
+                EE:F0:B3:46:DC:C7:09:EB:0E:B6:2F:E5:FE:62:60:45:44:9F:59:CC
+            X509v3 Authority Key Identifier: 
+                keyid:52:93:ED:1E:76:0A:9F:65:4F:DE:19:66:C1:D5:22:40:35:CB:A0:72
+
+            X509v3 Basic Constraints: 
+                CA:FALSE
+            X509v3 Key Usage: 
+                Digital Signature, Non Repudiation, Key Encipherment
+    Signature Algorithm: sha256WithRSAEncryption
+        7e:5a:6e:be:bf:d2:6c:c1:d6:fa:b6:fb:3f:06:53:36:08:87:
+        9d:95:b1:39:af:9e:f6:47:38:17:39:da:25:7c:f2:ad:0c:e3:
+        ab:74:19:ca:fb:8c:a0:50:c0:1d:19:8a:9c:21:ed:0f:3a:d1:
+        96:54:2e:10:09:4f:b8:70:f7:2b:99:43:d2:c6:15:bc:3f:24:
+        7d:28:39:32:3f:8d:a4:4f:40:75:7f:3e:0d:1c:d1:69:f2:4e:
+        98:83:47:97:d2:25:ac:c9:36:86:2f:04:a6:c4:86:c7:c4:00:
+        5f:7f:b9:ad:fc:bf:e9:f5:78:d7:82:1a:51:0d:fc:ab:9e:92:
+        1d:5f:0c:18:d1:82:e0:14:c9:ce:91:89:71:ff:49:49:ff:35:
+        bf:7b:44:78:42:c1:d0:66:65:bb:28:2e:60:ca:9b:20:12:a9:
+        90:61:b1:96:ec:15:46:c9:37:f7:07:90:8a:89:45:2a:3f:37:
+        ec:dc:e3:e5:8f:c3:3a:57:80:a5:54:60:0c:e1:b2:26:99:2b:
+        40:7e:36:d1:9a:70:02:ec:63:f4:3b:72:ae:81:fb:30:20:6d:
+        cb:48:46:c6:b5:8f:39:b1:84:05:25:55:8d:f5:62:f6:1b:46:
+        2e:da:a3:4c:26:12:44:d7:56:b6:b8:a9:ca:d3:ab:71:45:7c:
+        9f:48:6d:1e
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIBATANBgkqhkiG9w0BAQsFADBeMQswCQYDVQQGEwJVUzEP
+MA0GA1UECBMGTmV2YWRhMRIwEAYDVQQHEwlMYXMgVmVnYXMxGjAYBgNVBAoTEWdp
+dGh1Yi5jb20vbGliL3BxMQ4wDAYDVQQDEwVwcSBDQTAeFw0xNDEwMTExNTA1MTVa
+Fw0yNDEwMDgxNTA1MTVaMGExCzAJBgNVBAYTAlVTMQ8wDQYDVQQIEwZOZXZhZGEx
+EjAQBgNVBAcTCUxhcyBWZWdhczEaMBgGA1UEChMRZ2l0aHViLmNvbS9saWIvcHEx
+ETAPBgNVBAMTCHBvc3RncmVzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEA14pMhfsXpTyP4HIRKc4/sB8/fcbuf6f8Ais1RwimPZDfXFYUlADHbdHS4mGV
+d7jjpmYx+R8hfWLhJ9qUN2FK6mNToGG4nLul4ue3ptgPBQTHKeLqSSt/3hUAphhw
+UMcM3pr5Wpaw4ZQGxm1KITu0D6VtkoY0sk7XDqcZwHcLe4fIkt5C/4bSt5qk1BUj
+yq2laSG4zn5my4Vdue2LLQmNlOQEHnLs79B2kBVapPeRS+nOTp1dmnAXnNjpc4Pq
+PWGZps2skUBaiHflTiqOPRPz+ThvgWuKlcoOB6tv2rSM2f+qeAOqx8LPb2SS09iD
+1a/xIxinLnsXC+d98fqoQaMEVwIDAQABo1owWDAdBgNVHQ4EFgQU7vCzRtzHCesO
+ti/l/mJgRUSfWcwwHwYDVR0jBBgwFoAUUpPtHnYKn2VP3hlmwdUiQDXLoHIwCQYD
+VR0TBAIwADALBgNVHQ8EBAMCBeAwDQYJKoZIhvcNAQELBQADggEBAH5abr6/0mzB
+1vq2+z8GUzYIh52VsTmvnvZHOBc52iV88q0M46t0Gcr7jKBQwB0Zipwh7Q860ZZU
+LhAJT7hw9yuZQ9LGFbw/JH0oOTI/jaRPQHV/Pg0c0WnyTpiDR5fSJazJNoYvBKbE
+hsfEAF9/ua38v+n1eNeCGlEN/Kuekh1fDBjRguAUyc6RiXH/SUn/Nb97RHhCwdBm
+ZbsoLmDKmyASqZBhsZbsFUbJN/cHkIqJRSo/N+zc4+WPwzpXgKVUYAzhsiaZK0B+
+NtGacALsY/Q7cq6B+zAgbctIRsa1jzmxhAUlVY31YvYbRi7ao0wmEkTXVra4qcrT
+q3FFfJ9IbR4=
+-----END CERTIFICATE-----
diff --git a/vendor/github.com/lib/pq/certs/server.key b/vendor/github.com/lib/pq/certs/server.key
new file mode 100644
index 00000000..bd7b019b
--- /dev/null
+++ b/vendor/github.com/lib/pq/certs/server.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEA14pMhfsXpTyP4HIRKc4/sB8/fcbuf6f8Ais1RwimPZDfXFYU
+lADHbdHS4mGVd7jjpmYx+R8hfWLhJ9qUN2FK6mNToGG4nLul4ue3ptgPBQTHKeLq
+SSt/3hUAphhwUMcM3pr5Wpaw4ZQGxm1KITu0D6VtkoY0sk7XDqcZwHcLe4fIkt5C
+/4bSt5qk1BUjyq2laSG4zn5my4Vdue2LLQmNlOQEHnLs79B2kBVapPeRS+nOTp1d
+mnAXnNjpc4PqPWGZps2skUBaiHflTiqOPRPz+ThvgWuKlcoOB6tv2rSM2f+qeAOq
+x8LPb2SS09iD1a/xIxinLnsXC+d98fqoQaMEVwIDAQABAoIBAF3ZoihUhJ82F4+r
+Gz4QyDpv4L1reT2sb1aiabhcU8ZK5nbWJG+tRyjSS/i2dNaEcttpdCj9HR/zhgZM
+bm0OuAgG58rVwgS80CZUruq++Qs+YVojq8/gWPTiQD4SNhV2Fmx3HkwLgUk3oxuT
+SsvdqzGE3okGVrutCIcgy126eA147VPMoej1Bb3fO6npqK0pFPhZfAc0YoqJuM+k
+obRm5pAnGUipyLCFXjA9HYPKwYZw2RtfdA3CiImHeanSdqS+ctrC9y8BV40Th7gZ
+haXdKUNdjmIxV695QQ1mkGqpKLZFqhzKioGQ2/Ly2d1iaKN9fZltTusu8unepWJ2
+tlT9qMECgYEA9uHaF1t2CqE+AJvWTihHhPIIuLxoOQXYea1qvxfcH/UMtaLKzCNm
+lQ5pqCGsPvp+10f36yttO1ZehIvlVNXuJsjt0zJmPtIolNuJY76yeussfQ9jHheB
+5uPEzCFlHzxYbBUyqgWaF6W74okRGzEGJXjYSP0yHPPdU4ep2q3bGiUCgYEA34Af
+wBSuQSK7uLxArWHvQhyuvi43ZGXls6oRGl+Ysj54s8BP6XGkq9hEJ6G4yxgyV+BR
+DUOs5X8/TLT8POuIMYvKTQthQyCk0eLv2FLdESDuuKx0kBVY3s8lK3/z5HhrdOiN
+VMNZU+xDKgKc3hN9ypkk8vcZe6EtH7Y14e0rVcsCgYBTgxi8F/M5K0wG9rAqphNz
+VFBA9XKn/2M33cKjO5X5tXIEKzpAjaUQvNxexG04rJGljzG8+mar0M6ONahw5yD1
+O7i/XWgazgpuOEkkVYiYbd8RutfDgR4vFVMn3hAP3eDnRtBplRWH9Ec3HTiNIys6
+F8PKBOQjyRZQQC7jyzW3hQKBgACe5HeuFwXLSOYsb6mLmhR+6+VPT4wR1F95W27N
+USk9jyxAnngxfpmTkiziABdgS9N+pfr5cyN4BP77ia/Jn6kzkC5Cl9SN5KdIkA3z
+vPVtN/x/ThuQU5zaymmig1ThGLtMYggYOslG4LDfLPxY5YKIhle+Y+259twdr2yf
+Mf2dAoGAaGv3tWMgnIdGRk6EQL/yb9PKHo7ShN+tKNlGaK7WwzBdKs+Fe8jkgcr7
+pz4Ne887CmxejdISzOCcdT+Zm9Bx6I/uZwWOtDvWpIgIxVX9a9URj/+D1MxTE/y4
+d6H+c89yDY62I2+drMpdjCd3EtCaTlxpTbRS+s1eAHMH7aEkcCE=
+-----END RSA PRIVATE KEY-----
diff --git a/vendor/github.com/lib/pq/conn.go b/vendor/github.com/lib/pq/conn.go
new file mode 100644
index 00000000..40a630d7
--- /dev/null
+++ b/vendor/github.com/lib/pq/conn.go
@@ -0,0 +1,1763 @@
+package pq
+
+import (
+	"bufio"
+	"crypto/md5"
+	"crypto/tls"
+	"crypto/x509"
+	"database/sql"
+	"database/sql/driver"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"os"
+	"os/user"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/lib/pq/oid"
+)
+
+// Common error types
+var (
+	ErrNotSupported              = errors.New("pq: Unsupported command")
+	ErrInFailedTransaction       = errors.New("pq: Could not complete operation in a failed transaction")
+	ErrSSLNotSupported           = errors.New("pq: SSL is not enabled on the server")
+	ErrSSLKeyHasWorldPermissions = errors.New("pq: Private key file has group or world access. Permissions should be u=rw (0600) or less.")
+	ErrCouldNotDetectUsername    = errors.New("pq: Could not detect default username. Please provide one explicitly.")
+)
+
+type drv struct{}
+
+func (d *drv) Open(name string) (driver.Conn, error) {
+	return Open(name)
+}
+
+func init() {
+	sql.Register("postgres", &drv{})
+}
+
+type parameterStatus struct {
+	// server version in the same format as server_version_num, or 0 if
+	// unavailable
+	serverVersion int
+
+	// the current location based on the TimeZone value of the session, if
+	// available
+	currentLocation *time.Location
+}
+
+type transactionStatus byte
+
+const (
+	txnStatusIdle                transactionStatus = 'I'
+	txnStatusIdleInTransaction   transactionStatus = 'T'
+	txnStatusInFailedTransaction transactionStatus = 'E'
+)
+
+func (s transactionStatus) String() string {
+	switch s {
+	case txnStatusIdle:
+		return "idle"
+	case txnStatusIdleInTransaction:
+		return "idle in transaction"
+	case txnStatusInFailedTransaction:
+		return "in a failed transaction"
+	default:
+		errorf("unknown transactionStatus %d", s)
+	}
+
+	panic("not reached")
+}
+
+type Dialer interface {
+	Dial(network, address string) (net.Conn, error)
+	DialTimeout(network, address string, timeout time.Duration) (net.Conn, error)
+}
+
+type defaultDialer struct{}
+
+func (d defaultDialer) Dial(ntw, addr string) (net.Conn, error) {
+	return net.Dial(ntw, addr)
+}
+func (d defaultDialer) DialTimeout(ntw, addr string, timeout time.Duration) (net.Conn, error) {
+	return net.DialTimeout(ntw, addr, timeout)
+}
+
+type conn struct {
+	c         net.Conn
+	buf       *bufio.Reader
+	namei     int
+	scratch   [512]byte
+	txnStatus transactionStatus
+
+	parameterStatus parameterStatus
+
+	saveMessageType   byte
+	saveMessageBuffer []byte
+
+	// If true, this connection is bad and all public-facing functions should
+	// return ErrBadConn.
+	bad bool
+
+	// If set, this connection should never use the binary format when
+	// receiving query results from prepared statements.  Only provided for
+	// debugging.
+	disablePreparedBinaryResult bool
+
+	// Whether to always send []byte parameters over as binary.  Enables single
+	// round-trip mode for non-prepared Query calls.
+	binaryParameters bool
+}
+
+// Handle driver-side settings in parsed connection string.
+func (c *conn) handleDriverSettings(o values) (err error) {
+	boolSetting := func(key string, val *bool) error {
+		if value := o.Get(key); value != "" {
+			if value == "yes" {
+				*val = true
+			} else if value == "no" {
+				*val = false
+			} else {
+				return fmt.Errorf("unrecognized value %q for %s", value, key)
+			}
+		}
+		return nil
+	}
+
+	err = boolSetting("disable_prepared_binary_result", &c.disablePreparedBinaryResult)
+	if err != nil {
+		return err
+	}
+	err = boolSetting("binary_parameters", &c.binaryParameters)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *conn) writeBuf(b byte) *writeBuf {
+	c.scratch[0] = b
+	return &writeBuf{
+		buf: c.scratch[:5],
+		pos: 1,
+	}
+}
+
+func Open(name string) (_ driver.Conn, err error) {
+	return DialOpen(defaultDialer{}, name)
+}
+
+func DialOpen(d Dialer, name string) (_ driver.Conn, err error) {
+	// Handle any panics during connection initialization.  Note that we
+	// specifically do *not* want to use errRecover(), as that would turn any
+	// connection errors into ErrBadConns, hiding the real error message from
+	// the user.
+	defer errRecoverNoErrBadConn(&err)
+
+	o := make(values)
+
+	// A number of defaults are applied here, in this order:
+	//
+	// * Very low precedence defaults applied in every situation
+	// * Environment variables
+	// * Explicitly passed connection information
+	o.Set("host", "localhost")
+	o.Set("port", "5432")
+	// N.B.: Extra float digits should be set to 3, but that breaks
+	// Postgres 8.4 and older, where the max is 2.
+	o.Set("extra_float_digits", "2")
+	for k, v := range parseEnviron(os.Environ()) {
+		o.Set(k, v)
+	}
+
+	if strings.HasPrefix(name, "postgres://") || strings.HasPrefix(name, "postgresql://") {
+		name, err = ParseURL(name)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if err := parseOpts(name, o); err != nil {
+		return nil, err
+	}
+
+	// Use the "fallback" application name if necessary
+	if fallback := o.Get("fallback_application_name"); fallback != "" {
+		if !o.Isset("application_name") {
+			o.Set("application_name", fallback)
+		}
+	}
+
+	// We can't work with any client_encoding other than UTF-8 currently.
+	// However, we have historically allowed the user to set it to UTF-8
+	// explicitly, and there's no reason to break such programs, so allow that.
+	// Note that the "options" setting could also set client_encoding, but
+	// parsing its value is not worth it.  Instead, we always explicitly send
+	// client_encoding as a separate run-time parameter, which should override
+	// anything set in options.
+	if enc := o.Get("client_encoding"); enc != "" && !isUTF8(enc) {
+		return nil, errors.New("client_encoding must be absent or 'UTF8'")
+	}
+	o.Set("client_encoding", "UTF8")
+	// DateStyle needs a similar treatment.
+	if datestyle := o.Get("datestyle"); datestyle != "" {
+		if datestyle != "ISO, MDY" {
+			panic(fmt.Sprintf("setting datestyle must be absent or %v; got %v",
+				"ISO, MDY", datestyle))
+		}
+	} else {
+		o.Set("datestyle", "ISO, MDY")
+	}
+
+	// If a user is not provided by any other means, the last
+	// resort is to use the current operating system provided user
+	// name.
+	if o.Get("user") == "" {
+		u, err := userCurrent()
+		if err != nil {
+			return nil, err
+		} else {
+			o.Set("user", u)
+		}
+	}
+
+	cn := &conn{}
+	err = cn.handleDriverSettings(o)
+	if err != nil {
+		return nil, err
+	}
+
+	cn.c, err = dial(d, o)
+	if err != nil {
+		return nil, err
+	}
+	cn.ssl(o)
+	cn.buf = bufio.NewReader(cn.c)
+	cn.startup(o)
+
+	// reset the deadline, in case one was set (see dial)
+	if timeout := o.Get("connect_timeout"); timeout != "" && timeout != "0" {
+		err = cn.c.SetDeadline(time.Time{})
+	}
+	return cn, err
+}
+
+func dial(d Dialer, o values) (net.Conn, error) {
+	ntw, addr := network(o)
+	// SSL is not necessary or supported over UNIX domain sockets
+	if ntw == "unix" {
+		o["sslmode"] = "disable"
+	}
+
+	// Zero or not specified means wait indefinitely.
+	if timeout := o.Get("connect_timeout"); timeout != "" && timeout != "0" {
+		seconds, err := strconv.ParseInt(timeout, 10, 0)
+		if err != nil {
+			return nil, fmt.Errorf("invalid value for parameter connect_timeout: %s", err)
+		}
+		duration := time.Duration(seconds) * time.Second
+		// connect_timeout should apply to the entire connection establishment
+		// procedure, so we both use a timeout for the TCP connection
+		// establishment and set a deadline for doing the initial handshake.
+		// The deadline is then reset after startup() is done.
+		deadline := time.Now().Add(duration)
+		conn, err := d.DialTimeout(ntw, addr, duration)
+		if err != nil {
+			return nil, err
+		}
+		err = conn.SetDeadline(deadline)
+		return conn, err
+	}
+	return d.Dial(ntw, addr)
+}
+
+func network(o values) (string, string) {
+	host := o.Get("host")
+
+	if strings.HasPrefix(host, "/") {
+		sockPath := path.Join(host, ".s.PGSQL."+o.Get("port"))
+		return "unix", sockPath
+	}
+
+	return "tcp", host + ":" + o.Get("port")
+}
+
+type values map[string]string
+
+func (vs values) Set(k, v string) {
+	vs[k] = v
+}
+
+func (vs values) Get(k string) (v string) {
+	return vs[k]
+}
+
+func (vs values) Isset(k string) bool {
+	_, ok := vs[k]
+	return ok
+}
+
+// scanner implements a tokenizer for libpq-style option strings.
+type scanner struct {
+	s []rune
+	i int
+}
+
+// newScanner returns a new scanner initialized with the option string s.
+func newScanner(s string) *scanner {
+	return &scanner{[]rune(s), 0}
+}
+
+// Next returns the next rune.
+// It returns 0, false if the end of the text has been reached.
+func (s *scanner) Next() (rune, bool) {
+	if s.i >= len(s.s) {
+		return 0, false
+	}
+	r := s.s[s.i]
+	s.i++
+	return r, true
+}
+
+// SkipSpaces returns the next non-whitespace rune.
+// It returns 0, false if the end of the text has been reached.
+func (s *scanner) SkipSpaces() (rune, bool) {
+	r, ok := s.Next()
+	for unicode.IsSpace(r) && ok {
+		r, ok = s.Next()
+	}
+	return r, ok
+}
+
+// parseOpts parses the options from name and adds them to the values.
+//
+// The parsing code is based on conninfo_parse from libpq's fe-connect.c
+func parseOpts(name string, o values) error {
+	s := newScanner(name)
+
+	for {
+		var (
+			keyRunes, valRunes []rune
+			r                  rune
+			ok                 bool
+		)
+
+		if r, ok = s.SkipSpaces(); !ok {
+			break
+		}
+
+		// Scan the key
+		for !unicode.IsSpace(r) && r != '=' {
+			keyRunes = append(keyRunes, r)
+			if r, ok = s.Next(); !ok {
+				break
+			}
+		}
+
+		// Skip any whitespace if we're not at the = yet
+		if r != '=' {
+			r, ok = s.SkipSpaces()
+		}
+
+		// The current character should be =
+		if r != '=' || !ok {
+			return fmt.Errorf(`missing "=" after %q in connection info string"`, string(keyRunes))
+		}
+
+		// Skip any whitespace after the =
+		if r, ok = s.SkipSpaces(); !ok {
+			// If we reach the end here, the last value is just an empty string as per libpq.
+			o.Set(string(keyRunes), "")
+			break
+		}
+
+		if r != '\'' {
+			for !unicode.IsSpace(r) {
+				if r == '\\' {
+					if r, ok = s.Next(); !ok {
+						return fmt.Errorf(`missing character after backslash`)
+					}
+				}
+				valRunes = append(valRunes, r)
+
+				if r, ok = s.Next(); !ok {
+					break
+				}
+			}
+		} else {
+		quote:
+			for {
+				if r, ok = s.Next(); !ok {
+					return fmt.Errorf(`unterminated quoted string literal in connection string`)
+				}
+				switch r {
+				case '\'':
+					break quote
+				case '\\':
+					r, _ = s.Next()
+					fallthrough
+				default:
+					valRunes = append(valRunes, r)
+				}
+			}
+		}
+
+		o.Set(string(keyRunes), string(valRunes))
+	}
+
+	return nil
+}
+
+func (cn *conn) isInTransaction() bool {
+	return cn.txnStatus == txnStatusIdleInTransaction ||
+		cn.txnStatus == txnStatusInFailedTransaction
+}
+
+func (cn *conn) checkIsInTransaction(intxn bool) {
+	if cn.isInTransaction() != intxn {
+		cn.bad = true
+		errorf("unexpected transaction status %v", cn.txnStatus)
+	}
+}
+
+func (cn *conn) Begin() (_ driver.Tx, err error) {
+	if cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	cn.checkIsInTransaction(false)
+	_, commandTag, err := cn.simpleExec("BEGIN")
+	if err != nil {
+		return nil, err
+	}
+	if commandTag != "BEGIN" {
+		cn.bad = true
+		return nil, fmt.Errorf("unexpected command tag %s", commandTag)
+	}
+	if cn.txnStatus != txnStatusIdleInTransaction {
+		cn.bad = true
+		return nil, fmt.Errorf("unexpected transaction status %v", cn.txnStatus)
+	}
+	return cn, nil
+}
+
+func (cn *conn) Commit() (err error) {
+	if cn.bad {
+		return driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	cn.checkIsInTransaction(true)
+	// We don't want the client to think that everything is okay if it tries
+	// to commit a failed transaction.  However, no matter what we return,
+	// database/sql will release this connection back into the free connection
+	// pool so we have to abort the current transaction here.  Note that you
+	// would get the same behaviour if you issued a COMMIT in a failed
+	// transaction, so it's also the least surprising thing to do here.
+	if cn.txnStatus == txnStatusInFailedTransaction {
+		if err := cn.Rollback(); err != nil {
+			return err
+		}
+		return ErrInFailedTransaction
+	}
+
+	_, commandTag, err := cn.simpleExec("COMMIT")
+	if err != nil {
+		if cn.isInTransaction() {
+			cn.bad = true
+		}
+		return err
+	}
+	if commandTag != "COMMIT" {
+		cn.bad = true
+		return fmt.Errorf("unexpected command tag %s", commandTag)
+	}
+	cn.checkIsInTransaction(false)
+	return nil
+}
+
+func (cn *conn) Rollback() (err error) {
+	if cn.bad {
+		return driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	cn.checkIsInTransaction(true)
+	_, commandTag, err := cn.simpleExec("ROLLBACK")
+	if err != nil {
+		if cn.isInTransaction() {
+			cn.bad = true
+		}
+		return err
+	}
+	if commandTag != "ROLLBACK" {
+		return fmt.Errorf("unexpected command tag %s", commandTag)
+	}
+	cn.checkIsInTransaction(false)
+	return nil
+}
+
+func (cn *conn) gname() string {
+	cn.namei++
+	return strconv.FormatInt(int64(cn.namei), 10)
+}
+
+func (cn *conn) simpleExec(q string) (res driver.Result, commandTag string, err error) {
+	b := cn.writeBuf('Q')
+	b.string(q)
+	cn.send(b)
+
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 'C':
+			res, commandTag = cn.parseComplete(r.string())
+		case 'Z':
+			cn.processReadyForQuery(r)
+			// done
+			return
+		case 'E':
+			err = parseError(r)
+		case 'T', 'D', 'I':
+			// ignore any results
+		default:
+			cn.bad = true
+			errorf("unknown response for simple query: %q", t)
+		}
+	}
+}
+
+func (cn *conn) simpleQuery(q string) (res *rows, err error) {
+	defer cn.errRecover(&err)
+
+	st := &stmt{cn: cn, name: ""}
+
+	b := cn.writeBuf('Q')
+	b.string(q)
+	cn.send(b)
+
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 'C', 'I':
+			// We allow queries which don't return any results through Query as
+			// well as Exec.  We still have to give database/sql a rows object
+			// the user can close, though, to avoid connections from being
+			// leaked.  A "rows" with done=true works fine for that purpose.
+			if err != nil {
+				cn.bad = true
+				errorf("unexpected message %q in simple query execution", t)
+			}
+			res = &rows{
+				cn:       cn,
+				colNames: st.colNames,
+				colTyps:  st.colTyps,
+				colFmts:  st.colFmts,
+				done:     true,
+			}
+		case 'Z':
+			cn.processReadyForQuery(r)
+			// done
+			return
+		case 'E':
+			res = nil
+			err = parseError(r)
+		case 'D':
+			if res == nil {
+				cn.bad = true
+				errorf("unexpected DataRow in simple query execution")
+			}
+			// the query didn't fail; kick off to Next
+			cn.saveMessage(t, r)
+			return
+		case 'T':
+			// res might be non-nil here if we received a previous
+			// CommandComplete, but that's fine; just overwrite it
+			res = &rows{cn: cn}
+			res.colNames, res.colFmts, res.colTyps = parsePortalRowDescribe(r)
+
+			// To work around a bug in QueryRow in Go 1.2 and earlier, wait
+			// until the first DataRow has been received.
+		default:
+			cn.bad = true
+			errorf("unknown response for simple query: %q", t)
+		}
+	}
+}
+
+// Decides which column formats to use for a prepared statement.  The input is
+// an array of type oids, one element per result column.
+func decideColumnFormats(colTyps []oid.Oid, forceText bool) (colFmts []format, colFmtData []byte) {
+	if len(colTyps) == 0 {
+		return nil, colFmtDataAllText
+	}
+
+	colFmts = make([]format, len(colTyps))
+	if forceText {
+		return colFmts, colFmtDataAllText
+	}
+
+	allBinary := true
+	allText := true
+	for i, o := range colTyps {
+		switch o {
+		// This is the list of types to use binary mode for when receiving them
+		// through a prepared statement.  If a type appears in this list, it
+		// must also be implemented in binaryDecode in encode.go.
+		case oid.T_bytea:
+			fallthrough
+		case oid.T_int8:
+			fallthrough
+		case oid.T_int4:
+			fallthrough
+		case oid.T_int2:
+			colFmts[i] = formatBinary
+			allText = false
+
+		default:
+			allBinary = false
+		}
+	}
+
+	if allBinary {
+		return colFmts, colFmtDataAllBinary
+	} else if allText {
+		return colFmts, colFmtDataAllText
+	} else {
+		colFmtData = make([]byte, 2+len(colFmts)*2)
+		binary.BigEndian.PutUint16(colFmtData, uint16(len(colFmts)))
+		for i, v := range colFmts {
+			binary.BigEndian.PutUint16(colFmtData[2+i*2:], uint16(v))
+		}
+		return colFmts, colFmtData
+	}
+}
+
+func (cn *conn) prepareTo(q, stmtName string) *stmt {
+	st := &stmt{cn: cn, name: stmtName}
+
+	b := cn.writeBuf('P')
+	b.string(st.name)
+	b.string(q)
+	b.int16(0)
+
+	b.next('D')
+	b.byte('S')
+	b.string(st.name)
+
+	b.next('S')
+	cn.send(b)
+
+	cn.readParseResponse()
+	st.paramTyps, st.colNames, st.colTyps = cn.readStatementDescribeResponse()
+	st.colFmts, st.colFmtData = decideColumnFormats(st.colTyps, cn.disablePreparedBinaryResult)
+	cn.readReadyForQuery()
+	return st
+}
+
+func (cn *conn) Prepare(q string) (_ driver.Stmt, err error) {
+	if cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	if len(q) >= 4 && strings.EqualFold(q[:4], "COPY") {
+		return cn.prepareCopyIn(q)
+	}
+	return cn.prepareTo(q, cn.gname()), nil
+}
+
+func (cn *conn) Close() (err error) {
+	if cn.bad {
+		return driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	// Don't go through send(); ListenerConn relies on us not scribbling on the
+	// scratch buffer of this connection.
+	err = cn.sendSimpleMessage('X')
+	if err != nil {
+		return err
+	}
+
+	return cn.c.Close()
+}
+
+// Implement the "Queryer" interface
+func (cn *conn) Query(query string, args []driver.Value) (_ driver.Rows, err error) {
+	if cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	// Check to see if we can use the "simpleQuery" interface, which is
+	// *much* faster than going through prepare/exec
+	if len(args) == 0 {
+		return cn.simpleQuery(query)
+	}
+
+	if cn.binaryParameters {
+		cn.sendBinaryModeQuery(query, args)
+
+		cn.readParseResponse()
+		cn.readBindResponse()
+		rows := &rows{cn: cn}
+		rows.colNames, rows.colFmts, rows.colTyps = cn.readPortalDescribeResponse()
+		cn.postExecuteWorkaround()
+		return rows, nil
+	} else {
+		st := cn.prepareTo(query, "")
+		st.exec(args)
+		return &rows{
+			cn:       cn,
+			colNames: st.colNames,
+			colTyps:  st.colTyps,
+			colFmts:  st.colFmts,
+		}, nil
+	}
+}
+
+// Implement the optional "Execer" interface for one-shot queries
+func (cn *conn) Exec(query string, args []driver.Value) (res driver.Result, err error) {
+	if cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer cn.errRecover(&err)
+
+	// Check to see if we can use the "simpleExec" interface, which is
+	// *much* faster than going through prepare/exec
+	if len(args) == 0 {
+		// ignore commandTag, our caller doesn't care
+		r, _, err := cn.simpleExec(query)
+		return r, err
+	}
+
+	if cn.binaryParameters {
+		cn.sendBinaryModeQuery(query, args)
+
+		cn.readParseResponse()
+		cn.readBindResponse()
+		cn.readPortalDescribeResponse()
+		cn.postExecuteWorkaround()
+		res, _, err = cn.readExecuteResponse("Execute")
+		return res, err
+	} else {
+		// Use the unnamed statement to defer planning until bind
+		// time, or else value-based selectivity estimates cannot be
+		// used.
+		st := cn.prepareTo(query, "")
+		r, err := st.Exec(args)
+		if err != nil {
+			panic(err)
+		}
+		return r, err
+	}
+}
+
+func (cn *conn) send(m *writeBuf) {
+	_, err := cn.c.Write(m.wrap())
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (cn *conn) sendStartupPacket(m *writeBuf) {
+	// sanity check
+	if m.buf[0] != 0 {
+		panic("oops")
+	}
+
+	_, err := cn.c.Write((m.wrap())[1:])
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Send a message of type typ to the server on the other end of cn.  The
+// message should have no payload.  This method does not use the scratch
+// buffer.
+func (cn *conn) sendSimpleMessage(typ byte) (err error) {
+	_, err = cn.c.Write([]byte{typ, '\x00', '\x00', '\x00', '\x04'})
+	return err
+}
+
+// saveMessage memorizes a message and its buffer in the conn struct.
+// recvMessage will then return these values on the next call to it.  This
+// method is useful in cases where you have to see what the next message is
+// going to be (e.g. to see whether it's an error or not) but you can't handle
+// the message yourself.
+func (cn *conn) saveMessage(typ byte, buf *readBuf) {
+	if cn.saveMessageType != 0 {
+		cn.bad = true
+		errorf("unexpected saveMessageType %d", cn.saveMessageType)
+	}
+	cn.saveMessageType = typ
+	cn.saveMessageBuffer = *buf
+}
+
+// recvMessage receives any message from the backend, or returns an error if
+// a problem occurred while reading the message.
+func (cn *conn) recvMessage(r *readBuf) (byte, error) {
+	// workaround for a QueryRow bug, see exec
+	if cn.saveMessageType != 0 {
+		t := cn.saveMessageType
+		*r = cn.saveMessageBuffer
+		cn.saveMessageType = 0
+		cn.saveMessageBuffer = nil
+		return t, nil
+	}
+
+	x := cn.scratch[:5]
+	_, err := io.ReadFull(cn.buf, x)
+	if err != nil {
+		return 0, err
+	}
+
+	// read the type and length of the message that follows
+	t := x[0]
+	n := int(binary.BigEndian.Uint32(x[1:])) - 4
+	var y []byte
+	if n <= len(cn.scratch) {
+		y = cn.scratch[:n]
+	} else {
+		y = make([]byte, n)
+	}
+	_, err = io.ReadFull(cn.buf, y)
+	if err != nil {
+		return 0, err
+	}
+	*r = y
+	return t, nil
+}
+
+// recv receives a message from the backend, but if an error happened while
+// reading the message or the received message was an ErrorResponse, it panics.
+// NoticeResponses are ignored.  This function should generally be used only
+// during the startup sequence.
+func (cn *conn) recv() (t byte, r *readBuf) {
+	for {
+		var err error
+		r = &readBuf{}
+		t, err = cn.recvMessage(r)
+		if err != nil {
+			panic(err)
+		}
+
+		switch t {
+		case 'E':
+			panic(parseError(r))
+		case 'N':
+			// ignore
+		default:
+			return
+		}
+	}
+}
+
+// recv1Buf is exactly equivalent to recv1, except it uses a buffer supplied by
+// the caller to avoid an allocation.
+func (cn *conn) recv1Buf(r *readBuf) byte {
+	for {
+		t, err := cn.recvMessage(r)
+		if err != nil {
+			panic(err)
+		}
+
+		switch t {
+		case 'A', 'N':
+			// ignore
+		case 'S':
+			cn.processParameterStatus(r)
+		default:
+			return t
+		}
+	}
+}
+
+// recv1 receives a message from the backend, panicking if an error occurs
+// while attempting to read it.  All asynchronous messages are ignored, with
+// the exception of ErrorResponse.
+func (cn *conn) recv1() (t byte, r *readBuf) {
+	r = &readBuf{}
+	t = cn.recv1Buf(r)
+	return t, r
+}
+
+func (cn *conn) ssl(o values) {
+	verifyCaOnly := false
+	tlsConf := tls.Config{}
+	switch mode := o.Get("sslmode"); mode {
+	case "require", "":
+		tlsConf.InsecureSkipVerify = true
+	case "verify-ca":
+		// We must skip TLS's own verification since it requires full
+		// verification since Go 1.3.
+		tlsConf.InsecureSkipVerify = true
+		verifyCaOnly = true
+	case "verify-full":
+		tlsConf.ServerName = o.Get("host")
+	case "disable":
+		return
+	default:
+		errorf(`unsupported sslmode %q; only "require" (default), "verify-full", and "disable" supported`, mode)
+	}
+
+	cn.setupSSLClientCertificates(&tlsConf, o)
+	cn.setupSSLCA(&tlsConf, o)
+
+	w := cn.writeBuf(0)
+	w.int32(80877103)
+	cn.sendStartupPacket(w)
+
+	b := cn.scratch[:1]
+	_, err := io.ReadFull(cn.c, b)
+	if err != nil {
+		panic(err)
+	}
+
+	if b[0] != 'S' {
+		panic(ErrSSLNotSupported)
+	}
+
+	client := tls.Client(cn.c, &tlsConf)
+	if verifyCaOnly {
+		cn.verifyCA(client, &tlsConf)
+	}
+	cn.c = client
+}
+
+// verifyCA carries out a TLS handshake to the server and verifies the
+// presented certificate against the effective CA, i.e. the one specified in
+// sslrootcert or the system CA if sslrootcert was not specified.
+func (cn *conn) verifyCA(client *tls.Conn, tlsConf *tls.Config) {
+	err := client.Handshake()
+	if err != nil {
+		panic(err)
+	}
+	certs := client.ConnectionState().PeerCertificates
+	opts := x509.VerifyOptions{
+		DNSName:       client.ConnectionState().ServerName,
+		Intermediates: x509.NewCertPool(),
+		Roots:         tlsConf.RootCAs,
+	}
+	for i, cert := range certs {
+		if i == 0 {
+			continue
+		}
+		opts.Intermediates.AddCert(cert)
+	}
+	_, err = certs[0].Verify(opts)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// This function sets up SSL client certificates based on either the "sslkey"
+// and "sslcert" settings (possibly set via the environment variables PGSSLKEY
+// and PGSSLCERT, respectively), or if they aren't set, from the .postgresql
+// directory in the user's home directory.  If the file paths are set
+// explicitly, the files must exist.  The key file must also not be
+// world-readable, or this function will panic with
+// ErrSSLKeyHasWorldPermissions.
+func (cn *conn) setupSSLClientCertificates(tlsConf *tls.Config, o values) {
+	var missingOk bool
+
+	sslkey := o.Get("sslkey")
+	sslcert := o.Get("sslcert")
+	if sslkey != "" && sslcert != "" {
+		// If the user has set an sslkey and sslcert, they *must* exist.
+		missingOk = false
+	} else {
+		// Automatically load certificates from ~/.postgresql.
+		user, err := user.Current()
+		if err != nil {
+			// user.Current() might fail when cross-compiling.  We have to
+			// ignore the error and continue without client certificates, since
+			// we wouldn't know where to load them from.
+			return
+		}
+
+		sslkey = filepath.Join(user.HomeDir, ".postgresql", "postgresql.key")
+		sslcert = filepath.Join(user.HomeDir, ".postgresql", "postgresql.crt")
+		missingOk = true
+	}
+
+	// Check that both files exist, and report the error or stop, depending on
+	// which behaviour we want.  Note that we don't do any more extensive
+	// checks than this (such as checking that the paths aren't directories);
+	// LoadX509KeyPair() will take care of the rest.
+	keyfinfo, err := os.Stat(sslkey)
+	if err != nil && missingOk {
+		return
+	} else if err != nil {
+		panic(err)
+	}
+	_, err = os.Stat(sslcert)
+	if err != nil && missingOk {
+		return
+	} else if err != nil {
+		panic(err)
+	}
+
+	// If we got this far, the key file must also have the correct permissions
+	kmode := keyfinfo.Mode()
+	if kmode != kmode&0600 {
+		panic(ErrSSLKeyHasWorldPermissions)
+	}
+
+	cert, err := tls.LoadX509KeyPair(sslcert, sslkey)
+	if err != nil {
+		panic(err)
+	}
+	tlsConf.Certificates = []tls.Certificate{cert}
+}
+
+// Sets up RootCAs in the TLS configuration if sslrootcert is set.
+func (cn *conn) setupSSLCA(tlsConf *tls.Config, o values) {
+	if sslrootcert := o.Get("sslrootcert"); sslrootcert != "" {
+		tlsConf.RootCAs = x509.NewCertPool()
+
+		cert, err := ioutil.ReadFile(sslrootcert)
+		if err != nil {
+			panic(err)
+		}
+
+		ok := tlsConf.RootCAs.AppendCertsFromPEM(cert)
+		if !ok {
+			errorf("couldn't parse pem in sslrootcert")
+		}
+	}
+}
+
+// isDriverSetting returns true iff a setting is purely for configuring the
+// driver's options and should not be sent to the server in the connection
+// startup packet.
+func isDriverSetting(key string) bool {
+	switch key {
+	case "host", "port":
+		return true
+	case "password":
+		return true
+	case "sslmode", "sslcert", "sslkey", "sslrootcert":
+		return true
+	case "fallback_application_name":
+		return true
+	case "connect_timeout":
+		return true
+	case "disable_prepared_binary_result":
+		return true
+	case "binary_parameters":
+		return true
+
+	default:
+		return false
+	}
+}
+
+func (cn *conn) startup(o values) {
+	w := cn.writeBuf(0)
+	w.int32(196608)
+	// Send the backend the name of the database we want to connect to, and the
+	// user we want to connect as.  Additionally, we send over any run-time
+	// parameters potentially included in the connection string.  If the server
+	// doesn't recognize any of them, it will reply with an error.
+	for k, v := range o {
+		if isDriverSetting(k) {
+			// skip options which can't be run-time parameters
+			continue
+		}
+		// The protocol requires us to supply the database name as "database"
+		// instead of "dbname".
+		if k == "dbname" {
+			k = "database"
+		}
+		w.string(k)
+		w.string(v)
+	}
+	w.string("")
+	cn.sendStartupPacket(w)
+
+	for {
+		t, r := cn.recv()
+		switch t {
+		case 'K':
+		case 'S':
+			cn.processParameterStatus(r)
+		case 'R':
+			cn.auth(r, o)
+		case 'Z':
+			cn.processReadyForQuery(r)
+			return
+		default:
+			errorf("unknown response for startup: %q", t)
+		}
+	}
+}
+
+func (cn *conn) auth(r *readBuf, o values) {
+	switch code := r.int32(); code {
+	case 0:
+		// OK
+	case 3:
+		w := cn.writeBuf('p')
+		w.string(o.Get("password"))
+		cn.send(w)
+
+		t, r := cn.recv()
+		if t != 'R' {
+			errorf("unexpected password response: %q", t)
+		}
+
+		if r.int32() != 0 {
+			errorf("unexpected authentication response: %q", t)
+		}
+	case 5:
+		s := string(r.next(4))
+		w := cn.writeBuf('p')
+		w.string("md5" + md5s(md5s(o.Get("password")+o.Get("user"))+s))
+		cn.send(w)
+
+		t, r := cn.recv()
+		if t != 'R' {
+			errorf("unexpected password response: %q", t)
+		}
+
+		if r.int32() != 0 {
+			errorf("unexpected authentication response: %q", t)
+		}
+	default:
+		errorf("unknown authentication response: %d", code)
+	}
+}
+
+type format int
+
+const formatText format = 0
+const formatBinary format = 1
+
+// One result-column format code with the value 1 (i.e. all binary).
+var colFmtDataAllBinary []byte = []byte{0, 1, 0, 1}
+
+// No result-column format codes (i.e. all text).
+var colFmtDataAllText []byte = []byte{0, 0}
+
+type stmt struct {
+	cn         *conn
+	name       string
+	colNames   []string
+	colFmts    []format
+	colFmtData []byte
+	colTyps    []oid.Oid
+	paramTyps  []oid.Oid
+	closed     bool
+}
+
+func (st *stmt) Close() (err error) {
+	if st.closed {
+		return nil
+	}
+	if st.cn.bad {
+		return driver.ErrBadConn
+	}
+	defer st.cn.errRecover(&err)
+
+	w := st.cn.writeBuf('C')
+	w.byte('S')
+	w.string(st.name)
+	st.cn.send(w)
+
+	st.cn.send(st.cn.writeBuf('S'))
+
+	t, _ := st.cn.recv1()
+	if t != '3' {
+		st.cn.bad = true
+		errorf("unexpected close response: %q", t)
+	}
+	st.closed = true
+
+	t, r := st.cn.recv1()
+	if t != 'Z' {
+		st.cn.bad = true
+		errorf("expected ready for query, but got: %q", t)
+	}
+	st.cn.processReadyForQuery(r)
+
+	return nil
+}
+
+func (st *stmt) Query(v []driver.Value) (r driver.Rows, err error) {
+	if st.cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer st.cn.errRecover(&err)
+
+	st.exec(v)
+	return &rows{
+		cn:       st.cn,
+		colNames: st.colNames,
+		colTyps:  st.colTyps,
+		colFmts:  st.colFmts,
+	}, nil
+}
+
+func (st *stmt) Exec(v []driver.Value) (res driver.Result, err error) {
+	if st.cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer st.cn.errRecover(&err)
+
+	st.exec(v)
+	res, _, err = st.cn.readExecuteResponse("simple query")
+	return res, err
+}
+
+func (st *stmt) exec(v []driver.Value) {
+	if len(v) >= 65536 {
+		errorf("got %d parameters but PostgreSQL only supports 65535 parameters", len(v))
+	}
+	if len(v) != len(st.paramTyps) {
+		errorf("got %d parameters but the statement requires %d", len(v), len(st.paramTyps))
+	}
+
+	cn := st.cn
+	w := cn.writeBuf('B')
+	w.byte(0) // unnamed portal
+	w.string(st.name)
+
+	if cn.binaryParameters {
+		cn.sendBinaryParameters(w, v)
+	} else {
+		w.int16(0)
+		w.int16(len(v))
+		for i, x := range v {
+			if x == nil {
+				w.int32(-1)
+			} else {
+				b := encode(&cn.parameterStatus, x, st.paramTyps[i])
+				w.int32(len(b))
+				w.bytes(b)
+			}
+		}
+	}
+	w.bytes(st.colFmtData)
+
+	w.next('E')
+	w.byte(0)
+	w.int32(0)
+
+	w.next('S')
+	cn.send(w)
+
+	cn.readBindResponse()
+	cn.postExecuteWorkaround()
+
+}
+
+func (st *stmt) NumInput() int {
+	return len(st.paramTyps)
+}
+
+// parseComplete parses the "command tag" from a CommandComplete message, and
+// returns the number of rows affected (if applicable) and a string
+// identifying only the command that was executed, e.g. "ALTER TABLE".  If the
+// command tag could not be parsed, parseComplete panics.
+func (cn *conn) parseComplete(commandTag string) (driver.Result, string) {
+	commandsWithAffectedRows := []string{
+		"SELECT ",
+		// INSERT is handled below
+		"UPDATE ",
+		"DELETE ",
+		"FETCH ",
+		"MOVE ",
+		"COPY ",
+	}
+
+	var affectedRows *string
+	for _, tag := range commandsWithAffectedRows {
+		if strings.HasPrefix(commandTag, tag) {
+			t := commandTag[len(tag):]
+			affectedRows = &t
+			commandTag = tag[:len(tag)-1]
+			break
+		}
+	}
+	// INSERT also includes the oid of the inserted row in its command tag.
+	// Oids in user tables are deprecated, and the oid is only returned when
+	// exactly one row is inserted, so it's unlikely to be of value to any
+	// real-world application and we can ignore it.
+	if affectedRows == nil && strings.HasPrefix(commandTag, "INSERT ") {
+		parts := strings.Split(commandTag, " ")
+		if len(parts) != 3 {
+			cn.bad = true
+			errorf("unexpected INSERT command tag %s", commandTag)
+		}
+		affectedRows = &parts[len(parts)-1]
+		commandTag = "INSERT"
+	}
+	// There should be no affected rows attached to the tag, just return it
+	if affectedRows == nil {
+		return driver.RowsAffected(0), commandTag
+	}
+	n, err := strconv.ParseInt(*affectedRows, 10, 64)
+	if err != nil {
+		cn.bad = true
+		errorf("could not parse commandTag: %s", err)
+	}
+	return driver.RowsAffected(n), commandTag
+}
+
+type rows struct {
+	cn       *conn
+	colNames []string
+	colTyps  []oid.Oid
+	colFmts  []format
+	done     bool
+	rb       readBuf
+}
+
+func (rs *rows) Close() error {
+	// no need to look at cn.bad as Next() will
+	for {
+		err := rs.Next(nil)
+		switch err {
+		case nil:
+		case io.EOF:
+			return nil
+		default:
+			return err
+		}
+	}
+}
+
+func (rs *rows) Columns() []string {
+	return rs.colNames
+}
+
+func (rs *rows) Next(dest []driver.Value) (err error) {
+	if rs.done {
+		return io.EOF
+	}
+
+	conn := rs.cn
+	if conn.bad {
+		return driver.ErrBadConn
+	}
+	defer conn.errRecover(&err)
+
+	for {
+		t := conn.recv1Buf(&rs.rb)
+		switch t {
+		case 'E':
+			err = parseError(&rs.rb)
+		case 'C', 'I':
+			continue
+		case 'Z':
+			conn.processReadyForQuery(&rs.rb)
+			rs.done = true
+			if err != nil {
+				return err
+			}
+			return io.EOF
+		case 'D':
+			n := rs.rb.int16()
+			if n < len(dest) {
+				dest = dest[:n]
+			}
+			for i := range dest {
+				l := rs.rb.int32()
+				if l == -1 {
+					dest[i] = nil
+					continue
+				}
+				dest[i] = decode(&conn.parameterStatus, rs.rb.next(l), rs.colTyps[i], rs.colFmts[i])
+			}
+			return
+		default:
+			errorf("unexpected message after execute: %q", t)
+		}
+	}
+}
+
+// QuoteIdentifier quotes an "identifier" (e.g. a table or a column name) to be
+// used as part of an SQL statement.  For example:
+//
+//    tblname := "my_table"
+//    data := "my_data"
+//    err = db.Exec(fmt.Sprintf("INSERT INTO %s VALUES ($1)", pq.QuoteIdentifier(tblname)), data)
+//
+// Any double quotes in name will be escaped.  The quoted identifier will be
+// case sensitive when used in a query.  If the input string contains a zero
+// byte, the result will be truncated immediately before it.
+func QuoteIdentifier(name string) string {
+	end := strings.IndexRune(name, 0)
+	if end > -1 {
+		name = name[:end]
+	}
+	return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
+}
+
+func md5s(s string) string {
+	h := md5.New()
+	h.Write([]byte(s))
+	return fmt.Sprintf("%x", h.Sum(nil))
+}
+
+func (cn *conn) sendBinaryParameters(b *writeBuf, args []driver.Value) {
+	// Do one pass over the parameters to see if we're going to send any of
+	// them over in binary.  If we are, create a paramFormats array at the
+	// same time.
+	var paramFormats []int
+	for i, x := range args {
+		_, ok := x.([]byte)
+		if ok {
+			if paramFormats == nil {
+				paramFormats = make([]int, len(args))
+			}
+			paramFormats[i] = 1
+		}
+	}
+	if paramFormats == nil {
+		b.int16(0)
+	} else {
+		b.int16(len(paramFormats))
+		for _, x := range paramFormats {
+			b.int16(x)
+		}
+	}
+
+	b.int16(len(args))
+	for _, x := range args {
+		if x == nil {
+			b.int32(-1)
+		} else {
+			datum := binaryEncode(&cn.parameterStatus, x)
+			b.int32(len(datum))
+			b.bytes(datum)
+		}
+	}
+}
+
+func (cn *conn) sendBinaryModeQuery(query string, args []driver.Value) {
+	if len(args) >= 65536 {
+		errorf("got %d parameters but PostgreSQL only supports 65535 parameters", len(args))
+	}
+
+	b := cn.writeBuf('P')
+	b.byte(0) // unnamed statement
+	b.string(query)
+	b.int16(0)
+
+	b.next('B')
+	b.int16(0) // unnamed portal and statement
+	cn.sendBinaryParameters(b, args)
+	b.bytes(colFmtDataAllText)
+
+	b.next('D')
+	b.byte('P')
+	b.byte(0) // unnamed portal
+
+	b.next('E')
+	b.byte(0)
+	b.int32(0)
+
+	b.next('S')
+	cn.send(b)
+}
+
+func (c *conn) processParameterStatus(r *readBuf) {
+	var err error
+
+	param := r.string()
+	switch param {
+	case "server_version":
+		var major1 int
+		var major2 int
+		var minor int
+		_, err = fmt.Sscanf(r.string(), "%d.%d.%d", &major1, &major2, &minor)
+		if err == nil {
+			c.parameterStatus.serverVersion = major1*10000 + major2*100 + minor
+		}
+
+	case "TimeZone":
+		c.parameterStatus.currentLocation, err = time.LoadLocation(r.string())
+		if err != nil {
+			c.parameterStatus.currentLocation = nil
+		}
+
+	default:
+		// ignore
+	}
+}
+
+func (c *conn) processReadyForQuery(r *readBuf) {
+	c.txnStatus = transactionStatus(r.byte())
+}
+
+func (cn *conn) readReadyForQuery() {
+	t, r := cn.recv1()
+	switch t {
+	case 'Z':
+		cn.processReadyForQuery(r)
+		return
+	default:
+		cn.bad = true
+		errorf("unexpected message %q; expected ReadyForQuery", t)
+	}
+}
+
+func (cn *conn) readParseResponse() {
+	t, r := cn.recv1()
+	switch t {
+	case '1':
+		return
+	case 'E':
+		err := parseError(r)
+		cn.readReadyForQuery()
+		panic(err)
+	default:
+		cn.bad = true
+		errorf("unexpected Parse response %q", t)
+	}
+}
+
+func (cn *conn) readStatementDescribeResponse() (paramTyps []oid.Oid, colNames []string, colTyps []oid.Oid) {
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 't':
+			nparams := r.int16()
+			paramTyps = make([]oid.Oid, nparams)
+			for i := range paramTyps {
+				paramTyps[i] = r.oid()
+			}
+		case 'n':
+			return paramTyps, nil, nil
+		case 'T':
+			colNames, colTyps = parseStatementRowDescribe(r)
+			return paramTyps, colNames, colTyps
+		case 'E':
+			err := parseError(r)
+			cn.readReadyForQuery()
+			panic(err)
+		default:
+			cn.bad = true
+			errorf("unexpected Describe statement response %q", t)
+		}
+	}
+}
+
+func (cn *conn) readPortalDescribeResponse() (colNames []string, colFmts []format, colTyps []oid.Oid) {
+	t, r := cn.recv1()
+	switch t {
+	case 'T':
+		return parsePortalRowDescribe(r)
+	case 'n':
+		return nil, nil, nil
+	case 'E':
+		err := parseError(r)
+		cn.readReadyForQuery()
+		panic(err)
+	default:
+		cn.bad = true
+		errorf("unexpected Describe response %q", t)
+	}
+	panic("not reached")
+}
+
+func (cn *conn) readBindResponse() {
+	t, r := cn.recv1()
+	switch t {
+	case '2':
+		return
+	case 'E':
+		err := parseError(r)
+		cn.readReadyForQuery()
+		panic(err)
+	default:
+		cn.bad = true
+		errorf("unexpected Bind response %q", t)
+	}
+}
+
+func (cn *conn) postExecuteWorkaround() {
+	// Work around a bug in sql.DB.QueryRow: in Go 1.2 and earlier it ignores
+	// any errors from rows.Next, which masks errors that happened during the
+	// execution of the query.  To avoid the problem in common cases, we wait
+	// here for one more message from the database.  If it's not an error the
+	// query will likely succeed (or perhaps has already, if it's a
+	// CommandComplete), so we push the message into the conn struct; recv1
+	// will return it as the next message for rows.Next or rows.Close.
+	// However, if it's an error, we wait until ReadyForQuery and then return
+	// the error to our caller.
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 'E':
+			err := parseError(r)
+			cn.readReadyForQuery()
+			panic(err)
+		case 'C', 'D', 'I':
+			// the query didn't fail, but we can't process this message
+			cn.saveMessage(t, r)
+			return
+		default:
+			cn.bad = true
+			errorf("unexpected message during extended query execution: %q", t)
+		}
+	}
+}
+
+// Only for Exec(), since we ignore the returned data
+func (cn *conn) readExecuteResponse(protocolState string) (res driver.Result, commandTag string, err error) {
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 'C':
+			res, commandTag = cn.parseComplete(r.string())
+		case 'Z':
+			cn.processReadyForQuery(r)
+			return res, commandTag, err
+		case 'E':
+			err = parseError(r)
+		case 'T', 'D', 'I':
+			// ignore any results
+		default:
+			cn.bad = true
+			errorf("unknown %s response: %q", protocolState, t)
+		}
+	}
+}
+
+func parseStatementRowDescribe(r *readBuf) (colNames []string, colTyps []oid.Oid) {
+	n := r.int16()
+	colNames = make([]string, n)
+	colTyps = make([]oid.Oid, n)
+	for i := range colNames {
+		colNames[i] = r.string()
+		r.next(6)
+		colTyps[i] = r.oid()
+		r.next(6)
+		// format code not known when describing a statement; always 0
+		r.next(2)
+	}
+	return
+}
+
+func parsePortalRowDescribe(r *readBuf) (colNames []string, colFmts []format, colTyps []oid.Oid) {
+	n := r.int16()
+	colNames = make([]string, n)
+	colFmts = make([]format, n)
+	colTyps = make([]oid.Oid, n)
+	for i := range colNames {
+		colNames[i] = r.string()
+		r.next(6)
+		colTyps[i] = r.oid()
+		r.next(6)
+		colFmts[i] = format(r.int16())
+	}
+	return
+}
+
+// parseEnviron tries to mimic some of libpq's environment handling
+//
+// To ease testing, it does not directly reference os.Environ, but is
+// designed to accept its output.
+//
+// Environment-set connection information is intended to have a higher
+// precedence than a library default but lower than any explicitly
+// passed information (such as in the URL or connection string).
+func parseEnviron(env []string) (out map[string]string) {
+	out = make(map[string]string)
+
+	for _, v := range env {
+		parts := strings.SplitN(v, "=", 2)
+
+		accrue := func(keyname string) {
+			out[keyname] = parts[1]
+		}
+		unsupported := func() {
+			panic(fmt.Sprintf("setting %v not supported", parts[0]))
+		}
+
+		// The order of these is the same as is seen in the
+		// PostgreSQL 9.1 manual. Unsupported but well-defined
+		// keys cause a panic; these should be unset prior to
+		// execution. Options which pq expects to be set to a
+		// certain value are allowed, but must be set to that
+		// value if present (they can, of course, be absent).
+		switch parts[0] {
+		case "PGHOST":
+			accrue("host")
+		case "PGHOSTADDR":
+			unsupported()
+		case "PGPORT":
+			accrue("port")
+		case "PGDATABASE":
+			accrue("dbname")
+		case "PGUSER":
+			accrue("user")
+		case "PGPASSWORD":
+			accrue("password")
+		case "PGPASSFILE", "PGSERVICE", "PGSERVICEFILE", "PGREALM":
+			unsupported()
+		case "PGOPTIONS":
+			accrue("options")
+		case "PGAPPNAME":
+			accrue("application_name")
+		case "PGSSLMODE":
+			accrue("sslmode")
+		case "PGSSLCERT":
+			accrue("sslcert")
+		case "PGSSLKEY":
+			accrue("sslkey")
+		case "PGSSLROOTCERT":
+			accrue("sslrootcert")
+		case "PGREQUIRESSL", "PGSSLCRL":
+			unsupported()
+		case "PGREQUIREPEER":
+			unsupported()
+		case "PGKRBSRVNAME", "PGGSSLIB":
+			unsupported()
+		case "PGCONNECT_TIMEOUT":
+			accrue("connect_timeout")
+		case "PGCLIENTENCODING":
+			accrue("client_encoding")
+		case "PGDATESTYLE":
+			accrue("datestyle")
+		case "PGTZ":
+			accrue("timezone")
+		case "PGGEQO":
+			accrue("geqo")
+		case "PGSYSCONFDIR", "PGLOCALEDIR":
+			unsupported()
+		}
+	}
+
+	return out
+}
+
+// isUTF8 returns whether name is a fuzzy variation of the string "UTF-8".
+func isUTF8(name string) bool {
+	// Recognize all sorts of silly things as "UTF-8", like Postgres does
+	s := strings.Map(alnumLowerASCII, name)
+	return s == "utf8" || s == "unicode"
+}
+
+func alnumLowerASCII(ch rune) rune {
+	if 'A' <= ch && ch <= 'Z' {
+		return ch + ('a' - 'A')
+	}
+	if 'a' <= ch && ch <= 'z' || '0' <= ch && ch <= '9' {
+		return ch
+	}
+	return -1 // discard
+}
diff --git a/vendor/github.com/lib/pq/copy.go b/vendor/github.com/lib/pq/copy.go
new file mode 100644
index 00000000..e44fa48a
--- /dev/null
+++ b/vendor/github.com/lib/pq/copy.go
@@ -0,0 +1,268 @@
+package pq
+
+import (
+	"database/sql/driver"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"sync"
+)
+
+var (
+	errCopyInClosed               = errors.New("pq: copyin statement has already been closed")
+	errBinaryCopyNotSupported     = errors.New("pq: only text format supported for COPY")
+	errCopyToNotSupported         = errors.New("pq: COPY TO is not supported")
+	errCopyNotSupportedOutsideTxn = errors.New("pq: COPY is only allowed inside a transaction")
+)
+
+// CopyIn creates a COPY FROM statement which can be prepared with
+// Tx.Prepare().  The target table should be visible in search_path.
+func CopyIn(table string, columns ...string) string {
+	stmt := "COPY " + QuoteIdentifier(table) + " ("
+	for i, col := range columns {
+		if i != 0 {
+			stmt += ", "
+		}
+		stmt += QuoteIdentifier(col)
+	}
+	stmt += ") FROM STDIN"
+	return stmt
+}
+
+// CopyInSchema creates a COPY FROM statement which can be prepared with
+// Tx.Prepare().
+func CopyInSchema(schema, table string, columns ...string) string {
+	stmt := "COPY " + QuoteIdentifier(schema) + "." + QuoteIdentifier(table) + " ("
+	for i, col := range columns {
+		if i != 0 {
+			stmt += ", "
+		}
+		stmt += QuoteIdentifier(col)
+	}
+	stmt += ") FROM STDIN"
+	return stmt
+}
+
+type copyin struct {
+	cn      *conn
+	buffer  []byte
+	rowData chan []byte
+	done    chan bool
+
+	closed bool
+
+	sync.Mutex // guards err
+	err        error
+}
+
+const ciBufferSize = 64 * 1024
+
+// flush buffer before the buffer is filled up and needs reallocation
+const ciBufferFlushSize = 63 * 1024
+
+func (cn *conn) prepareCopyIn(q string) (_ driver.Stmt, err error) {
+	if !cn.isInTransaction() {
+		return nil, errCopyNotSupportedOutsideTxn
+	}
+
+	ci := &copyin{
+		cn:      cn,
+		buffer:  make([]byte, 0, ciBufferSize),
+		rowData: make(chan []byte),
+		done:    make(chan bool, 1),
+	}
+	// add CopyData identifier + 4 bytes for message length
+	ci.buffer = append(ci.buffer, 'd', 0, 0, 0, 0)
+
+	b := cn.writeBuf('Q')
+	b.string(q)
+	cn.send(b)
+
+awaitCopyInResponse:
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 'G':
+			if r.byte() != 0 {
+				err = errBinaryCopyNotSupported
+				break awaitCopyInResponse
+			}
+			go ci.resploop()
+			return ci, nil
+		case 'H':
+			err = errCopyToNotSupported
+			break awaitCopyInResponse
+		case 'E':
+			err = parseError(r)
+		case 'Z':
+			if err == nil {
+				cn.bad = true
+				errorf("unexpected ReadyForQuery in response to COPY")
+			}
+			cn.processReadyForQuery(r)
+			return nil, err
+		default:
+			cn.bad = true
+			errorf("unknown response for copy query: %q", t)
+		}
+	}
+
+	// something went wrong, abort COPY before we return
+	b = cn.writeBuf('f')
+	b.string(err.Error())
+	cn.send(b)
+
+	for {
+		t, r := cn.recv1()
+		switch t {
+		case 'c', 'C', 'E':
+		case 'Z':
+			// correctly aborted, we're done
+			cn.processReadyForQuery(r)
+			return nil, err
+		default:
+			cn.bad = true
+			errorf("unknown response for CopyFail: %q", t)
+		}
+	}
+}
+
+func (ci *copyin) flush(buf []byte) {
+	// set message length (without message identifier)
+	binary.BigEndian.PutUint32(buf[1:], uint32(len(buf)-1))
+
+	_, err := ci.cn.c.Write(buf)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (ci *copyin) resploop() {
+	for {
+		var r readBuf
+		t, err := ci.cn.recvMessage(&r)
+		if err != nil {
+			ci.cn.bad = true
+			ci.setError(err)
+			ci.done <- true
+			return
+		}
+		switch t {
+		case 'C':
+			// complete
+		case 'N':
+			// NoticeResponse
+		case 'Z':
+			ci.cn.processReadyForQuery(&r)
+			ci.done <- true
+			return
+		case 'E':
+			err := parseError(&r)
+			ci.setError(err)
+		default:
+			ci.cn.bad = true
+			ci.setError(fmt.Errorf("unknown response during CopyIn: %q", t))
+			ci.done <- true
+			return
+		}
+	}
+}
+
+func (ci *copyin) isErrorSet() bool {
+	ci.Lock()
+	isSet := (ci.err != nil)
+	ci.Unlock()
+	return isSet
+}
+
+// setError() sets ci.err if one has not been set already.  Caller must not be
+// holding ci.Mutex.
+func (ci *copyin) setError(err error) {
+	ci.Lock()
+	if ci.err == nil {
+		ci.err = err
+	}
+	ci.Unlock()
+}
+
+func (ci *copyin) NumInput() int {
+	return -1
+}
+
+func (ci *copyin) Query(v []driver.Value) (r driver.Rows, err error) {
+	return nil, ErrNotSupported
+}
+
+// Exec inserts values into the COPY stream. The insert is asynchronous
+// and Exec can return errors from previous Exec calls to the same
+// COPY stmt.
+//
+// You need to call Exec(nil) to sync the COPY stream and to get any
+// errors from pending data, since Stmt.Close() doesn't return errors
+// to the user.
+func (ci *copyin) Exec(v []driver.Value) (r driver.Result, err error) {
+	if ci.closed {
+		return nil, errCopyInClosed
+	}
+
+	if ci.cn.bad {
+		return nil, driver.ErrBadConn
+	}
+	defer ci.cn.errRecover(&err)
+
+	if ci.isErrorSet() {
+		return nil, ci.err
+	}
+
+	if len(v) == 0 {
+		err = ci.Close()
+		ci.closed = true
+		return nil, err
+	}
+
+	numValues := len(v)
+	for i, value := range v {
+		ci.buffer = appendEncodedText(&ci.cn.parameterStatus, ci.buffer, value)
+		if i < numValues-1 {
+			ci.buffer = append(ci.buffer, '\t')
+		}
+	}
+
+	ci.buffer = append(ci.buffer, '\n')
+
+	if len(ci.buffer) > ciBufferFlushSize {
+		ci.flush(ci.buffer)
+		// reset buffer, keep bytes for message identifier and length
+		ci.buffer = ci.buffer[:5]
+	}
+
+	return driver.RowsAffected(0), nil
+}
+
+func (ci *copyin) Close() (err error) {
+	if ci.closed {
+		return errCopyInClosed
+	}
+
+	if ci.cn.bad {
+		return driver.ErrBadConn
+	}
+	defer ci.cn.errRecover(&err)
+
+	if len(ci.buffer) > 0 {
+		ci.flush(ci.buffer)
+	}
+	// Avoid touching the scratch buffer as resploop could be using it.
+	err = ci.cn.sendSimpleMessage('c')
+	if err != nil {
+		return err
+	}
+
+	<-ci.done
+
+	if ci.isErrorSet() {
+		err = ci.err
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/lib/pq/doc.go b/vendor/github.com/lib/pq/doc.go
new file mode 100644
index 00000000..f772117d
--- /dev/null
+++ b/vendor/github.com/lib/pq/doc.go
@@ -0,0 +1,210 @@
+/*
+Package pq is a pure Go Postgres driver for the database/sql package.
+
+In most cases clients will use the database/sql package instead of
+using this package directly. For example:
+
+	import (
+		"database/sql"
+
+		_ "github.com/lib/pq"
+	)
+
+	func main() {
+		db, err := sql.Open("postgres", "user=pqgotest dbname=pqgotest sslmode=verify-full")
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		age := 21
+		rows, err := db.Query("SELECT name FROM users WHERE age = $1", age)
+		…
+	}
+
+You can also connect to a database using a URL. For example:
+
+	db, err := sql.Open("postgres", "postgres://pqgotest:password@localhost/pqgotest?sslmode=verify-full")
+
+
+Connection String Parameters
+
+
+Similarly to libpq, when establishing a connection using pq you are expected to
+supply a connection string containing zero or more parameters.
+A subset of the connection parameters supported by libpq are also supported by pq.
+Additionally, pq also lets you specify run-time parameters (such as search_path or work_mem)
+directly in the connection string.  This is different from libpq, which does not allow
+run-time parameters in the connection string, instead requiring you to supply
+them in the options parameter.
+
+For compatibility with libpq, the following special connection parameters are
+supported:
+
+	* dbname - The name of the database to connect to
+	* user - The user to sign in as
+	* password - The user's password
+	* host - The host to connect to. Values that start with / are for unix domain sockets. (default is localhost)
+	* port - The port to bind to. (default is 5432)
+	* sslmode - Whether or not to use SSL (default is require, this is not the default for libpq)
+	* fallback_application_name - An application_name to fall back to if one isn't provided.
+	* connect_timeout - Maximum wait for connection, in seconds. Zero or not specified means wait indefinitely.
+	* sslcert - Cert file location. The file must contain PEM encoded data.
+	* sslkey - Key file location. The file must contain PEM encoded data.
+	* sslrootcert - The location of the root certificate file. The file must contain PEM encoded data.
+
+Valid values for sslmode are:
+
+	* disable - No SSL
+	* require - Always SSL (skip verification)
+	* verify-ca - Always SSL (verify that the certificate presented by the server was signed by a trusted CA)
+	* verify-full - Always SSL (verify that the certification presented by the server was signed by a trusted CA and the server host name matches the one in the certificate)
+
+See http://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING
+for more information about connection string parameters.
+
+Use single quotes for values that contain whitespace:
+
+    "user=pqgotest password='with spaces'"
+
+A backslash will escape the next character in values:
+
+    "user=space\ man password='it\'s valid'
+
+Note that the connection parameter client_encoding (which sets the
+text encoding for the connection) may be set but must be "UTF8",
+matching with the same rules as Postgres. It is an error to provide
+any other value.
+
+In addition to the parameters listed above, any run-time parameter that can be
+set at backend start time can be set in the connection string.  For more
+information, see
+http://www.postgresql.org/docs/current/static/runtime-config.html.
+
+Most environment variables as specified at http://www.postgresql.org/docs/current/static/libpq-envars.html
+supported by libpq are also supported by pq.  If any of the environment
+variables not supported by pq are set, pq will panic during connection
+establishment.  Environment variables have a lower precedence than explicitly
+provided connection parameters.
+
+
+Queries
+
+database/sql does not dictate any specific format for parameter
+markers in query strings, and pq uses the Postgres-native ordinal markers,
+as shown above. The same marker can be reused for the same parameter:
+
+	rows, err := db.Query(`SELECT name FROM users WHERE favorite_fruit = $1
+		OR age BETWEEN $2 AND $2 + 3`, "orange", 64)
+
+pq does not support the LastInsertId() method of the Result type in database/sql.
+To return the identifier of an INSERT (or UPDATE or DELETE), use the Postgres
+RETURNING clause with a standard Query or QueryRow call:
+
+	var userid int
+	err := db.QueryRow(`INSERT INTO users(name, favorite_fruit, age)
+		VALUES('beatrice', 'starfruit', 93) RETURNING id`).Scan(&userid)
+
+For more details on RETURNING, see the Postgres documentation:
+
+	http://www.postgresql.org/docs/current/static/sql-insert.html
+	http://www.postgresql.org/docs/current/static/sql-update.html
+	http://www.postgresql.org/docs/current/static/sql-delete.html
+
+For additional instructions on querying see the documentation for the database/sql package.
+
+Errors
+
+pq may return errors of type *pq.Error which can be interrogated for error details:
+
+        if err, ok := err.(*pq.Error); ok {
+            fmt.Println("pq error:", err.Code.Name())
+        }
+
+See the pq.Error type for details.
+
+
+Bulk imports
+
+You can perform bulk imports by preparing a statement returned by pq.CopyIn (or
+pq.CopyInSchema) in an explicit transaction (sql.Tx). The returned statement
+handle can then be repeatedly "executed" to copy data into the target table.
+After all data has been processed you should call Exec() once with no arguments
+to flush all buffered data. Any call to Exec() might return an error which
+should be handled appropriately, but because of the internal buffering an error
+returned by Exec() might not be related to the data passed in the call that
+failed.
+
+CopyIn uses COPY FROM internally. It is not possible to COPY outside of an
+explicit transaction in pq.
+
+Usage example:
+
+	txn, err := db.Begin()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, err := txn.Prepare(pq.CopyIn("users", "name", "age"))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, user := range users {
+		_, err = stmt.Exec(user.Name, int64(user.Age))
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	_, err = stmt.Exec()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = stmt.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = txn.Commit()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+
+Notifications
+
+
+PostgreSQL supports a simple publish/subscribe model over database
+connections.  See http://www.postgresql.org/docs/current/static/sql-notify.html
+for more information about the general mechanism.
+
+To start listening for notifications, you first have to open a new connection
+to the database by calling NewListener.  This connection can not be used for
+anything other than LISTEN / NOTIFY.  Calling Listen will open a "notification
+channel"; once a notification channel is open, a notification generated on that
+channel will effect a send on the Listener.Notify channel.  A notification
+channel will remain open until Unlisten is called, though connection loss might
+result in some notifications being lost.  To solve this problem, Listener sends
+a nil pointer over the Notify channel any time the connection is re-established
+following a connection loss.  The application can get information about the
+state of the underlying connection by setting an event callback in the call to
+NewListener.
+
+A single Listener can safely be used from concurrent goroutines, which means
+that there is often no need to create more than one Listener in your
+application.  However, a Listener is always connected to a single database, so
+you will need to create a new Listener instance for every database you want to
+receive notifications in.
+
+The channel name in both Listen and Unlisten is case sensitive, and can contain
+any characters legal in an identifier (see
+http://www.postgresql.org/docs/current/static/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
+for more information).  Note that the channel name will be truncated to 63
+bytes by the PostgreSQL server.
+
+You can find a complete, working example of Listener usage at
+http://godoc.org/github.com/lib/pq/listen_example.
+
+*/
+package pq
diff --git a/vendor/github.com/lib/pq/encode.go b/vendor/github.com/lib/pq/encode.go
new file mode 100644
index 00000000..88422eb3
--- /dev/null
+++ b/vendor/github.com/lib/pq/encode.go
@@ -0,0 +1,538 @@
+package pq
+
+import (
+	"bytes"
+	"database/sql/driver"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/lib/pq/oid"
+)
+
+func binaryEncode(parameterStatus *parameterStatus, x interface{}) []byte {
+	switch v := x.(type) {
+	case []byte:
+		return v
+	default:
+		return encode(parameterStatus, x, oid.T_unknown)
+	}
+	panic("not reached")
+}
+
+func encode(parameterStatus *parameterStatus, x interface{}, pgtypOid oid.Oid) []byte {
+	switch v := x.(type) {
+	case int64:
+		return strconv.AppendInt(nil, v, 10)
+	case float64:
+		return strconv.AppendFloat(nil, v, 'f', -1, 64)
+	case []byte:
+		if pgtypOid == oid.T_bytea {
+			return encodeBytea(parameterStatus.serverVersion, v)
+		}
+
+		return v
+	case string:
+		if pgtypOid == oid.T_bytea {
+			return encodeBytea(parameterStatus.serverVersion, []byte(v))
+		}
+
+		return []byte(v)
+	case bool:
+		return strconv.AppendBool(nil, v)
+	case time.Time:
+		return formatTs(v)
+
+	default:
+		errorf("encode: unknown type for %T", v)
+	}
+
+	panic("not reached")
+}
+
+func decode(parameterStatus *parameterStatus, s []byte, typ oid.Oid, f format) interface{} {
+	if f == formatBinary {
+		return binaryDecode(parameterStatus, s, typ)
+	} else {
+		return textDecode(parameterStatus, s, typ)
+	}
+}
+
+func binaryDecode(parameterStatus *parameterStatus, s []byte, typ oid.Oid) interface{} {
+	switch typ {
+	case oid.T_bytea:
+		return s
+	case oid.T_int8:
+		return int64(binary.BigEndian.Uint64(s))
+	case oid.T_int4:
+		return int64(int32(binary.BigEndian.Uint32(s)))
+	case oid.T_int2:
+		return int64(int16(binary.BigEndian.Uint16(s)))
+
+	default:
+		errorf("don't know how to decode binary parameter of type %u", uint32(typ))
+	}
+
+	panic("not reached")
+}
+
+func textDecode(parameterStatus *parameterStatus, s []byte, typ oid.Oid) interface{} {
+	switch typ {
+	case oid.T_bytea:
+		return parseBytea(s)
+	case oid.T_timestamptz:
+		return parseTs(parameterStatus.currentLocation, string(s))
+	case oid.T_timestamp, oid.T_date:
+		return parseTs(nil, string(s))
+	case oid.T_time:
+		return mustParse("15:04:05", typ, s)
+	case oid.T_timetz:
+		return mustParse("15:04:05-07", typ, s)
+	case oid.T_bool:
+		return s[0] == 't'
+	case oid.T_int8, oid.T_int4, oid.T_int2:
+		i, err := strconv.ParseInt(string(s), 10, 64)
+		if err != nil {
+			errorf("%s", err)
+		}
+		return i
+	case oid.T_float4, oid.T_float8:
+		bits := 64
+		if typ == oid.T_float4 {
+			bits = 32
+		}
+		f, err := strconv.ParseFloat(string(s), bits)
+		if err != nil {
+			errorf("%s", err)
+		}
+		return f
+	}
+
+	return s
+}
+
+// appendEncodedText encodes item in text format as required by COPY
+// and appends to buf
+func appendEncodedText(parameterStatus *parameterStatus, buf []byte, x interface{}) []byte {
+	switch v := x.(type) {
+	case int64:
+		return strconv.AppendInt(buf, v, 10)
+	case float64:
+		return strconv.AppendFloat(buf, v, 'f', -1, 64)
+	case []byte:
+		encodedBytea := encodeBytea(parameterStatus.serverVersion, v)
+		return appendEscapedText(buf, string(encodedBytea))
+	case string:
+		return appendEscapedText(buf, v)
+	case bool:
+		return strconv.AppendBool(buf, v)
+	case time.Time:
+		return append(buf, formatTs(v)...)
+	case nil:
+		return append(buf, "\\N"...)
+	default:
+		errorf("encode: unknown type for %T", v)
+	}
+
+	panic("not reached")
+}
+
+func appendEscapedText(buf []byte, text string) []byte {
+	escapeNeeded := false
+	startPos := 0
+	var c byte
+
+	// check if we need to escape
+	for i := 0; i < len(text); i++ {
+		c = text[i]
+		if c == '\\' || c == '\n' || c == '\r' || c == '\t' {
+			escapeNeeded = true
+			startPos = i
+			break
+		}
+	}
+	if !escapeNeeded {
+		return append(buf, text...)
+	}
+
+	// copy till first char to escape, iterate the rest
+	result := append(buf, text[:startPos]...)
+	for i := startPos; i < len(text); i++ {
+		c = text[i]
+		switch c {
+		case '\\':
+			result = append(result, '\\', '\\')
+		case '\n':
+			result = append(result, '\\', 'n')
+		case '\r':
+			result = append(result, '\\', 'r')
+		case '\t':
+			result = append(result, '\\', 't')
+		default:
+			result = append(result, c)
+		}
+	}
+	return result
+}
+
+func mustParse(f string, typ oid.Oid, s []byte) time.Time {
+	str := string(s)
+
+	// check for a 30-minute-offset timezone
+	if (typ == oid.T_timestamptz || typ == oid.T_timetz) &&
+		str[len(str)-3] == ':' {
+		f += ":00"
+	}
+	t, err := time.Parse(f, str)
+	if err != nil {
+		errorf("decode: %s", err)
+	}
+	return t
+}
+
+func expect(str, char string, pos int) {
+	if c := str[pos : pos+1]; c != char {
+		errorf("expected '%v' at position %v; got '%v'", char, pos, c)
+	}
+}
+
+func mustAtoi(str string) int {
+	result, err := strconv.Atoi(str)
+	if err != nil {
+		errorf("expected number; got '%v'", str)
+	}
+	return result
+}
+
+// The location cache caches the time zones typically used by the client.
+type locationCache struct {
+	cache map[int]*time.Location
+	lock  sync.Mutex
+}
+
+// All connections share the same list of timezones. Benchmarking shows that
+// about 5% speed could be gained by putting the cache in the connection and
+// losing the mutex, at the cost of a small amount of memory and a somewhat
+// significant increase in code complexity.
+var globalLocationCache *locationCache = newLocationCache()
+
+func newLocationCache() *locationCache {
+	return &locationCache{cache: make(map[int]*time.Location)}
+}
+
+// Returns the cached timezone for the specified offset, creating and caching
+// it if necessary.
+func (c *locationCache) getLocation(offset int) *time.Location {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	location, ok := c.cache[offset]
+	if !ok {
+		location = time.FixedZone("", offset)
+		c.cache[offset] = location
+	}
+
+	return location
+}
+
+var infinityTsEnabled = false
+var infinityTsNegative time.Time
+var infinityTsPositive time.Time
+
+const (
+	infinityTsEnabledAlready        = "pq: infinity timestamp enabled already"
+	infinityTsNegativeMustBeSmaller = "pq: infinity timestamp: negative value must be smaller (before) than positive"
+)
+
+/*
+ * If EnableInfinityTs is not called, "-infinity" and "infinity" will return
+ * []byte("-infinity") and []byte("infinity") respectively, and potentially
+ * cause error "sql: Scan error on column index 0: unsupported driver -> Scan pair: []uint8 -> *time.Time",
+ * when scanning into a time.Time value.
+ *
+ * Once EnableInfinityTs has been called, all connections created using this
+ * driver will decode Postgres' "-infinity" and "infinity" for "timestamp",
+ * "timestamp with time zone" and "date" types to the predefined minimum and
+ * maximum times, respectively.  When encoding time.Time values, any time which
+ * equals or preceeds the predefined minimum time will be encoded to
+ * "-infinity".  Any values at or past the maximum time will similarly be
+ * encoded to "infinity".
+ *
+ *
+ * If EnableInfinityTs is called with negative >= positive, it will panic.
+ * Calling EnableInfinityTs after a connection has been established results in
+ * undefined behavior.  If EnableInfinityTs is called more than once, it will
+ * panic.
+ */
+func EnableInfinityTs(negative time.Time, positive time.Time) {
+	if infinityTsEnabled {
+		panic(infinityTsEnabledAlready)
+	}
+	if !negative.Before(positive) {
+		panic(infinityTsNegativeMustBeSmaller)
+	}
+	infinityTsEnabled = true
+	infinityTsNegative = negative
+	infinityTsPositive = positive
+}
+
+/*
+ * Testing might want to toggle infinityTsEnabled
+ */
+func disableInfinityTs() {
+	infinityTsEnabled = false
+}
+
+// This is a time function specific to the Postgres default DateStyle
+// setting ("ISO, MDY"), the only one we currently support. This
+// accounts for the discrepancies between the parsing available with
+// time.Parse and the Postgres date formatting quirks.
+func parseTs(currentLocation *time.Location, str string) interface{} {
+	switch str {
+	case "-infinity":
+		if infinityTsEnabled {
+			return infinityTsNegative
+		}
+		return []byte(str)
+	case "infinity":
+		if infinityTsEnabled {
+			return infinityTsPositive
+		}
+		return []byte(str)
+	}
+
+	monSep := strings.IndexRune(str, '-')
+	// this is Gregorian year, not ISO Year
+	// In Gregorian system, the year 1 BC is followed by AD 1
+	year := mustAtoi(str[:monSep])
+	daySep := monSep + 3
+	month := mustAtoi(str[monSep+1 : daySep])
+	expect(str, "-", daySep)
+	timeSep := daySep + 3
+	day := mustAtoi(str[daySep+1 : timeSep])
+
+	var hour, minute, second int
+	if len(str) > monSep+len("01-01")+1 {
+		expect(str, " ", timeSep)
+		minSep := timeSep + 3
+		expect(str, ":", minSep)
+		hour = mustAtoi(str[timeSep+1 : minSep])
+		secSep := minSep + 3
+		expect(str, ":", secSep)
+		minute = mustAtoi(str[minSep+1 : secSep])
+		secEnd := secSep + 3
+		second = mustAtoi(str[secSep+1 : secEnd])
+	}
+	remainderIdx := monSep + len("01-01 00:00:00") + 1
+	// Three optional (but ordered) sections follow: the
+	// fractional seconds, the time zone offset, and the BC
+	// designation. We set them up here and adjust the other
+	// offsets if the preceding sections exist.
+
+	nanoSec := 0
+	tzOff := 0
+
+	if remainderIdx < len(str) && str[remainderIdx:remainderIdx+1] == "." {
+		fracStart := remainderIdx + 1
+		fracOff := strings.IndexAny(str[fracStart:], "-+ ")
+		if fracOff < 0 {
+			fracOff = len(str) - fracStart
+		}
+		fracSec := mustAtoi(str[fracStart : fracStart+fracOff])
+		nanoSec = fracSec * (1000000000 / int(math.Pow(10, float64(fracOff))))
+
+		remainderIdx += fracOff + 1
+	}
+	if tzStart := remainderIdx; tzStart < len(str) && (str[tzStart:tzStart+1] == "-" || str[tzStart:tzStart+1] == "+") {
+		// time zone separator is always '-' or '+' (UTC is +00)
+		var tzSign int
+		if c := str[tzStart : tzStart+1]; c == "-" {
+			tzSign = -1
+		} else if c == "+" {
+			tzSign = +1
+		} else {
+			errorf("expected '-' or '+' at position %v; got %v", tzStart, c)
+		}
+		tzHours := mustAtoi(str[tzStart+1 : tzStart+3])
+		remainderIdx += 3
+		var tzMin, tzSec int
+		if tzStart+3 < len(str) && str[tzStart+3:tzStart+4] == ":" {
+			tzMin = mustAtoi(str[tzStart+4 : tzStart+6])
+			remainderIdx += 3
+		}
+		if tzStart+6 < len(str) && str[tzStart+6:tzStart+7] == ":" {
+			tzSec = mustAtoi(str[tzStart+7 : tzStart+9])
+			remainderIdx += 3
+		}
+		tzOff = tzSign * ((tzHours * 60 * 60) + (tzMin * 60) + tzSec)
+	}
+	var isoYear int
+	if remainderIdx < len(str) && str[remainderIdx:remainderIdx+3] == " BC" {
+		isoYear = 1 - year
+		remainderIdx += 3
+	} else {
+		isoYear = year
+	}
+	if remainderIdx < len(str) {
+		errorf("expected end of input, got %v", str[remainderIdx:])
+	}
+	t := time.Date(isoYear, time.Month(month), day,
+		hour, minute, second, nanoSec,
+		globalLocationCache.getLocation(tzOff))
+
+	if currentLocation != nil {
+		// Set the location of the returned Time based on the session's
+		// TimeZone value, but only if the local time zone database agrees with
+		// the remote database on the offset.
+		lt := t.In(currentLocation)
+		_, newOff := lt.Zone()
+		if newOff == tzOff {
+			t = lt
+		}
+	}
+
+	return t
+}
+
+// formatTs formats t into a format postgres understands.
+func formatTs(t time.Time) (b []byte) {
+	if infinityTsEnabled {
+		// t <= -infinity : ! (t > -infinity)
+		if !t.After(infinityTsNegative) {
+			return []byte("-infinity")
+		}
+		// t >= infinity : ! (!t < infinity)
+		if !t.Before(infinityTsPositive) {
+			return []byte("infinity")
+		}
+	}
+	// Need to send dates before 0001 A.D. with " BC" suffix, instead of the
+	// minus sign preferred by Go.
+	// Beware, "0000" in ISO is "1 BC", "-0001" is "2 BC" and so on
+	bc := false
+	if t.Year() <= 0 {
+		// flip year sign, and add 1, e.g: "0" will be "1", and "-10" will be "11"
+		t = t.AddDate((-t.Year())*2+1, 0, 0)
+		bc = true
+	}
+	b = []byte(t.Format(time.RFC3339Nano))
+
+	_, offset := t.Zone()
+	offset = offset % 60
+	if offset != 0 {
+		// RFC3339Nano already printed the minus sign
+		if offset < 0 {
+			offset = -offset
+		}
+
+		b = append(b, ':')
+		if offset < 10 {
+			b = append(b, '0')
+		}
+		b = strconv.AppendInt(b, int64(offset), 10)
+	}
+
+	if bc {
+		b = append(b, " BC"...)
+	}
+	return b
+}
+
+// Parse a bytea value received from the server.  Both "hex" and the legacy
+// "escape" format are supported.
+func parseBytea(s []byte) (result []byte) {
+	if len(s) >= 2 && bytes.Equal(s[:2], []byte("\\x")) {
+		// bytea_output = hex
+		s = s[2:] // trim off leading "\\x"
+		result = make([]byte, hex.DecodedLen(len(s)))
+		_, err := hex.Decode(result, s)
+		if err != nil {
+			errorf("%s", err)
+		}
+	} else {
+		// bytea_output = escape
+		for len(s) > 0 {
+			if s[0] == '\\' {
+				// escaped '\\'
+				if len(s) >= 2 && s[1] == '\\' {
+					result = append(result, '\\')
+					s = s[2:]
+					continue
+				}
+
+				// '\\' followed by an octal number
+				if len(s) < 4 {
+					errorf("invalid bytea sequence %v", s)
+				}
+				r, err := strconv.ParseInt(string(s[1:4]), 8, 9)
+				if err != nil {
+					errorf("could not parse bytea value: %s", err.Error())
+				}
+				result = append(result, byte(r))
+				s = s[4:]
+			} else {
+				// We hit an unescaped, raw byte.  Try to read in as many as
+				// possible in one go.
+				i := bytes.IndexByte(s, '\\')
+				if i == -1 {
+					result = append(result, s...)
+					break
+				}
+				result = append(result, s[:i]...)
+				s = s[i:]
+			}
+		}
+	}
+
+	return result
+}
+
+func encodeBytea(serverVersion int, v []byte) (result []byte) {
+	if serverVersion >= 90000 {
+		// Use the hex format if we know that the server supports it
+		result = make([]byte, 2+hex.EncodedLen(len(v)))
+		result[0] = '\\'
+		result[1] = 'x'
+		hex.Encode(result[2:], v)
+	} else {
+		// .. or resort to "escape"
+		for _, b := range v {
+			if b == '\\' {
+				result = append(result, '\\', '\\')
+			} else if b < 0x20 || b > 0x7e {
+				result = append(result, []byte(fmt.Sprintf("\\%03o", b))...)
+			} else {
+				result = append(result, b)
+			}
+		}
+	}
+
+	return result
+}
+
+// NullTime represents a time.Time that may be null. NullTime implements the
+// sql.Scanner interface so it can be used as a scan destination, similar to
+// sql.NullString.
+type NullTime struct {
+	Time  time.Time
+	Valid bool // Valid is true if Time is not NULL
+}
+
+// Scan implements the Scanner interface.
+func (nt *NullTime) Scan(value interface{}) error {
+	nt.Time, nt.Valid = value.(time.Time)
+	return nil
+}
+
+// Value implements the driver Valuer interface.
+func (nt NullTime) Value() (driver.Value, error) {
+	if !nt.Valid {
+		return nil, nil
+	}
+	return nt.Time, nil
+}
diff --git a/vendor/github.com/lib/pq/error.go b/vendor/github.com/lib/pq/error.go
new file mode 100644
index 00000000..b4bb44ce
--- /dev/null
+++ b/vendor/github.com/lib/pq/error.go
@@ -0,0 +1,508 @@
+package pq
+
+import (
+	"database/sql/driver"
+	"fmt"
+	"io"
+	"net"
+	"runtime"
+)
+
+// Error severities
+const (
+	Efatal   = "FATAL"
+	Epanic   = "PANIC"
+	Ewarning = "WARNING"
+	Enotice  = "NOTICE"
+	Edebug   = "DEBUG"
+	Einfo    = "INFO"
+	Elog     = "LOG"
+)
+
+// Error represents an error communicating with the server.
+//
+// See http://www.postgresql.org/docs/current/static/protocol-error-fields.html for details of the fields
+type Error struct {
+	Severity         string
+	Code             ErrorCode
+	Message          string
+	Detail           string
+	Hint             string
+	Position         string
+	InternalPosition string
+	InternalQuery    string
+	Where            string
+	Schema           string
+	Table            string
+	Column           string
+	DataTypeName     string
+	Constraint       string
+	File             string
+	Line             string
+	Routine          string
+}
+
+// ErrorCode is a five-character error code.
+type ErrorCode string
+
+// Name returns a more human friendly rendering of the error code, namely the
+// "condition name".
+//
+// See http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html for
+// details.
+func (ec ErrorCode) Name() string {
+	return errorCodeNames[ec]
+}
+
+// ErrorClass is only the class part of an error code.
+type ErrorClass string
+
+// Name returns the condition name of an error class.  It is equivalent to the
+// condition name of the "standard" error code (i.e. the one having the last
+// three characters "000").
+func (ec ErrorClass) Name() string {
+	return errorCodeNames[ErrorCode(ec+"000")]
+}
+
+// Class returns the error class, e.g. "28".
+//
+// See http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html for
+// details.
+func (ec ErrorCode) Class() ErrorClass {
+	return ErrorClass(ec[0:2])
+}
+
+// errorCodeNames is a mapping between the five-character error codes and the
+// human readable "condition names". It is derived from the list at
+// http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html
+var errorCodeNames = map[ErrorCode]string{
+	// Class 00 - Successful Completion
+	"00000": "successful_completion",
+	// Class 01 - Warning
+	"01000": "warning",
+	"0100C": "dynamic_result_sets_returned",
+	"01008": "implicit_zero_bit_padding",
+	"01003": "null_value_eliminated_in_set_function",
+	"01007": "privilege_not_granted",
+	"01006": "privilege_not_revoked",
+	"01004": "string_data_right_truncation",
+	"01P01": "deprecated_feature",
+	// Class 02 - No Data (this is also a warning class per the SQL standard)
+	"02000": "no_data",
+	"02001": "no_additional_dynamic_result_sets_returned",
+	// Class 03 - SQL Statement Not Yet Complete
+	"03000": "sql_statement_not_yet_complete",
+	// Class 08 - Connection Exception
+	"08000": "connection_exception",
+	"08003": "connection_does_not_exist",
+	"08006": "connection_failure",
+	"08001": "sqlclient_unable_to_establish_sqlconnection",
+	"08004": "sqlserver_rejected_establishment_of_sqlconnection",
+	"08007": "transaction_resolution_unknown",
+	"08P01": "protocol_violation",
+	// Class 09 - Triggered Action Exception
+	"09000": "triggered_action_exception",
+	// Class 0A - Feature Not Supported
+	"0A000": "feature_not_supported",
+	// Class 0B - Invalid Transaction Initiation
+	"0B000": "invalid_transaction_initiation",
+	// Class 0F - Locator Exception
+	"0F000": "locator_exception",
+	"0F001": "invalid_locator_specification",
+	// Class 0L - Invalid Grantor
+	"0L000": "invalid_grantor",
+	"0LP01": "invalid_grant_operation",
+	// Class 0P - Invalid Role Specification
+	"0P000": "invalid_role_specification",
+	// Class 0Z - Diagnostics Exception
+	"0Z000": "diagnostics_exception",
+	"0Z002": "stacked_diagnostics_accessed_without_active_handler",
+	// Class 20 - Case Not Found
+	"20000": "case_not_found",
+	// Class 21 - Cardinality Violation
+	"21000": "cardinality_violation",
+	// Class 22 - Data Exception
+	"22000": "data_exception",
+	"2202E": "array_subscript_error",
+	"22021": "character_not_in_repertoire",
+	"22008": "datetime_field_overflow",
+	"22012": "division_by_zero",
+	"22005": "error_in_assignment",
+	"2200B": "escape_character_conflict",
+	"22022": "indicator_overflow",
+	"22015": "interval_field_overflow",
+	"2201E": "invalid_argument_for_logarithm",
+	"22014": "invalid_argument_for_ntile_function",
+	"22016": "invalid_argument_for_nth_value_function",
+	"2201F": "invalid_argument_for_power_function",
+	"2201G": "invalid_argument_for_width_bucket_function",
+	"22018": "invalid_character_value_for_cast",
+	"22007": "invalid_datetime_format",
+	"22019": "invalid_escape_character",
+	"2200D": "invalid_escape_octet",
+	"22025": "invalid_escape_sequence",
+	"22P06": "nonstandard_use_of_escape_character",
+	"22010": "invalid_indicator_parameter_value",
+	"22023": "invalid_parameter_value",
+	"2201B": "invalid_regular_expression",
+	"2201W": "invalid_row_count_in_limit_clause",
+	"2201X": "invalid_row_count_in_result_offset_clause",
+	"22009": "invalid_time_zone_displacement_value",
+	"2200C": "invalid_use_of_escape_character",
+	"2200G": "most_specific_type_mismatch",
+	"22004": "null_value_not_allowed",
+	"22002": "null_value_no_indicator_parameter",
+	"22003": "numeric_value_out_of_range",
+	"22026": "string_data_length_mismatch",
+	"22001": "string_data_right_truncation",
+	"22011": "substring_error",
+	"22027": "trim_error",
+	"22024": "unterminated_c_string",
+	"2200F": "zero_length_character_string",
+	"22P01": "floating_point_exception",
+	"22P02": "invalid_text_representation",
+	"22P03": "invalid_binary_representation",
+	"22P04": "bad_copy_file_format",
+	"22P05": "untranslatable_character",
+	"2200L": "not_an_xml_document",
+	"2200M": "invalid_xml_document",
+	"2200N": "invalid_xml_content",
+	"2200S": "invalid_xml_comment",
+	"2200T": "invalid_xml_processing_instruction",
+	// Class 23 - Integrity Constraint Violation
+	"23000": "integrity_constraint_violation",
+	"23001": "restrict_violation",
+	"23502": "not_null_violation",
+	"23503": "foreign_key_violation",
+	"23505": "unique_violation",
+	"23514": "check_violation",
+	"23P01": "exclusion_violation",
+	// Class 24 - Invalid Cursor State
+	"24000": "invalid_cursor_state",
+	// Class 25 - Invalid Transaction State
+	"25000": "invalid_transaction_state",
+	"25001": "active_sql_transaction",
+	"25002": "branch_transaction_already_active",
+	"25008": "held_cursor_requires_same_isolation_level",
+	"25003": "inappropriate_access_mode_for_branch_transaction",
+	"25004": "inappropriate_isolation_level_for_branch_transaction",
+	"25005": "no_active_sql_transaction_for_branch_transaction",
+	"25006": "read_only_sql_transaction",
+	"25007": "schema_and_data_statement_mixing_not_supported",
+	"25P01": "no_active_sql_transaction",
+	"25P02": "in_failed_sql_transaction",
+	// Class 26 - Invalid SQL Statement Name
+	"26000": "invalid_sql_statement_name",
+	// Class 27 - Triggered Data Change Violation
+	"27000": "triggered_data_change_violation",
+	// Class 28 - Invalid Authorization Specification
+	"28000": "invalid_authorization_specification",
+	"28P01": "invalid_password",
+	// Class 2B - Dependent Privilege Descriptors Still Exist
+	"2B000": "dependent_privilege_descriptors_still_exist",
+	"2BP01": "dependent_objects_still_exist",
+	// Class 2D - Invalid Transaction Termination
+	"2D000": "invalid_transaction_termination",
+	// Class 2F - SQL Routine Exception
+	"2F000": "sql_routine_exception",
+	"2F005": "function_executed_no_return_statement",
+	"2F002": "modifying_sql_data_not_permitted",
+	"2F003": "prohibited_sql_statement_attempted",
+	"2F004": "reading_sql_data_not_permitted",
+	// Class 34 - Invalid Cursor Name
+	"34000": "invalid_cursor_name",
+	// Class 38 - External Routine Exception
+	"38000": "external_routine_exception",
+	"38001": "containing_sql_not_permitted",
+	"38002": "modifying_sql_data_not_permitted",
+	"38003": "prohibited_sql_statement_attempted",
+	"38004": "reading_sql_data_not_permitted",
+	// Class 39 - External Routine Invocation Exception
+	"39000": "external_routine_invocation_exception",
+	"39001": "invalid_sqlstate_returned",
+	"39004": "null_value_not_allowed",
+	"39P01": "trigger_protocol_violated",
+	"39P02": "srf_protocol_violated",
+	// Class 3B - Savepoint Exception
+	"3B000": "savepoint_exception",
+	"3B001": "invalid_savepoint_specification",
+	// Class 3D - Invalid Catalog Name
+	"3D000": "invalid_catalog_name",
+	// Class 3F - Invalid Schema Name
+	"3F000": "invalid_schema_name",
+	// Class 40 - Transaction Rollback
+	"40000": "transaction_rollback",
+	"40002": "transaction_integrity_constraint_violation",
+	"40001": "serialization_failure",
+	"40003": "statement_completion_unknown",
+	"40P01": "deadlock_detected",
+	// Class 42 - Syntax Error or Access Rule Violation
+	"42000": "syntax_error_or_access_rule_violation",
+	"42601": "syntax_error",
+	"42501": "insufficient_privilege",
+	"42846": "cannot_coerce",
+	"42803": "grouping_error",
+	"42P20": "windowing_error",
+	"42P19": "invalid_recursion",
+	"42830": "invalid_foreign_key",
+	"42602": "invalid_name",
+	"42622": "name_too_long",
+	"42939": "reserved_name",
+	"42804": "datatype_mismatch",
+	"42P18": "indeterminate_datatype",
+	"42P21": "collation_mismatch",
+	"42P22": "indeterminate_collation",
+	"42809": "wrong_object_type",
+	"42703": "undefined_column",
+	"42883": "undefined_function",
+	"42P01": "undefined_table",
+	"42P02": "undefined_parameter",
+	"42704": "undefined_object",
+	"42701": "duplicate_column",
+	"42P03": "duplicate_cursor",
+	"42P04": "duplicate_database",
+	"42723": "duplicate_function",
+	"42P05": "duplicate_prepared_statement",
+	"42P06": "duplicate_schema",
+	"42P07": "duplicate_table",
+	"42712": "duplicate_alias",
+	"42710": "duplicate_object",
+	"42702": "ambiguous_column",
+	"42725": "ambiguous_function",
+	"42P08": "ambiguous_parameter",
+	"42P09": "ambiguous_alias",
+	"42P10": "invalid_column_reference",
+	"42611": "invalid_column_definition",
+	"42P11": "invalid_cursor_definition",
+	"42P12": "invalid_database_definition",
+	"42P13": "invalid_function_definition",
+	"42P14": "invalid_prepared_statement_definition",
+	"42P15": "invalid_schema_definition",
+	"42P16": "invalid_table_definition",
+	"42P17": "invalid_object_definition",
+	// Class 44 - WITH CHECK OPTION Violation
+	"44000": "with_check_option_violation",
+	// Class 53 - Insufficient Resources
+	"53000": "insufficient_resources",
+	"53100": "disk_full",
+	"53200": "out_of_memory",
+	"53300": "too_many_connections",
+	"53400": "configuration_limit_exceeded",
+	// Class 54 - Program Limit Exceeded
+	"54000": "program_limit_exceeded",
+	"54001": "statement_too_complex",
+	"54011": "too_many_columns",
+	"54023": "too_many_arguments",
+	// Class 55 - Object Not In Prerequisite State
+	"55000": "object_not_in_prerequisite_state",
+	"55006": "object_in_use",
+	"55P02": "cant_change_runtime_param",
+	"55P03": "lock_not_available",
+	// Class 57 - Operator Intervention
+	"57000": "operator_intervention",
+	"57014": "query_canceled",
+	"57P01": "admin_shutdown",
+	"57P02": "crash_shutdown",
+	"57P03": "cannot_connect_now",
+	"57P04": "database_dropped",
+	// Class 58 - System Error (errors external to PostgreSQL itself)
+	"58000": "system_error",
+	"58030": "io_error",
+	"58P01": "undefined_file",
+	"58P02": "duplicate_file",
+	// Class F0 - Configuration File Error
+	"F0000": "config_file_error",
+	"F0001": "lock_file_exists",
+	// Class HV - Foreign Data Wrapper Error (SQL/MED)
+	"HV000": "fdw_error",
+	"HV005": "fdw_column_name_not_found",
+	"HV002": "fdw_dynamic_parameter_value_needed",
+	"HV010": "fdw_function_sequence_error",
+	"HV021": "fdw_inconsistent_descriptor_information",
+	"HV024": "fdw_invalid_attribute_value",
+	"HV007": "fdw_invalid_column_name",
+	"HV008": "fdw_invalid_column_number",
+	"HV004": "fdw_invalid_data_type",
+	"HV006": "fdw_invalid_data_type_descriptors",
+	"HV091": "fdw_invalid_descriptor_field_identifier",
+	"HV00B": "fdw_invalid_handle",
+	"HV00C": "fdw_invalid_option_index",
+	"HV00D": "fdw_invalid_option_name",
+	"HV090": "fdw_invalid_string_length_or_buffer_length",
+	"HV00A": "fdw_invalid_string_format",
+	"HV009": "fdw_invalid_use_of_null_pointer",
+	"HV014": "fdw_too_many_handles",
+	"HV001": "fdw_out_of_memory",
+	"HV00P": "fdw_no_schemas",
+	"HV00J": "fdw_option_name_not_found",
+	"HV00K": "fdw_reply_handle",
+	"HV00Q": "fdw_schema_not_found",
+	"HV00R": "fdw_table_not_found",
+	"HV00L": "fdw_unable_to_create_execution",
+	"HV00M": "fdw_unable_to_create_reply",
+	"HV00N": "fdw_unable_to_establish_connection",
+	// Class P0 - PL/pgSQL Error
+	"P0000": "plpgsql_error",
+	"P0001": "raise_exception",
+	"P0002": "no_data_found",
+	"P0003": "too_many_rows",
+	// Class XX - Internal Error
+	"XX000": "internal_error",
+	"XX001": "data_corrupted",
+	"XX002": "index_corrupted",
+}
+
+func parseError(r *readBuf) *Error {
+	err := new(Error)
+	for t := r.byte(); t != 0; t = r.byte() {
+		msg := r.string()
+		switch t {
+		case 'S':
+			err.Severity = msg
+		case 'C':
+			err.Code = ErrorCode(msg)
+		case 'M':
+			err.Message = msg
+		case 'D':
+			err.Detail = msg
+		case 'H':
+			err.Hint = msg
+		case 'P':
+			err.Position = msg
+		case 'p':
+			err.InternalPosition = msg
+		case 'q':
+			err.InternalQuery = msg
+		case 'W':
+			err.Where = msg
+		case 's':
+			err.Schema = msg
+		case 't':
+			err.Table = msg
+		case 'c':
+			err.Column = msg
+		case 'd':
+			err.DataTypeName = msg
+		case 'n':
+			err.Constraint = msg
+		case 'F':
+			err.File = msg
+		case 'L':
+			err.Line = msg
+		case 'R':
+			err.Routine = msg
+		}
+	}
+	return err
+}
+
+// Fatal returns true if the Error Severity is fatal.
+func (err *Error) Fatal() bool {
+	return err.Severity == Efatal
+}
+
+// Get implements the legacy PGError interface. New code should use the fields
+// of the Error struct directly.
+func (err *Error) Get(k byte) (v string) {
+	switch k {
+	case 'S':
+		return err.Severity
+	case 'C':
+		return string(err.Code)
+	case 'M':
+		return err.Message
+	case 'D':
+		return err.Detail
+	case 'H':
+		return err.Hint
+	case 'P':
+		return err.Position
+	case 'p':
+		return err.InternalPosition
+	case 'q':
+		return err.InternalQuery
+	case 'W':
+		return err.Where
+	case 's':
+		return err.Schema
+	case 't':
+		return err.Table
+	case 'c':
+		return err.Column
+	case 'd':
+		return err.DataTypeName
+	case 'n':
+		return err.Constraint
+	case 'F':
+		return err.File
+	case 'L':
+		return err.Line
+	case 'R':
+		return err.Routine
+	}
+	return ""
+}
+
+func (err Error) Error() string {
+	return "pq: " + err.Message
+}
+
+// PGError is an interface used by previous versions of pq. It is provided
+// only to support legacy code. New code should use the Error type.
+type PGError interface {
+	Error() string
+	Fatal() bool
+	Get(k byte) (v string)
+}
+
+func errorf(s string, args ...interface{}) {
+	panic(fmt.Errorf("pq: %s", fmt.Sprintf(s, args...)))
+}
+
+func errRecoverNoErrBadConn(err *error) {
+	e := recover()
+	if e == nil {
+		// Do nothing
+		return
+	}
+	var ok bool
+	*err, ok = e.(error)
+	if !ok {
+		*err = fmt.Errorf("pq: unexpected error: %#v", e)
+	}
+}
+
+func (c *conn) errRecover(err *error) {
+	e := recover()
+	switch v := e.(type) {
+	case nil:
+		// Do nothing
+	case runtime.Error:
+		c.bad = true
+		panic(v)
+	case *Error:
+		if v.Fatal() {
+			*err = driver.ErrBadConn
+		} else {
+			*err = v
+		}
+	case *net.OpError:
+		*err = driver.ErrBadConn
+	case error:
+		if v == io.EOF || v.(error).Error() == "remote error: handshake failure" {
+			*err = driver.ErrBadConn
+		} else {
+			*err = v
+		}
+
+	default:
+		c.bad = true
+		panic(fmt.Sprintf("unknown error: %#v", e))
+	}
+
+	// Any time we return ErrBadConn, we need to remember it since *Tx doesn't
+	// mark the connection bad in database/sql.
+	if *err == driver.ErrBadConn {
+		c.bad = true
+	}
+}
diff --git a/vendor/github.com/lib/pq/hstore/hstore.go b/vendor/github.com/lib/pq/hstore/hstore.go
new file mode 100644
index 00000000..72d5abf5
--- /dev/null
+++ b/vendor/github.com/lib/pq/hstore/hstore.go
@@ -0,0 +1,118 @@
+package hstore
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"strings"
+)
+
+// A wrapper for transferring Hstore values back and forth easily.
+type Hstore struct {
+	Map map[string]sql.NullString
+}
+
+// escapes and quotes hstore keys/values
+// s should be a sql.NullString or string
+func hQuote(s interface{}) string {
+	var str string
+	switch v := s.(type) {
+	case sql.NullString:
+		if !v.Valid {
+			return "NULL"
+		}
+		str = v.String
+	case string:
+		str = v
+	default:
+		panic("not a string or sql.NullString")
+	}
+
+	str = strings.Replace(str, "\\", "\\\\", -1)
+	return `"` + strings.Replace(str, "\"", "\\\"", -1) + `"`
+}
+
+// Scan implements the Scanner interface.
+//
+// Note h.Map is reallocated before the scan to clear existing values. If the
+// hstore column's database value is NULL, then h.Map is set to nil instead.
+func (h *Hstore) Scan(value interface{}) error {
+	if value == nil {
+		h.Map = nil
+		return nil
+	}
+	h.Map = make(map[string]sql.NullString)
+	var b byte
+	pair := [][]byte{{}, {}}
+	pi := 0
+	inQuote := false
+	didQuote := false
+	sawSlash := false
+	bindex := 0
+	for bindex, b = range value.([]byte) {
+		if sawSlash {
+			pair[pi] = append(pair[pi], b)
+			sawSlash = false
+			continue
+		}
+
+		switch b {
+		case '\\':
+			sawSlash = true
+			continue
+		case '"':
+			inQuote = !inQuote
+			if !didQuote {
+				didQuote = true
+			}
+			continue
+		default:
+			if !inQuote {
+				switch b {
+				case ' ', '\t', '\n', '\r':
+					continue
+				case '=':
+					continue
+				case '>':
+					pi = 1
+					didQuote = false
+					continue
+				case ',':
+					s := string(pair[1])
+					if !didQuote && len(s) == 4 && strings.ToLower(s) == "null" {
+						h.Map[string(pair[0])] = sql.NullString{String: "", Valid: false}
+					} else {
+						h.Map[string(pair[0])] = sql.NullString{String: string(pair[1]), Valid: true}
+					}
+					pair[0] = []byte{}
+					pair[1] = []byte{}
+					pi = 0
+					continue
+				}
+			}
+		}
+		pair[pi] = append(pair[pi], b)
+	}
+	if bindex > 0 {
+		s := string(pair[1])
+		if !didQuote && len(s) == 4 && strings.ToLower(s) == "null" {
+			h.Map[string(pair[0])] = sql.NullString{String: "", Valid: false}
+		} else {
+			h.Map[string(pair[0])] = sql.NullString{String: string(pair[1]), Valid: true}
+		}
+	}
+	return nil
+}
+
+// Value implements the driver Valuer interface. Note if h.Map is nil, the
+// database column value will be set to NULL.
+func (h Hstore) Value() (driver.Value, error) {
+	if h.Map == nil {
+		return nil, nil
+	}
+	parts := []string{}
+	for key, val := range h.Map {
+		thispart := hQuote(key) + "=>" + hQuote(val)
+		parts = append(parts, thispart)
+	}
+	return []byte(strings.Join(parts, ",")), nil
+}
diff --git a/vendor/github.com/lib/pq/listen_example/doc.go b/vendor/github.com/lib/pq/listen_example/doc.go
new file mode 100644
index 00000000..5bc99f5c
--- /dev/null
+++ b/vendor/github.com/lib/pq/listen_example/doc.go
@@ -0,0 +1,102 @@
+/*
+
+Below you will find a self-contained Go program which uses the LISTEN / NOTIFY
+mechanism to avoid polling the database while waiting for more work to arrive.
+
+    //
+    // You can see the program in action by defining a function similar to
+    // the following:
+    //
+    // CREATE OR REPLACE FUNCTION public.get_work()
+    //   RETURNS bigint
+    //   LANGUAGE sql
+    //   AS $$
+    //     SELECT CASE WHEN random() >= 0.2 THEN int8 '1' END
+    //   $$
+    // ;
+
+    package main
+
+    import (
+        "database/sql"
+        "fmt"
+        "time"
+
+        "github.com/lib/pq"
+    )
+
+    func doWork(db *sql.DB, work int64) {
+        // work here
+    }
+
+    func getWork(db *sql.DB) {
+        for {
+            // get work from the database here
+            var work sql.NullInt64
+            err := db.QueryRow("SELECT get_work()").Scan(&work)
+            if err != nil {
+                fmt.Println("call to get_work() failed: ", err)
+                time.Sleep(10 * time.Second)
+                continue
+            }
+            if !work.Valid {
+                // no more work to do
+                fmt.Println("ran out of work")
+                return
+            }
+
+            fmt.Println("starting work on ", work.Int64)
+            go doWork(db, work.Int64)
+        }
+    }
+
+    func waitForNotification(l *pq.Listener) {
+        for {
+            select {
+                case <-l.Notify:
+                    fmt.Println("received notification, new work available")
+                    return
+                case <-time.After(90 * time.Second):
+                    go func() {
+                        l.Ping()
+                    }()
+                    // Check if there's more work available, just in case it takes
+                    // a while for the Listener to notice connection loss and
+                    // reconnect.
+                    fmt.Println("received no work for 90 seconds, checking for new work")
+                    return
+            }
+        }
+    }
+
+    func main() {
+        var conninfo string = ""
+
+        db, err := sql.Open("postgres", conninfo)
+        if err != nil {
+            panic(err)
+        }
+
+        reportProblem := func(ev pq.ListenerEventType, err error) {
+            if err != nil {
+                fmt.Println(err.Error())
+            }
+        }
+
+        listener := pq.NewListener(conninfo, 10 * time.Second, time.Minute, reportProblem)
+        err = listener.Listen("getwork")
+        if err != nil {
+            panic(err)
+        }
+
+        fmt.Println("entering main loop")
+        for {
+            // process all available work before waiting for notifications
+            getWork(db)
+            waitForNotification(listener)
+        }
+    }
+
+
+*/
+package listen_example
diff --git a/vendor/github.com/lib/pq/notify.go b/vendor/github.com/lib/pq/notify.go
new file mode 100644
index 00000000..8cad5781
--- /dev/null
+++ b/vendor/github.com/lib/pq/notify.go
@@ -0,0 +1,766 @@
+package pq
+
+// Package pq is a pure Go Postgres driver for the database/sql package.
+// This module contains support for Postgres LISTEN/NOTIFY.
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Notification represents a single notification from the database.
+type Notification struct {
+	// Process ID (PID) of the notifying postgres backend.
+	BePid int
+	// Name of the channel the notification was sent on.
+	Channel string
+	// Payload, or the empty string if unspecified.
+	Extra string
+}
+
+func recvNotification(r *readBuf) *Notification {
+	bePid := r.int32()
+	channel := r.string()
+	extra := r.string()
+
+	return &Notification{bePid, channel, extra}
+}
+
+const (
+	connStateIdle int32 = iota
+	connStateExpectResponse
+	connStateExpectReadyForQuery
+)
+
+type message struct {
+	typ byte
+	err error
+}
+
+var errListenerConnClosed = errors.New("pq: ListenerConn has been closed")
+
+// ListenerConn is a low-level interface for waiting for notifications.  You
+// should use Listener instead.
+type ListenerConn struct {
+	// guards cn and err
+	connectionLock sync.Mutex
+	cn             *conn
+	err            error
+
+	connState int32
+
+	// the sending goroutine will be holding this lock
+	senderLock sync.Mutex
+
+	notificationChan chan<- *Notification
+
+	replyChan chan message
+}
+
+// Creates a new ListenerConn.  Use NewListener instead.
+func NewListenerConn(name string, notificationChan chan<- *Notification) (*ListenerConn, error) {
+	cn, err := Open(name)
+	if err != nil {
+		return nil, err
+	}
+
+	l := &ListenerConn{
+		cn:               cn.(*conn),
+		notificationChan: notificationChan,
+		connState:        connStateIdle,
+		replyChan:        make(chan message, 2),
+	}
+
+	go l.listenerConnMain()
+
+	return l, nil
+}
+
+// We can only allow one goroutine at a time to be running a query on the
+// connection for various reasons, so the goroutine sending on the connection
+// must be holding senderLock.
+//
+// Returns an error if an unrecoverable error has occurred and the ListenerConn
+// should be abandoned.
+func (l *ListenerConn) acquireSenderLock() error {
+	// we must acquire senderLock first to avoid deadlocks; see ExecSimpleQuery
+	l.senderLock.Lock()
+
+	l.connectionLock.Lock()
+	err := l.err
+	l.connectionLock.Unlock()
+	if err != nil {
+		l.senderLock.Unlock()
+		return err
+	}
+	return nil
+}
+
+func (l *ListenerConn) releaseSenderLock() {
+	l.senderLock.Unlock()
+}
+
+// setState advances the protocol state to newState.  Returns false if moving
+// to that state from the current state is not allowed.
+func (l *ListenerConn) setState(newState int32) bool {
+	var expectedState int32
+
+	switch newState {
+	case connStateIdle:
+		expectedState = connStateExpectReadyForQuery
+	case connStateExpectResponse:
+		expectedState = connStateIdle
+	case connStateExpectReadyForQuery:
+		expectedState = connStateExpectResponse
+	default:
+		panic(fmt.Sprintf("unexpected listenerConnState %d", newState))
+	}
+
+	return atomic.CompareAndSwapInt32(&l.connState, expectedState, newState)
+}
+
+// Main logic is here: receive messages from the postgres backend, forward
+// notifications and query replies and keep the internal state in sync with the
+// protocol state.  Returns when the connection has been lost, is about to go
+// away or should be discarded because we couldn't agree on the state with the
+// server backend.
+func (l *ListenerConn) listenerConnLoop() (err error) {
+	defer errRecoverNoErrBadConn(&err)
+
+	r := &readBuf{}
+	for {
+		t, err := l.cn.recvMessage(r)
+		if err != nil {
+			return err
+		}
+
+		switch t {
+		case 'A':
+			// recvNotification copies all the data so we don't need to worry
+			// about the scratch buffer being overwritten.
+			l.notificationChan <- recvNotification(r)
+
+		case 'T', 'D':
+			// only used by tests; ignore
+
+		case 'E':
+			// We might receive an ErrorResponse even when not in a query; it
+			// is expected that the server will close the connection after
+			// that, but we should make sure that the error we display is the
+			// one from the stray ErrorResponse, not io.ErrUnexpectedEOF.
+			if !l.setState(connStateExpectReadyForQuery) {
+				return parseError(r)
+			}
+			l.replyChan <- message{t, parseError(r)}
+
+		case 'C', 'I':
+			if !l.setState(connStateExpectReadyForQuery) {
+				// protocol out of sync
+				return fmt.Errorf("unexpected CommandComplete")
+			}
+			// ExecSimpleQuery doesn't need to know about this message
+
+		case 'Z':
+			if !l.setState(connStateIdle) {
+				// protocol out of sync
+				return fmt.Errorf("unexpected ReadyForQuery")
+			}
+			l.replyChan <- message{t, nil}
+
+		case 'N', 'S':
+			// ignore
+		default:
+			return fmt.Errorf("unexpected message %q from server in listenerConnLoop", t)
+		}
+	}
+}
+
+// This is the main routine for the goroutine receiving on the database
+// connection.  Most of the main logic is in listenerConnLoop.
+func (l *ListenerConn) listenerConnMain() {
+	err := l.listenerConnLoop()
+
+	// listenerConnLoop terminated; we're done, but we still have to clean up.
+	// Make sure nobody tries to start any new queries by making sure the err
+	// pointer is set.  It is important that we do not overwrite its value; a
+	// connection could be closed by either this goroutine or one sending on
+	// the connection -- whoever closes the connection is assumed to have the
+	// more meaningful error message (as the other one will probably get
+	// net.errClosed), so that goroutine sets the error we expose while the
+	// other error is discarded.  If the connection is lost while two
+	// goroutines are operating on the socket, it probably doesn't matter which
+	// error we expose so we don't try to do anything more complex.
+	l.connectionLock.Lock()
+	if l.err == nil {
+		l.err = err
+	}
+	l.cn.Close()
+	l.connectionLock.Unlock()
+
+	// There might be a query in-flight; make sure nobody's waiting for a
+	// response to it, since there's not going to be one.
+	close(l.replyChan)
+
+	// let the listener know we're done
+	close(l.notificationChan)
+
+	// this ListenerConn is done
+}
+
+// Send a LISTEN query to the server.  See ExecSimpleQuery.
+func (l *ListenerConn) Listen(channel string) (bool, error) {
+	return l.ExecSimpleQuery("LISTEN " + QuoteIdentifier(channel))
+}
+
+// Send an UNLISTEN query to the server.  See ExecSimpleQuery.
+func (l *ListenerConn) Unlisten(channel string) (bool, error) {
+	return l.ExecSimpleQuery("UNLISTEN " + QuoteIdentifier(channel))
+}
+
+// Send `UNLISTEN *` to the server.  See ExecSimpleQuery.
+func (l *ListenerConn) UnlistenAll() (bool, error) {
+	return l.ExecSimpleQuery("UNLISTEN *")
+}
+
+// Ping the remote server to make sure it's alive.  Non-nil error means the
+// connection has failed and should be abandoned.
+func (l *ListenerConn) Ping() error {
+	sent, err := l.ExecSimpleQuery("")
+	if !sent {
+		return err
+	}
+	if err != nil {
+		// shouldn't happen
+		panic(err)
+	}
+	return nil
+}
+
+// Attempt to send a query on the connection.  Returns an error if sending the
+// query failed, and the caller should initiate closure of this connection.
+// The caller must be holding senderLock (see acquireSenderLock and
+// releaseSenderLock).
+func (l *ListenerConn) sendSimpleQuery(q string) (err error) {
+	defer errRecoverNoErrBadConn(&err)
+
+	// must set connection state before sending the query
+	if !l.setState(connStateExpectResponse) {
+		panic("two queries running at the same time")
+	}
+
+	// Can't use l.cn.writeBuf here because it uses the scratch buffer which
+	// might get overwritten by listenerConnLoop.
+	b := &writeBuf{
+		buf: []byte("Q\x00\x00\x00\x00"),
+		pos: 1,
+	}
+	b.string(q)
+	l.cn.send(b)
+
+	return nil
+}
+
+// Execute a "simple query" (i.e. one with no bindable parameters) on the
+// connection.  The possible return values are:
+//   1) "executed" is true; the query was executed to completion on the
+//      database server.  If the query failed, err will be set to the error
+//      returned by the database, otherwise err will be nil.
+//   2) If "executed" is false, the query could not be executed on the remote
+//      server.  err will be non-nil.
+//
+// After a call to ExecSimpleQuery has returned an executed=false value, the
+// connection has either been closed or will be closed shortly thereafter, and
+// all subsequently executed queries will return an error.
+func (l *ListenerConn) ExecSimpleQuery(q string) (executed bool, err error) {
+	if err = l.acquireSenderLock(); err != nil {
+		return false, err
+	}
+	defer l.releaseSenderLock()
+
+	err = l.sendSimpleQuery(q)
+	if err != nil {
+		// We can't know what state the protocol is in, so we need to abandon
+		// this connection.
+		l.connectionLock.Lock()
+		// Set the error pointer if it hasn't been set already; see
+		// listenerConnMain.
+		if l.err == nil {
+			l.err = err
+		}
+		l.connectionLock.Unlock()
+		l.cn.c.Close()
+		return false, err
+	}
+
+	// now we just wait for a reply..
+	for {
+		m, ok := <-l.replyChan
+		if !ok {
+			// We lost the connection to server, don't bother waiting for a
+			// a response.  err should have been set already.
+			l.connectionLock.Lock()
+			err := l.err
+			l.connectionLock.Unlock()
+			return false, err
+		}
+		switch m.typ {
+		case 'Z':
+			// sanity check
+			if m.err != nil {
+				panic("m.err != nil")
+			}
+			// done; err might or might not be set
+			return true, err
+
+		case 'E':
+			// sanity check
+			if m.err == nil {
+				panic("m.err == nil")
+			}
+			// server responded with an error; ReadyForQuery to follow
+			err = m.err
+
+		default:
+			return false, fmt.Errorf("unknown response for simple query: %q", m.typ)
+		}
+	}
+}
+
+func (l *ListenerConn) Close() error {
+	l.connectionLock.Lock()
+	if l.err != nil {
+		l.connectionLock.Unlock()
+		return errListenerConnClosed
+	}
+	l.err = errListenerConnClosed
+	l.connectionLock.Unlock()
+	// We can't send anything on the connection without holding senderLock.
+	// Simply close the net.Conn to wake up everyone operating on it.
+	return l.cn.c.Close()
+}
+
+// Err() returns the reason the connection was closed.  It is not safe to call
+// this function until l.Notify has been closed.
+func (l *ListenerConn) Err() error {
+	return l.err
+}
+
+var errListenerClosed = errors.New("pq: Listener has been closed")
+
+var ErrChannelAlreadyOpen = errors.New("pq: channel is already open")
+var ErrChannelNotOpen = errors.New("pq: channel is not open")
+
+type ListenerEventType int
+
+const (
+	// Emitted only when the database connection has been initially
+	// initialized.  err will always be nil.
+	ListenerEventConnected ListenerEventType = iota
+
+	// Emitted after a database connection has been lost, either because of an
+	// error or because Close has been called.  err will be set to the reason
+	// the database connection was lost.
+	ListenerEventDisconnected
+
+	// Emitted after a database connection has been re-established after
+	// connection loss.  err will always be nil.  After this event has been
+	// emitted, a nil pq.Notification is sent on the Listener.Notify channel.
+	ListenerEventReconnected
+
+	// Emitted after a connection to the database was attempted, but failed.
+	// err will be set to an error describing why the connection attempt did
+	// not succeed.
+	ListenerEventConnectionAttemptFailed
+)
+
+type EventCallbackType func(event ListenerEventType, err error)
+
+// Listener provides an interface for listening to notifications from a
+// PostgreSQL database.  For general usage information, see section
+// "Notifications".
+//
+// Listener can safely be used from concurrently running goroutines.
+type Listener struct {
+	// Channel for receiving notifications from the database.  In some cases a
+	// nil value will be sent.  See section "Notifications" above.
+	Notify chan *Notification
+
+	name                 string
+	minReconnectInterval time.Duration
+	maxReconnectInterval time.Duration
+	eventCallback        EventCallbackType
+
+	lock                 sync.Mutex
+	isClosed             bool
+	reconnectCond        *sync.Cond
+	cn                   *ListenerConn
+	connNotificationChan <-chan *Notification
+	channels             map[string]struct{}
+}
+
+// NewListener creates a new database connection dedicated to LISTEN / NOTIFY.
+//
+// name should be set to a connection string to be used to establish the
+// database connection (see section "Connection String Parameters" above).
+//
+// minReconnectInterval controls the duration to wait before trying to
+// re-establish the database connection after connection loss.  After each
+// consecutive failure this interval is doubled, until maxReconnectInterval is
+// reached.  Successfully completing the connection establishment procedure
+// resets the interval back to minReconnectInterval.
+//
+// The last parameter eventCallback can be set to a function which will be
+// called by the Listener when the state of the underlying database connection
+// changes.  This callback will be called by the goroutine which dispatches the
+// notifications over the Notify channel, so you should try to avoid doing
+// potentially time-consuming operations from the callback.
+func NewListener(name string,
+	minReconnectInterval time.Duration,
+	maxReconnectInterval time.Duration,
+	eventCallback EventCallbackType) *Listener {
+	l := &Listener{
+		name:                 name,
+		minReconnectInterval: minReconnectInterval,
+		maxReconnectInterval: maxReconnectInterval,
+		eventCallback:        eventCallback,
+
+		channels: make(map[string]struct{}),
+
+		Notify: make(chan *Notification, 32),
+	}
+	l.reconnectCond = sync.NewCond(&l.lock)
+
+	go l.listenerMain()
+
+	return l
+}
+
+// Returns the notification channel for this listener.  This is the same
+// channel as Notify, and will not be recreated during the life time of the
+// Listener.
+func (l *Listener) NotificationChannel() <-chan *Notification {
+	return l.Notify
+}
+
+// Listen starts listening for notifications on a channel.  Calls to this
+// function will block until an acknowledgement has been received from the
+// server.  Note that Listener automatically re-establishes the connection
+// after connection loss, so this function may block indefinitely if the
+// connection can not be re-established.
+//
+// Listen will only fail in three conditions:
+//   1) The channel is already open.  The returned error will be
+//      ErrChannelAlreadyOpen.
+//   2) The query was executed on the remote server, but PostgreSQL returned an
+//      error message in response to the query.  The returned error will be a
+//      pq.Error containing the information the server supplied.
+//   3) Close is called on the Listener before the request could be completed.
+//
+// The channel name is case-sensitive.
+func (l *Listener) Listen(channel string) error {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	if l.isClosed {
+		return errListenerClosed
+	}
+
+	// The server allows you to issue a LISTEN on a channel which is already
+	// open, but it seems useful to be able to detect this case to spot for
+	// mistakes in application logic.  If the application genuinely does't
+	// care, it can check the exported error and ignore it.
+	_, exists := l.channels[channel]
+	if exists {
+		return ErrChannelAlreadyOpen
+	}
+
+	if l.cn != nil {
+		// If gotResponse is true but error is set, the query was executed on
+		// the remote server, but resulted in an error.  This should be
+		// relatively rare, so it's fine if we just pass the error to our
+		// caller.  However, if gotResponse is false, we could not complete the
+		// query on the remote server and our underlying connection is about
+		// to go away, so we only add relname to l.channels, and wait for
+		// resync() to take care of the rest.
+		gotResponse, err := l.cn.Listen(channel)
+		if gotResponse && err != nil {
+			return err
+		}
+	}
+
+	l.channels[channel] = struct{}{}
+	for l.cn == nil {
+		l.reconnectCond.Wait()
+		// we let go of the mutex for a while
+		if l.isClosed {
+			return errListenerClosed
+		}
+	}
+
+	return nil
+}
+
+// Unlisten removes a channel from the Listener's channel list.  Returns
+// ErrChannelNotOpen if the Listener is not listening on the specified channel.
+// Returns immediately with no error if there is no connection.  Note that you
+// might still get notifications for this channel even after Unlisten has
+// returned.
+//
+// The channel name is case-sensitive.
+func (l *Listener) Unlisten(channel string) error {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	if l.isClosed {
+		return errListenerClosed
+	}
+
+	// Similarly to LISTEN, this is not an error in Postgres, but it seems
+	// useful to distinguish from the normal conditions.
+	_, exists := l.channels[channel]
+	if !exists {
+		return ErrChannelNotOpen
+	}
+
+	if l.cn != nil {
+		// Similarly to Listen (see comment in that function), the caller
+		// should only be bothered with an error if it came from the backend as
+		// a response to our query.
+		gotResponse, err := l.cn.Unlisten(channel)
+		if gotResponse && err != nil {
+			return err
+		}
+	}
+
+	// Don't bother waiting for resync if there's no connection.
+	delete(l.channels, channel)
+	return nil
+}
+
+// UnlistenAll removes all channels from the Listener's channel list.  Returns
+// immediately with no error if there is no connection.  Note that you might
+// still get notifications for any of the deleted channels even after
+// UnlistenAll has returned.
+func (l *Listener) UnlistenAll() error {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	if l.isClosed {
+		return errListenerClosed
+	}
+
+	if l.cn != nil {
+		// Similarly to Listen (see comment in that function), the caller
+		// should only be bothered with an error if it came from the backend as
+		// a response to our query.
+		gotResponse, err := l.cn.UnlistenAll()
+		if gotResponse && err != nil {
+			return err
+		}
+	}
+
+	// Don't bother waiting for resync if there's no connection.
+	l.channels = make(map[string]struct{})
+	return nil
+}
+
+// Ping the remote server to make sure it's alive.  Non-nil return value means
+// that there is no active connection.
+func (l *Listener) Ping() error {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	if l.isClosed {
+		return errListenerClosed
+	}
+	if l.cn == nil {
+		return errors.New("no connection")
+	}
+
+	return l.cn.Ping()
+}
+
+// Clean up after losing the server connection.  Returns l.cn.Err(), which
+// should have the reason the connection was lost.
+func (l *Listener) disconnectCleanup() error {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	// sanity check; can't look at Err() until the channel has been closed
+	select {
+	case _, ok := <-l.connNotificationChan:
+		if ok {
+			panic("connNotificationChan not closed")
+		}
+	default:
+		panic("connNotificationChan not closed")
+	}
+
+	err := l.cn.Err()
+	l.cn.Close()
+	l.cn = nil
+	return err
+}
+
+// Synchronize the list of channels we want to be listening on with the server
+// after the connection has been established.
+func (l *Listener) resync(cn *ListenerConn, notificationChan <-chan *Notification) error {
+	doneChan := make(chan error)
+	go func() {
+		for channel := range l.channels {
+			// If we got a response, return that error to our caller as it's
+			// going to be more descriptive than cn.Err().
+			gotResponse, err := cn.Listen(channel)
+			if gotResponse && err != nil {
+				doneChan <- err
+				return
+			}
+
+			// If we couldn't reach the server, wait for notificationChan to
+			// close and then return the error message from the connection, as
+			// per ListenerConn's interface.
+			if err != nil {
+				for _ = range notificationChan {
+				}
+				doneChan <- cn.Err()
+				return
+			}
+		}
+		doneChan <- nil
+	}()
+
+	// Ignore notifications while synchronization is going on to avoid
+	// deadlocks.  We have to send a nil notification over Notify anyway as
+	// we can't possibly know which notifications (if any) were lost while
+	// the connection was down, so there's no reason to try and process
+	// these messages at all.
+	for {
+		select {
+		case _, ok := <-notificationChan:
+			if !ok {
+				notificationChan = nil
+			}
+
+		case err := <-doneChan:
+			return err
+		}
+	}
+}
+
+// caller should NOT be holding l.lock
+func (l *Listener) closed() bool {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	return l.isClosed
+}
+
+func (l *Listener) connect() error {
+	notificationChan := make(chan *Notification, 32)
+	cn, err := NewListenerConn(l.name, notificationChan)
+	if err != nil {
+		return err
+	}
+
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	err = l.resync(cn, notificationChan)
+	if err != nil {
+		cn.Close()
+		return err
+	}
+
+	l.cn = cn
+	l.connNotificationChan = notificationChan
+	l.reconnectCond.Broadcast()
+
+	return nil
+}
+
+// Close disconnects the Listener from the database and shuts it down.
+// Subsequent calls to its methods will return an error.  Close returns an
+// error if the connection has already been closed.
+func (l *Listener) Close() error {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+
+	if l.isClosed {
+		return errListenerClosed
+	}
+
+	if l.cn != nil {
+		l.cn.Close()
+	}
+	l.isClosed = true
+
+	return nil
+}
+
+func (l *Listener) emitEvent(event ListenerEventType, err error) {
+	if l.eventCallback != nil {
+		l.eventCallback(event, err)
+	}
+}
+
+// Main logic here: maintain a connection to the server when possible, wait
+// for notifications and emit events.
+func (l *Listener) listenerConnLoop() {
+	var nextReconnect time.Time
+
+	reconnectInterval := l.minReconnectInterval
+	for {
+		for {
+			err := l.connect()
+			if err == nil {
+				break
+			}
+
+			if l.closed() {
+				return
+			}
+			l.emitEvent(ListenerEventConnectionAttemptFailed, err)
+
+			time.Sleep(reconnectInterval)
+			reconnectInterval *= 2
+			if reconnectInterval > l.maxReconnectInterval {
+				reconnectInterval = l.maxReconnectInterval
+			}
+		}
+
+		if nextReconnect.IsZero() {
+			l.emitEvent(ListenerEventConnected, nil)
+		} else {
+			l.emitEvent(ListenerEventReconnected, nil)
+			l.Notify <- nil
+		}
+
+		reconnectInterval = l.minReconnectInterval
+		nextReconnect = time.Now().Add(reconnectInterval)
+
+		for {
+			notification, ok := <-l.connNotificationChan
+			if !ok {
+				// lost connection, loop again
+				break
+			}
+			l.Notify <- notification
+		}
+
+		err := l.disconnectCleanup()
+		if l.closed() {
+			return
+		}
+		l.emitEvent(ListenerEventDisconnected, err)
+
+		time.Sleep(nextReconnect.Sub(time.Now()))
+	}
+}
+
+func (l *Listener) listenerMain() {
+	l.listenerConnLoop()
+	close(l.Notify)
+}
diff --git a/vendor/github.com/lib/pq/oid/doc.go b/vendor/github.com/lib/pq/oid/doc.go
new file mode 100644
index 00000000..caaede24
--- /dev/null
+++ b/vendor/github.com/lib/pq/oid/doc.go
@@ -0,0 +1,6 @@
+// Package oid contains OID constants
+// as defined by the Postgres server.
+package oid
+
+// Oid is a Postgres Object ID.
+type Oid uint32
diff --git a/vendor/github.com/lib/pq/oid/gen.go b/vendor/github.com/lib/pq/oid/gen.go
new file mode 100644
index 00000000..cd4aea80
--- /dev/null
+++ b/vendor/github.com/lib/pq/oid/gen.go
@@ -0,0 +1,74 @@
+// +build ignore
+
+// Generate the table of OID values
+// Run with 'go run gen.go'.
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+
+	_ "github.com/lib/pq"
+)
+
+func main() {
+	datname := os.Getenv("PGDATABASE")
+	sslmode := os.Getenv("PGSSLMODE")
+
+	if datname == "" {
+		os.Setenv("PGDATABASE", "pqgotest")
+	}
+
+	if sslmode == "" {
+		os.Setenv("PGSSLMODE", "disable")
+	}
+
+	db, err := sql.Open("postgres", "")
+	if err != nil {
+		log.Fatal(err)
+	}
+	cmd := exec.Command("gofmt")
+	cmd.Stderr = os.Stderr
+	w, err := cmd.StdinPipe()
+	if err != nil {
+		log.Fatal(err)
+	}
+	f, err := os.Create("types.go")
+	if err != nil {
+		log.Fatal(err)
+	}
+	cmd.Stdout = f
+	err = cmd.Start()
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Fprintln(w, "// generated by 'go run gen.go'; do not edit")
+	fmt.Fprintln(w, "\npackage oid")
+	fmt.Fprintln(w, "const (")
+	rows, err := db.Query(`
+		SELECT typname, oid
+		FROM pg_type WHERE oid < 10000
+		ORDER BY oid;
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var name string
+	var oid int
+	for rows.Next() {
+		err = rows.Scan(&name, &oid)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Fprintf(w, "T_%s Oid = %d\n", name, oid)
+	}
+	if err = rows.Err(); err != nil {
+		log.Fatal(err)
+	}
+	fmt.Fprintln(w, ")")
+	w.Close()
+	cmd.Wait()
+}
diff --git a/vendor/github.com/lib/pq/oid/types.go b/vendor/github.com/lib/pq/oid/types.go
new file mode 100644
index 00000000..03df05a6
--- /dev/null
+++ b/vendor/github.com/lib/pq/oid/types.go
@@ -0,0 +1,161 @@
+// generated by 'go run gen.go'; do not edit
+
+package oid
+
+const (
+	T_bool             Oid = 16
+	T_bytea            Oid = 17
+	T_char             Oid = 18
+	T_name             Oid = 19
+	T_int8             Oid = 20
+	T_int2             Oid = 21
+	T_int2vector       Oid = 22
+	T_int4             Oid = 23
+	T_regproc          Oid = 24
+	T_text             Oid = 25
+	T_oid              Oid = 26
+	T_tid              Oid = 27
+	T_xid              Oid = 28
+	T_cid              Oid = 29
+	T_oidvector        Oid = 30
+	T_pg_type          Oid = 71
+	T_pg_attribute     Oid = 75
+	T_pg_proc          Oid = 81
+	T_pg_class         Oid = 83
+	T_json             Oid = 114
+	T_xml              Oid = 142
+	T__xml             Oid = 143
+	T_pg_node_tree     Oid = 194
+	T__json            Oid = 199
+	T_smgr             Oid = 210
+	T_point            Oid = 600
+	T_lseg             Oid = 601
+	T_path             Oid = 602
+	T_box              Oid = 603
+	T_polygon          Oid = 604
+	T_line             Oid = 628
+	T__line            Oid = 629
+	T_cidr             Oid = 650
+	T__cidr            Oid = 651
+	T_float4           Oid = 700
+	T_float8           Oid = 701
+	T_abstime          Oid = 702
+	T_reltime          Oid = 703
+	T_tinterval        Oid = 704
+	T_unknown          Oid = 705
+	T_circle           Oid = 718
+	T__circle          Oid = 719
+	T_money            Oid = 790
+	T__money           Oid = 791
+	T_macaddr          Oid = 829
+	T_inet             Oid = 869
+	T__bool            Oid = 1000
+	T__bytea           Oid = 1001
+	T__char            Oid = 1002
+	T__name            Oid = 1003
+	T__int2            Oid = 1005
+	T__int2vector      Oid = 1006
+	T__int4            Oid = 1007
+	T__regproc         Oid = 1008
+	T__text            Oid = 1009
+	T__tid             Oid = 1010
+	T__xid             Oid = 1011
+	T__cid             Oid = 1012
+	T__oidvector       Oid = 1013
+	T__bpchar          Oid = 1014
+	T__varchar         Oid = 1015
+	T__int8            Oid = 1016
+	T__point           Oid = 1017
+	T__lseg            Oid = 1018
+	T__path            Oid = 1019
+	T__box             Oid = 1020
+	T__float4          Oid = 1021
+	T__float8          Oid = 1022
+	T__abstime         Oid = 1023
+	T__reltime         Oid = 1024
+	T__tinterval       Oid = 1025
+	T__polygon         Oid = 1027
+	T__oid             Oid = 1028
+	T_aclitem          Oid = 1033
+	T__aclitem         Oid = 1034
+	T__macaddr         Oid = 1040
+	T__inet            Oid = 1041
+	T_bpchar           Oid = 1042
+	T_varchar          Oid = 1043
+	T_date             Oid = 1082
+	T_time             Oid = 1083
+	T_timestamp        Oid = 1114
+	T__timestamp       Oid = 1115
+	T__date            Oid = 1182
+	T__time            Oid = 1183
+	T_timestamptz      Oid = 1184
+	T__timestamptz     Oid = 1185
+	T_interval         Oid = 1186
+	T__interval        Oid = 1187
+	T__numeric         Oid = 1231
+	T_pg_database      Oid = 1248
+	T__cstring         Oid = 1263
+	T_timetz           Oid = 1266
+	T__timetz          Oid = 1270
+	T_bit              Oid = 1560
+	T__bit             Oid = 1561
+	T_varbit           Oid = 1562
+	T__varbit          Oid = 1563
+	T_numeric          Oid = 1700
+	T_refcursor        Oid = 1790
+	T__refcursor       Oid = 2201
+	T_regprocedure     Oid = 2202
+	T_regoper          Oid = 2203
+	T_regoperator      Oid = 2204
+	T_regclass         Oid = 2205
+	T_regtype          Oid = 2206
+	T__regprocedure    Oid = 2207
+	T__regoper         Oid = 2208
+	T__regoperator     Oid = 2209
+	T__regclass        Oid = 2210
+	T__regtype         Oid = 2211
+	T_record           Oid = 2249
+	T_cstring          Oid = 2275
+	T_any              Oid = 2276
+	T_anyarray         Oid = 2277
+	T_void             Oid = 2278
+	T_trigger          Oid = 2279
+	T_language_handler Oid = 2280
+	T_internal         Oid = 2281
+	T_opaque           Oid = 2282
+	T_anyelement       Oid = 2283
+	T__record          Oid = 2287
+	T_anynonarray      Oid = 2776
+	T_pg_authid        Oid = 2842
+	T_pg_auth_members  Oid = 2843
+	T__txid_snapshot   Oid = 2949
+	T_uuid             Oid = 2950
+	T__uuid            Oid = 2951
+	T_txid_snapshot    Oid = 2970
+	T_fdw_handler      Oid = 3115
+	T_anyenum          Oid = 3500
+	T_tsvector         Oid = 3614
+	T_tsquery          Oid = 3615
+	T_gtsvector        Oid = 3642
+	T__tsvector        Oid = 3643
+	T__gtsvector       Oid = 3644
+	T__tsquery         Oid = 3645
+	T_regconfig        Oid = 3734
+	T__regconfig       Oid = 3735
+	T_regdictionary    Oid = 3769
+	T__regdictionary   Oid = 3770
+	T_anyrange         Oid = 3831
+	T_event_trigger    Oid = 3838
+	T_int4range        Oid = 3904
+	T__int4range       Oid = 3905
+	T_numrange         Oid = 3906
+	T__numrange        Oid = 3907
+	T_tsrange          Oid = 3908
+	T__tsrange         Oid = 3909
+	T_tstzrange        Oid = 3910
+	T__tstzrange       Oid = 3911
+	T_daterange        Oid = 3912
+	T__daterange       Oid = 3913
+	T_int8range        Oid = 3926
+	T__int8range       Oid = 3927
+)
diff --git a/vendor/github.com/lib/pq/url.go b/vendor/github.com/lib/pq/url.go
new file mode 100644
index 00000000..9bac95c4
--- /dev/null
+++ b/vendor/github.com/lib/pq/url.go
@@ -0,0 +1,76 @@
+package pq
+
+import (
+	"fmt"
+	nurl "net/url"
+	"sort"
+	"strings"
+)
+
+// ParseURL no longer needs to be used by clients of this library since supplying a URL as a
+// connection string to sql.Open() is now supported:
+//
+//	sql.Open("postgres", "postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full")
+//
+// It remains exported here for backwards-compatibility.
+//
+// ParseURL converts a url to a connection string for driver.Open.
+// Example:
+//
+//	"postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full"
+//
+// converts to:
+//
+//	"user=bob password=secret host=1.2.3.4 port=5432 dbname=mydb sslmode=verify-full"
+//
+// A minimal example:
+//
+//	"postgres://"
+//
+// This will be blank, causing driver.Open to use all of the defaults
+func ParseURL(url string) (string, error) {
+	u, err := nurl.Parse(url)
+	if err != nil {
+		return "", err
+	}
+
+	if u.Scheme != "postgres" && u.Scheme != "postgresql" {
+		return "", fmt.Errorf("invalid connection protocol: %s", u.Scheme)
+	}
+
+	var kvs []string
+	escaper := strings.NewReplacer(` `, `\ `, `'`, `\'`, `\`, `\\`)
+	accrue := func(k, v string) {
+		if v != "" {
+			kvs = append(kvs, k+"="+escaper.Replace(v))
+		}
+	}
+
+	if u.User != nil {
+		v := u.User.Username()
+		accrue("user", v)
+
+		v, _ = u.User.Password()
+		accrue("password", v)
+	}
+
+	i := strings.Index(u.Host, ":")
+	if i < 0 {
+		accrue("host", u.Host)
+	} else {
+		accrue("host", u.Host[:i])
+		accrue("port", u.Host[i+1:])
+	}
+
+	if u.Path != "" {
+		accrue("dbname", u.Path[1:])
+	}
+
+	q := u.Query()
+	for k := range q {
+		accrue(k, q.Get(k))
+	}
+
+	sort.Strings(kvs) // Makes testing easier (not a performance concern)
+	return strings.Join(kvs, " "), nil
+}
diff --git a/vendor/github.com/lib/pq/user_posix.go b/vendor/github.com/lib/pq/user_posix.go
new file mode 100644
index 00000000..e937d7d0
--- /dev/null
+++ b/vendor/github.com/lib/pq/user_posix.go
@@ -0,0 +1,24 @@
+// Package pq is a pure Go Postgres driver for the database/sql package.
+
+// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+
+package pq
+
+import (
+	"os"
+	"os/user"
+)
+
+func userCurrent() (string, error) {
+	u, err := user.Current()
+	if err == nil {
+		return u.Username, nil
+	}
+
+	name := os.Getenv("USER")
+	if name != "" {
+		return name, nil
+	}
+
+	return "", ErrCouldNotDetectUsername
+}
diff --git a/vendor/github.com/lib/pq/user_windows.go b/vendor/github.com/lib/pq/user_windows.go
new file mode 100644
index 00000000..2b691267
--- /dev/null
+++ b/vendor/github.com/lib/pq/user_windows.go
@@ -0,0 +1,27 @@
+// Package pq is a pure Go Postgres driver for the database/sql package.
+package pq
+
+import (
+	"path/filepath"
+	"syscall"
+)
+
+// Perform Windows user name lookup identically to libpq.
+//
+// The PostgreSQL code makes use of the legacy Win32 function
+// GetUserName, and that function has not been imported into stock Go.
+// GetUserNameEx is available though, the difference being that a
+// wider range of names are available.  To get the output to be the
+// same as GetUserName, only the base (or last) component of the
+// result is returned.
+func userCurrent() (string, error) {
+	pw_name := make([]uint16, 128)
+	pwname_size := uint32(len(pw_name)) - 1
+	err := syscall.GetUserNameEx(syscall.NameSamCompatible, &pw_name[0], &pwname_size)
+	if err != nil {
+		return "", ErrCouldNotDetectUsername
+	}
+	s := syscall.UTF16ToString(pw_name)
+	u := filepath.Base(s)
+	return u, nil
+}
diff --git a/vendor/github.com/pborman/uuid/CONTRIBUTORS b/vendor/github.com/pborman/uuid/CONTRIBUTORS
new file mode 100644
index 00000000..b382a04e
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/CONTRIBUTORS
@@ -0,0 +1 @@
+Paul Borman <borman@google.com>
diff --git a/vendor/github.com/pborman/uuid/LICENSE b/vendor/github.com/pborman/uuid/LICENSE
new file mode 100644
index 00000000..5dc68268
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009,2014 Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/pborman/uuid/dce.go b/vendor/github.com/pborman/uuid/dce.go
new file mode 100644
index 00000000..50a0f2d0
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/dce.go
@@ -0,0 +1,84 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+)
+
+// A Domain represents a Version 2 domain
+type Domain byte
+
+// Domain constants for DCE Security (Version 2) UUIDs.
+const (
+	Person = Domain(0)
+	Group  = Domain(1)
+	Org    = Domain(2)
+)
+
+// NewDCESecurity returns a DCE Security (Version 2) UUID.
+//
+// The domain should be one of Person, Group or Org.
+// On a POSIX system the id should be the users UID for the Person
+// domain and the users GID for the Group.  The meaning of id for
+// the domain Org or on non-POSIX systems is site defined.
+//
+// For a given domain/id pair the same token may be returned for up to
+// 7 minutes and 10 seconds.
+func NewDCESecurity(domain Domain, id uint32) UUID {
+	uuid := NewUUID()
+	if uuid != nil {
+		uuid[6] = (uuid[6] & 0x0f) | 0x20 // Version 2
+		uuid[9] = byte(domain)
+		binary.BigEndian.PutUint32(uuid[0:], id)
+	}
+	return uuid
+}
+
+// NewDCEPerson returns a DCE Security (Version 2) UUID in the person
+// domain with the id returned by os.Getuid.
+//
+//  NewDCEPerson(Person, uint32(os.Getuid()))
+func NewDCEPerson() UUID {
+	return NewDCESecurity(Person, uint32(os.Getuid()))
+}
+
+// NewDCEGroup returns a DCE Security (Version 2) UUID in the group
+// domain with the id returned by os.Getgid.
+//
+//  NewDCEGroup(Group, uint32(os.Getgid()))
+func NewDCEGroup() UUID {
+	return NewDCESecurity(Group, uint32(os.Getgid()))
+}
+
+// Domain returns the domain for a Version 2 UUID or false.
+func (uuid UUID) Domain() (Domain, bool) {
+	if v, _ := uuid.Version(); v != 2 {
+		return 0, false
+	}
+	return Domain(uuid[9]), true
+}
+
+// Id returns the id for a Version 2 UUID or false.
+func (uuid UUID) Id() (uint32, bool) {
+	if v, _ := uuid.Version(); v != 2 {
+		return 0, false
+	}
+	return binary.BigEndian.Uint32(uuid[0:4]), true
+}
+
+func (d Domain) String() string {
+	switch d {
+	case Person:
+		return "Person"
+	case Group:
+		return "Group"
+	case Org:
+		return "Org"
+	}
+	return fmt.Sprintf("Domain%d", int(d))
+}
diff --git a/vendor/github.com/pborman/uuid/doc.go b/vendor/github.com/pborman/uuid/doc.go
new file mode 100644
index 00000000..d8bd013e
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/doc.go
@@ -0,0 +1,8 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The uuid package generates and inspects UUIDs.
+//
+// UUIDs are based on RFC 4122 and DCE 1.1: Authentication and Security Services.
+package uuid
diff --git a/vendor/github.com/pborman/uuid/hash.go b/vendor/github.com/pborman/uuid/hash.go
new file mode 100644
index 00000000..cdd4192f
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/hash.go
@@ -0,0 +1,53 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"crypto/md5"
+	"crypto/sha1"
+	"hash"
+)
+
+// Well known Name Space IDs and UUIDs
+var (
+	NameSpace_DNS  = Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+	NameSpace_URL  = Parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+	NameSpace_OID  = Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
+	NameSpace_X500 = Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
+	NIL            = Parse("00000000-0000-0000-0000-000000000000")
+)
+
+// NewHash returns a new UUID dervied from the hash of space concatenated with
+// data generated by h.  The hash should be at least 16 byte in length.  The
+// first 16 bytes of the hash are used to form the UUID.  The version of the
+// UUID will be the lower 4 bits of version.  NewHash is used to implement
+// NewMD5 and NewSHA1.
+func NewHash(h hash.Hash, space UUID, data []byte, version int) UUID {
+	h.Reset()
+	h.Write(space)
+	h.Write([]byte(data))
+	s := h.Sum(nil)
+	uuid := make([]byte, 16)
+	copy(uuid, s)
+	uuid[6] = (uuid[6] & 0x0f) | uint8((version&0xf)<<4)
+	uuid[8] = (uuid[8] & 0x3f) | 0x80 // RFC 4122 variant
+	return uuid
+}
+
+// NewMD5 returns a new MD5 (Version 3) UUID based on the
+// supplied name space and data.
+//
+//  NewHash(md5.New(), space, data, 3)
+func NewMD5(space UUID, data []byte) UUID {
+	return NewHash(md5.New(), space, data, 3)
+}
+
+// NewSHA1 returns a new SHA1 (Version 5) UUID based on the
+// supplied name space and data.
+//
+//  NewHash(sha1.New(), space, data, 5)
+func NewSHA1(space UUID, data []byte) UUID {
+	return NewHash(sha1.New(), space, data, 5)
+}
diff --git a/vendor/github.com/pborman/uuid/json.go b/vendor/github.com/pborman/uuid/json.go
new file mode 100644
index 00000000..760580a5
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/json.go
@@ -0,0 +1,30 @@
+// Copyright 2014 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "errors"
+
+func (u UUID) MarshalJSON() ([]byte, error) {
+	if len(u) == 0 {
+		return []byte(`""`), nil
+	}
+	return []byte(`"` + u.String() + `"`), nil
+}
+
+func (u *UUID) UnmarshalJSON(data []byte) error {
+	if len(data) == 0 || string(data) == `""` {
+		return nil
+	}
+	if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' {
+		return errors.New("invalid UUID format")
+	}
+	data = data[1 : len(data)-1]
+	uu := Parse(string(data))
+	if uu == nil {
+		return errors.New("invalid UUID format")
+	}
+	*u = uu
+	return nil
+}
diff --git a/vendor/github.com/pborman/uuid/node.go b/vendor/github.com/pborman/uuid/node.go
new file mode 100644
index 00000000..dd0a8ac1
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/node.go
@@ -0,0 +1,101 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "net"
+
+var (
+	interfaces []net.Interface // cached list of interfaces
+	ifname     string          // name of interface being used
+	nodeID     []byte          // hardware for version 1 UUIDs
+)
+
+// NodeInterface returns the name of the interface from which the NodeID was
+// derived.  The interface "user" is returned if the NodeID was set by
+// SetNodeID.
+func NodeInterface() string {
+	return ifname
+}
+
+// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
+// If name is "" then the first usable interface found will be used or a random
+// Node ID will be generated.  If a named interface cannot be found then false
+// is returned.
+//
+// SetNodeInterface never fails when name is "".
+func SetNodeInterface(name string) bool {
+	if interfaces == nil {
+		var err error
+		interfaces, err = net.Interfaces()
+		if err != nil && name != "" {
+			return false
+		}
+	}
+
+	for _, ifs := range interfaces {
+		if len(ifs.HardwareAddr) >= 6 && (name == "" || name == ifs.Name) {
+			if setNodeID(ifs.HardwareAddr) {
+				ifname = ifs.Name
+				return true
+			}
+		}
+	}
+
+	// We found no interfaces with a valid hardware address.  If name
+	// does not specify a specific interface generate a random Node ID
+	// (section 4.1.6)
+	if name == "" {
+		if nodeID == nil {
+			nodeID = make([]byte, 6)
+		}
+		randomBits(nodeID)
+		return true
+	}
+	return false
+}
+
+// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
+// if not already set.
+func NodeID() []byte {
+	if nodeID == nil {
+		SetNodeInterface("")
+	}
+	nid := make([]byte, 6)
+	copy(nid, nodeID)
+	return nid
+}
+
+// SetNodeID sets the Node ID to be used for Version 1 UUIDs.  The first 6 bytes
+// of id are used.  If id is less than 6 bytes then false is returned and the
+// Node ID is not set.
+func SetNodeID(id []byte) bool {
+	if setNodeID(id) {
+		ifname = "user"
+		return true
+	}
+	return false
+}
+
+func setNodeID(id []byte) bool {
+	if len(id) < 6 {
+		return false
+	}
+	if nodeID == nil {
+		nodeID = make([]byte, 6)
+	}
+	copy(nodeID, id)
+	return true
+}
+
+// NodeID returns the 6 byte node id encoded in uuid.  It returns nil if uuid is
+// not valid.  The NodeID is only well defined for version 1 and 2 UUIDs.
+func (uuid UUID) NodeID() []byte {
+	if len(uuid) != 16 {
+		return nil
+	}
+	node := make([]byte, 6)
+	copy(node, uuid[10:])
+	return node
+}
diff --git a/vendor/github.com/pborman/uuid/time.go b/vendor/github.com/pborman/uuid/time.go
new file mode 100644
index 00000000..7ebc9bef
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/time.go
@@ -0,0 +1,132 @@
+// Copyright 2014 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+	"sync"
+	"time"
+)
+
+// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
+// 1582.
+type Time int64
+
+const (
+	lillian    = 2299160          // Julian day of 15 Oct 1582
+	unix       = 2440587          // Julian day of 1 Jan 1970
+	epoch      = unix - lillian   // Days between epochs
+	g1582      = epoch * 86400    // seconds between epochs
+	g1582ns100 = g1582 * 10000000 // 100s of a nanoseconds between epochs
+)
+
+var (
+	mu        sync.Mutex
+	lasttime  uint64 // last time we returned
+	clock_seq uint16 // clock sequence for this run
+
+	timeNow = time.Now // for testing
+)
+
+// UnixTime converts t the number of seconds and nanoseconds using the Unix
+// epoch of 1 Jan 1970.
+func (t Time) UnixTime() (sec, nsec int64) {
+	sec = int64(t - g1582ns100)
+	nsec = (sec % 10000000) * 100
+	sec /= 10000000
+	return sec, nsec
+}
+
+// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
+// clock sequence as well as adjusting the clock sequence as needed.  An error
+// is returned if the current time cannot be determined.
+func GetTime() (Time, uint16, error) {
+	defer mu.Unlock()
+	mu.Lock()
+	return getTime()
+}
+
+func getTime() (Time, uint16, error) {
+	t := timeNow()
+
+	// If we don't have a clock sequence already, set one.
+	if clock_seq == 0 {
+		setClockSequence(-1)
+	}
+	now := uint64(t.UnixNano()/100) + g1582ns100
+
+	// If time has gone backwards with this clock sequence then we
+	// increment the clock sequence
+	if now <= lasttime {
+		clock_seq = ((clock_seq + 1) & 0x3fff) | 0x8000
+	}
+	lasttime = now
+	return Time(now), clock_seq, nil
+}
+
+// ClockSequence returns the current clock sequence, generating one if not
+// already set.  The clock sequence is only used for Version 1 UUIDs.
+//
+// The uuid package does not use global static storage for the clock sequence or
+// the last time a UUID was generated.  Unless SetClockSequence a new random
+// clock sequence is generated the first time a clock sequence is requested by
+// ClockSequence, GetTime, or NewUUID.  (section 4.2.1.1) sequence is generated
+// for
+func ClockSequence() int {
+	defer mu.Unlock()
+	mu.Lock()
+	return clockSequence()
+}
+
+func clockSequence() int {
+	if clock_seq == 0 {
+		setClockSequence(-1)
+	}
+	return int(clock_seq & 0x3fff)
+}
+
+// SetClockSeq sets the clock sequence to the lower 14 bits of seq.  Setting to
+// -1 causes a new sequence to be generated.
+func SetClockSequence(seq int) {
+	defer mu.Unlock()
+	mu.Lock()
+	setClockSequence(seq)
+}
+
+func setClockSequence(seq int) {
+	if seq == -1 {
+		var b [2]byte
+		randomBits(b[:]) // clock sequence
+		seq = int(b[0])<<8 | int(b[1])
+	}
+	old_seq := clock_seq
+	clock_seq = uint16(seq&0x3fff) | 0x8000 // Set our variant
+	if old_seq != clock_seq {
+		lasttime = 0
+	}
+}
+
+// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
+// uuid.  It returns false if uuid is not valid.  The time is only well defined
+// for version 1 and 2 UUIDs.
+func (uuid UUID) Time() (Time, bool) {
+	if len(uuid) != 16 {
+		return 0, false
+	}
+	time := int64(binary.BigEndian.Uint32(uuid[0:4]))
+	time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
+	time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
+	return Time(time), true
+}
+
+// ClockSequence returns the clock sequence encoded in uuid.  It returns false
+// if uuid is not valid.  The clock sequence is only well defined for version 1
+// and 2 UUIDs.
+func (uuid UUID) ClockSequence() (int, bool) {
+	if len(uuid) != 16 {
+		return 0, false
+	}
+	return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff, true
+}
diff --git a/vendor/github.com/pborman/uuid/util.go b/vendor/github.com/pborman/uuid/util.go
new file mode 100644
index 00000000..de40b102
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/util.go
@@ -0,0 +1,43 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"io"
+)
+
+// randomBits completely fills slice b with random data.
+func randomBits(b []byte) {
+	if _, err := io.ReadFull(rander, b); err != nil {
+		panic(err.Error()) // rand should never fail
+	}
+}
+
+// xvalues returns the value of a byte as a hexadecimal digit or 255.
+var xvalues = []byte{
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255,
+	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+}
+
+// xtob converts the the first two hex bytes of x into a byte.
+func xtob(x string) (byte, bool) {
+	b1 := xvalues[x[0]]
+	b2 := xvalues[x[1]]
+	return (b1 << 4) | b2, b1 != 255 && b2 != 255
+}
diff --git a/vendor/github.com/pborman/uuid/uuid.go b/vendor/github.com/pborman/uuid/uuid.go
new file mode 100644
index 00000000..2920fae6
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/uuid.go
@@ -0,0 +1,163 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"bytes"
+	"crypto/rand"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
+// 4122.
+type UUID []byte
+
+// A Version represents a UUIDs version.
+type Version byte
+
+// A Variant represents a UUIDs variant.
+type Variant byte
+
+// Constants returned by Variant.
+const (
+	Invalid   = Variant(iota) // Invalid UUID
+	RFC4122                   // The variant specified in RFC4122
+	Reserved                  // Reserved, NCS backward compatibility.
+	Microsoft                 // Reserved, Microsoft Corporation backward compatibility.
+	Future                    // Reserved for future definition.
+)
+
+var rander = rand.Reader // random function
+
+// New returns a new random (version 4) UUID as a string.  It is a convenience
+// function for NewRandom().String().
+func New() string {
+	return NewRandom().String()
+}
+
+// Parse decodes s into a UUID or returns nil.  Both the UUID form of
+// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded.
+func Parse(s string) UUID {
+	if len(s) == 36+9 {
+		if strings.ToLower(s[:9]) != "urn:uuid:" {
+			return nil
+		}
+		s = s[9:]
+	} else if len(s) != 36 {
+		return nil
+	}
+	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+		return nil
+	}
+	uuid := make([]byte, 16)
+	for i, x := range []int{
+		0, 2, 4, 6,
+		9, 11,
+		14, 16,
+		19, 21,
+		24, 26, 28, 30, 32, 34} {
+		if v, ok := xtob(s[x:]); !ok {
+			return nil
+		} else {
+			uuid[i] = v
+		}
+	}
+	return uuid
+}
+
+// Equal returns true if uuid1 and uuid2 are equal.
+func Equal(uuid1, uuid2 UUID) bool {
+	return bytes.Equal(uuid1, uuid2)
+}
+
+// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+// , or "" if uuid is invalid.
+func (uuid UUID) String() string {
+	if uuid == nil || len(uuid) != 16 {
+		return ""
+	}
+	b := []byte(uuid)
+	return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
+		b[:4], b[4:6], b[6:8], b[8:10], b[10:])
+}
+
+// URN returns the RFC 2141 URN form of uuid,
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,  or "" if uuid is invalid.
+func (uuid UUID) URN() string {
+	if uuid == nil || len(uuid) != 16 {
+		return ""
+	}
+	b := []byte(uuid)
+	return fmt.Sprintf("urn:uuid:%08x-%04x-%04x-%04x-%012x",
+		b[:4], b[4:6], b[6:8], b[8:10], b[10:])
+}
+
+// Variant returns the variant encoded in uuid.  It returns Invalid if
+// uuid is invalid.
+func (uuid UUID) Variant() Variant {
+	if len(uuid) != 16 {
+		return Invalid
+	}
+	switch {
+	case (uuid[8] & 0xc0) == 0x80:
+		return RFC4122
+	case (uuid[8] & 0xe0) == 0xc0:
+		return Microsoft
+	case (uuid[8] & 0xe0) == 0xe0:
+		return Future
+	default:
+		return Reserved
+	}
+	panic("unreachable")
+}
+
+// Version returns the verison of uuid.  It returns false if uuid is not
+// valid.
+func (uuid UUID) Version() (Version, bool) {
+	if len(uuid) != 16 {
+		return 0, false
+	}
+	return Version(uuid[6] >> 4), true
+}
+
+func (v Version) String() string {
+	if v > 15 {
+		return fmt.Sprintf("BAD_VERSION_%d", v)
+	}
+	return fmt.Sprintf("VERSION_%d", v)
+}
+
+func (v Variant) String() string {
+	switch v {
+	case RFC4122:
+		return "RFC4122"
+	case Reserved:
+		return "Reserved"
+	case Microsoft:
+		return "Microsoft"
+	case Future:
+		return "Future"
+	case Invalid:
+		return "Invalid"
+	}
+	return fmt.Sprintf("BadVariant%d", int(v))
+}
+
+// SetRand sets the random number generator to r, which implents io.Reader.
+// If r.Read returns an error when the package requests random data then
+// a panic will be issued.
+//
+// Calling SetRand with nil sets the random number generator to the default
+// generator.
+func SetRand(r io.Reader) {
+	if r == nil {
+		rander = rand.Reader
+		return
+	}
+	rander = r
+}
diff --git a/vendor/github.com/pborman/uuid/version1.go b/vendor/github.com/pborman/uuid/version1.go
new file mode 100644
index 00000000..0127eacf
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/version1.go
@@ -0,0 +1,41 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+)
+
+// NewUUID returns a Version 1 UUID based on the current NodeID and clock
+// sequence, and the current time.  If the NodeID has not been set by SetNodeID
+// or SetNodeInterface then it will be set automatically.  If the NodeID cannot
+// be set NewUUID returns nil.  If clock sequence has not been set by
+// SetClockSequence then it will be set automatically.  If GetTime fails to
+// return the current NewUUID returns nil.
+func NewUUID() UUID {
+	if nodeID == nil {
+		SetNodeInterface("")
+	}
+
+	now, seq, err := GetTime()
+	if err != nil {
+		return nil
+	}
+
+	uuid := make([]byte, 16)
+
+	time_low := uint32(now & 0xffffffff)
+	time_mid := uint16((now >> 32) & 0xffff)
+	time_hi := uint16((now >> 48) & 0x0fff)
+	time_hi |= 0x1000 // Version 1
+
+	binary.BigEndian.PutUint32(uuid[0:], time_low)
+	binary.BigEndian.PutUint16(uuid[4:], time_mid)
+	binary.BigEndian.PutUint16(uuid[6:], time_hi)
+	binary.BigEndian.PutUint16(uuid[8:], seq)
+	copy(uuid[10:], nodeID)
+
+	return uuid
+}
diff --git a/vendor/github.com/pborman/uuid/version4.go b/vendor/github.com/pborman/uuid/version4.go
new file mode 100644
index 00000000..b3d4a368
--- /dev/null
+++ b/vendor/github.com/pborman/uuid/version4.go
@@ -0,0 +1,25 @@
+// Copyright 2011 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+// Random returns a Random (Version 4) UUID or panics.
+//
+// The strength of the UUIDs is based on the strength of the crypto/rand
+// package.
+//
+// A note about uniqueness derived from from the UUID Wikipedia entry:
+//
+//  Randomly generated UUIDs have 122 random bits.  One's annual risk of being
+//  hit by a meteorite is estimated to be one chance in 17 billion, that
+//  means the probability is about 0.00000000006 (6 × 10−11),
+//  equivalent to the odds of creating a few tens of trillions of UUIDs in a
+//  year and having one duplicate.
+func NewRandom() UUID {
+	uuid := make([]byte, 16)
+	randomBits([]byte(uuid))
+	uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
+	uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
+	return uuid
+}
diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go
new file mode 100644
index 00000000..fbf03f4d
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/assert/assertions.go
@@ -0,0 +1,895 @@
+package assert
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+	Errorf(format string, args ...interface{})
+}
+
+// Comparison a custom function that returns true on success and false on failure
+type Comparison func() (success bool)
+
+/*
+	Helper functions
+*/
+
+// ObjectsAreEqual determines if two objects are considered equal.
+//
+// This function does no assertion of any kind.
+func ObjectsAreEqual(expected, actual interface{}) bool {
+
+	if expected == nil || actual == nil {
+		return expected == actual
+	}
+
+	if reflect.DeepEqual(expected, actual) {
+		return true
+	}
+
+	return false
+
+}
+
+// ObjectsAreEqualValues gets whether two objects are equal, or if their
+// values are equal.
+func ObjectsAreEqualValues(expected, actual interface{}) bool {
+	if ObjectsAreEqual(expected, actual) {
+		return true
+	}
+
+	actualType := reflect.TypeOf(actual)
+	expectedValue := reflect.ValueOf(expected)
+	if expectedValue.Type().ConvertibleTo(actualType) {
+		// Attempt comparison after type conversion
+		if reflect.DeepEqual(actual, expectedValue.Convert(actualType).Interface()) {
+			return true
+		}
+	}
+
+	return false
+}
+
+/* CallerInfo is necessary because the assert functions use the testing object
+internally, causing it to print the file:line of the assert method, rather than where
+the problem actually occured in calling code.*/
+
+// CallerInfo returns an array of strings containing the file and line number
+// of each stack frame leading from the current test to the assert call that
+// failed.
+func CallerInfo() []string {
+
+	pc := uintptr(0)
+	file := ""
+	line := 0
+	ok := false
+	name := ""
+
+	callers := []string{}
+	for i := 0; ; i++ {
+		pc, file, line, ok = runtime.Caller(i)
+		if !ok {
+			return nil
+		}
+
+		// This is a huge edge case, but it will panic if this is the case, see #180
+		if file == "<autogenerated>" {
+			break
+		}
+
+		parts := strings.Split(file, "/")
+		dir := parts[len(parts)-2]
+		file = parts[len(parts)-1]
+		if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" {
+			callers = append(callers, fmt.Sprintf("%s:%d", file, line))
+		}
+
+		f := runtime.FuncForPC(pc)
+		if f == nil {
+			break
+		}
+		name = f.Name()
+		// Drop the package
+		segments := strings.Split(name, ".")
+		name = segments[len(segments)-1]
+		if isTest(name, "Test") ||
+			isTest(name, "Benchmark") ||
+			isTest(name, "Example") {
+			break
+		}
+	}
+
+	return callers
+}
+
+// Stolen from the `go test` tool.
+// isTest tells whether name looks like a test (or benchmark, according to prefix).
+// It is a Test (say) if there is a character after Test that is not a lower-case letter.
+// We don't want TesticularCancer.
+func isTest(name, prefix string) bool {
+	if !strings.HasPrefix(name, prefix) {
+		return false
+	}
+	if len(name) == len(prefix) { // "Test" is ok
+		return true
+	}
+	rune, _ := utf8.DecodeRuneInString(name[len(prefix):])
+	return !unicode.IsLower(rune)
+}
+
+// getWhitespaceString returns a string that is long enough to overwrite the default
+// output from the go testing framework.
+func getWhitespaceString() string {
+
+	_, file, line, ok := runtime.Caller(1)
+	if !ok {
+		return ""
+	}
+	parts := strings.Split(file, "/")
+	file = parts[len(parts)-1]
+
+	return strings.Repeat(" ", len(fmt.Sprintf("%s:%d:      ", file, line)))
+
+}
+
+func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
+	if len(msgAndArgs) == 0 || msgAndArgs == nil {
+		return ""
+	}
+	if len(msgAndArgs) == 1 {
+		return msgAndArgs[0].(string)
+	}
+	if len(msgAndArgs) > 1 {
+		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+	}
+	return ""
+}
+
+// Indents all lines of the message by appending a number of tabs to each line, in an output format compatible with Go's
+// test printing (see inner comment for specifics)
+func indentMessageLines(message string, tabs int) string {
+	outBuf := new(bytes.Buffer)
+
+	for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
+		if i != 0 {
+			outBuf.WriteRune('\n')
+		}
+		for ii := 0; ii < tabs; ii++ {
+			outBuf.WriteRune('\t')
+			// Bizarrely, all lines except the first need one fewer tabs prepended, so deliberately advance the counter
+			// by 1 prematurely.
+			if ii == 0 && i > 0 {
+				ii++
+			}
+		}
+		outBuf.WriteString(scanner.Text())
+	}
+
+	return outBuf.String()
+}
+
+// Fail reports a failure through
+func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
+
+	message := messageFromMsgAndArgs(msgAndArgs...)
+
+	errorTrace := strings.Join(CallerInfo(), "\n\r\t\t\t")
+	if len(message) > 0 {
+		t.Errorf("\r%s\r\tError Trace:\t%s\n"+
+			"\r\tError:%s\n"+
+			"\r\tMessages:\t%s\n\r",
+			getWhitespaceString(),
+			errorTrace,
+			indentMessageLines(failureMessage, 2),
+			message)
+	} else {
+		t.Errorf("\r%s\r\tError Trace:\t%s\n"+
+			"\r\tError:%s\n\r",
+			getWhitespaceString(),
+			errorTrace,
+			indentMessageLines(failureMessage, 2))
+	}
+
+	return false
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//    assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
+func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+
+	interfaceType := reflect.TypeOf(interfaceObject).Elem()
+
+	if !reflect.TypeOf(object).Implements(interfaceType) {
+		return Fail(t, fmt.Sprintf("Object must implement %v", interfaceType), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// IsType asserts that the specified objects are of the same type.
+func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+
+	if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
+		return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
+	}
+
+	return true
+}
+
+// Equal asserts that two objects are equal.
+//
+//    assert.Equal(t, 123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+	if !ObjectsAreEqual(expected, actual) {
+		return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
+			"        != %#v (actual)", expected, actual), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// EqualValues asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+	if !ObjectsAreEqualValues(expected, actual) {
+		return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
+			"        != %#v (actual)", expected, actual), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+//    assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+	aType := reflect.TypeOf(expected)
+	bType := reflect.TypeOf(actual)
+
+	if aType != bType {
+		return Fail(t, "Types expected to match exactly", "%v != %v", aType, bType)
+	}
+
+	return Equal(t, expected, actual, msgAndArgs...)
+
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//    assert.NotNil(t, err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+	success := true
+
+	if object == nil {
+		success = false
+	} else {
+		value := reflect.ValueOf(object)
+		kind := value.Kind()
+		if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+			success = false
+		}
+	}
+
+	if !success {
+		Fail(t, "Expected value not to be nil.", msgAndArgs...)
+	}
+
+	return success
+}
+
+// isNil checks if a specified object is nil or not, without Failing.
+func isNil(object interface{}) bool {
+	if object == nil {
+		return true
+	}
+
+	value := reflect.ValueOf(object)
+	kind := value.Kind()
+	if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+		return true
+	}
+
+	return false
+}
+
+// Nil asserts that the specified object is nil.
+//
+//    assert.Nil(t, err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if isNil(object) {
+		return true
+	}
+	return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
+}
+
+var zeros = []interface{}{
+	int(0),
+	int8(0),
+	int16(0),
+	int32(0),
+	int64(0),
+	uint(0),
+	uint8(0),
+	uint16(0),
+	uint32(0),
+	uint64(0),
+	float32(0),
+	float64(0),
+}
+
+// isEmpty gets whether the specified object is considered empty or not.
+func isEmpty(object interface{}) bool {
+
+	if object == nil {
+		return true
+	} else if object == "" {
+		return true
+	} else if object == false {
+		return true
+	}
+
+	for _, v := range zeros {
+		if object == v {
+			return true
+		}
+	}
+
+	objValue := reflect.ValueOf(object)
+
+	switch objValue.Kind() {
+	case reflect.Map:
+		fallthrough
+	case reflect.Slice, reflect.Chan:
+		{
+			return (objValue.Len() == 0)
+		}
+	case reflect.Ptr:
+		{
+			switch object.(type) {
+			case *time.Time:
+				return object.(*time.Time).IsZero()
+			default:
+				return false
+			}
+		}
+	}
+	return false
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+// assert.Empty(t, obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+	pass := isEmpty(object)
+	if !pass {
+		Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
+	}
+
+	return pass
+
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+// if assert.NotEmpty(t, obj) {
+//   assert.Equal(t, "two", obj[1])
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+	pass := !isEmpty(object)
+	if !pass {
+		Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
+	}
+
+	return pass
+
+}
+
+// getLen try to get length of object.
+// return (false, 0) if impossible.
+func getLen(x interface{}) (ok bool, length int) {
+	v := reflect.ValueOf(x)
+	defer func() {
+		if e := recover(); e != nil {
+			ok = false
+		}
+	}()
+	return true, v.Len()
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//    assert.Len(t, mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
+	ok, l := getLen(object)
+	if !ok {
+		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...)
+	}
+
+	if l != length {
+		return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
+	}
+	return true
+}
+
+// True asserts that the specified value is true.
+//
+//    assert.True(t, myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+
+	if value != true {
+		return Fail(t, "Should be true", msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// False asserts that the specified value is true.
+//
+//    assert.False(t, myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+
+	if value != false {
+		return Fail(t, "Should be false", msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//    assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+	if ObjectsAreEqual(expected, actual) {
+		return Fail(t, "Should not be equal", msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// containsElement try loop over the list check if the list includes the element.
+// return (false, false) if impossible.
+// return (true, false) if element was not found.
+// return (true, true) if element was found.
+func includeElement(list interface{}, element interface{}) (ok, found bool) {
+
+	listValue := reflect.ValueOf(list)
+	elementValue := reflect.ValueOf(element)
+	defer func() {
+		if e := recover(); e != nil {
+			ok = false
+			found = false
+		}
+	}()
+
+	if reflect.TypeOf(list).Kind() == reflect.String {
+		return true, strings.Contains(listValue.String(), elementValue.String())
+	}
+
+	for i := 0; i < listValue.Len(); i++ {
+		if ObjectsAreEqual(listValue.Index(i).Interface(), element) {
+			return true, true
+		}
+	}
+	return true, false
+
+}
+
+// Contains asserts that the specified string or list(array, slice...) contains the
+// specified substring or element.
+//
+//    assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
+//    assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+
+	ok, found := includeElement(s, contains)
+	if !ok {
+		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+	}
+	if !found {
+		return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// NotContains asserts that the specified string or list(array, slice...) does NOT contain the
+// specified substring or element.
+//
+//    assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+//    assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+
+	ok, found := includeElement(s, contains)
+	if !ok {
+		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+	}
+	if found {
+		return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...)
+	}
+
+	return true
+
+}
+
+// Condition uses a Comparison to assert a complex condition.
+func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
+	result := comp()
+	if !result {
+		Fail(t, "Condition failed!", msgAndArgs...)
+	}
+	return result
+}
+
+// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
+// methods, and represents a simple func that takes no arguments, and returns nothing.
+type PanicTestFunc func()
+
+// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
+func didPanic(f PanicTestFunc) (bool, interface{}) {
+
+	didPanic := false
+	var message interface{}
+	func() {
+
+		defer func() {
+			if message = recover(); message != nil {
+				didPanic = true
+			}
+		}()
+
+		// call the target function
+		f()
+
+	}()
+
+	return didPanic, message
+
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//   assert.Panics(t, func(){
+//     GoCrazy()
+//   }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+
+	if funcDidPanic, panicValue := didPanic(f); !funcDidPanic {
+		return Fail(t, fmt.Sprintf("func %#v should panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
+	}
+
+	return true
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   assert.NotPanics(t, func(){
+//     RemainCalm()
+//   }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+
+	if funcDidPanic, panicValue := didPanic(f); funcDidPanic {
+		return Fail(t, fmt.Sprintf("func %#v should not panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
+	}
+
+	return true
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//   assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+
+	dt := expected.Sub(actual)
+	if dt < -delta || dt > delta {
+		return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+	}
+
+	return true
+}
+
+func toFloat(x interface{}) (float64, bool) {
+	var xf float64
+	xok := true
+
+	switch xn := x.(type) {
+	case uint8:
+		xf = float64(xn)
+	case uint16:
+		xf = float64(xn)
+	case uint32:
+		xf = float64(xn)
+	case uint64:
+		xf = float64(xn)
+	case int:
+		xf = float64(xn)
+	case int8:
+		xf = float64(xn)
+	case int16:
+		xf = float64(xn)
+	case int32:
+		xf = float64(xn)
+	case int64:
+		xf = float64(xn)
+	case float32:
+		xf = float64(xn)
+	case float64:
+		xf = float64(xn)
+	default:
+		xok = false
+	}
+
+	return xf, xok
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// 	 assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+
+	af, aok := toFloat(expected)
+	bf, bok := toFloat(actual)
+
+	if !aok || !bok {
+		return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...)
+	}
+
+	if math.IsNaN(af) {
+		return Fail(t, fmt.Sprintf("Actual must not be NaN"), msgAndArgs...)
+	}
+
+	if math.IsNaN(bf) {
+		return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...)
+	}
+
+	dt := af - bf
+	if dt < -delta || dt > delta {
+		return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+	}
+
+	return true
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if expected == nil || actual == nil ||
+		reflect.TypeOf(actual).Kind() != reflect.Slice ||
+		reflect.TypeOf(expected).Kind() != reflect.Slice {
+		return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...)
+	}
+
+	actualSlice := reflect.ValueOf(actual)
+	expectedSlice := reflect.ValueOf(expected)
+
+	for i := 0; i < actualSlice.Len(); i++ {
+		result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta)
+		if !result {
+			return result
+		}
+	}
+
+	return true
+}
+
+// min(|expected|, |actual|) * epsilon
+func calcEpsilonDelta(expected, actual interface{}, epsilon float64) float64 {
+	af, aok := toFloat(expected)
+	bf, bok := toFloat(actual)
+
+	if !aok || !bok {
+		// invalid input
+		return 0
+	}
+
+	if af < 0 {
+		af = -af
+	}
+	if bf < 0 {
+		bf = -bf
+	}
+	var delta float64
+	if af < bf {
+		delta = af * epsilon
+	} else {
+		delta = bf * epsilon
+	}
+	return delta
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	delta := calcEpsilonDelta(expected, actual, epsilon)
+
+	return InDelta(t, expected, actual, delta, msgAndArgs...)
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares two slices.
+func InEpsilonSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	if expected == nil || actual == nil ||
+		reflect.TypeOf(actual).Kind() != reflect.Slice ||
+		reflect.TypeOf(expected).Kind() != reflect.Slice {
+		return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...)
+	}
+
+	actualSlice := reflect.ValueOf(actual)
+	expectedSlice := reflect.ValueOf(expected)
+
+	for i := 0; i < actualSlice.Len(); i++ {
+		result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta)
+		if !result {
+			return result
+		}
+	}
+
+	return true
+}
+
+/*
+	Errors
+*/
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.NoError(t, err) {
+//	   assert.Equal(t, actualObj, expectedObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
+	if isNil(err) {
+		return true
+	}
+
+	return Fail(t, fmt.Sprintf("No error is expected but got %v", err), msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.Error(t, err, "An error was expected") {
+//	   assert.Equal(t, err, expectedError)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
+
+	message := messageFromMsgAndArgs(msgAndArgs...)
+	return NotNil(t, err, "An error is expected but got nil. %s", message)
+
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   if assert.Error(t, err, "An error was expected") {
+//	   assert.Equal(t, err, expectedError)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
+
+	message := messageFromMsgAndArgs(msgAndArgs...)
+	if !NotNil(t, theError, "An error is expected but got nil. %s", message) {
+		return false
+	}
+	s := "An error with value \"%s\" is expected but got \"%s\". %s"
+	return Equal(t, theError.Error(), errString,
+		s, errString, theError.Error(), message)
+}
+
+// matchRegexp return true if a specified regexp matches a string.
+func matchRegexp(rx interface{}, str interface{}) bool {
+
+	var r *regexp.Regexp
+	if rr, ok := rx.(*regexp.Regexp); ok {
+		r = rr
+	} else {
+		r = regexp.MustCompile(fmt.Sprint(rx))
+	}
+
+	return (r.FindStringIndex(fmt.Sprint(str)) != nil)
+
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//  assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+//  assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+
+	match := matchRegexp(rx, str)
+
+	if !match {
+		Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...)
+	}
+
+	return match
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//  assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+//  assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	match := matchRegexp(rx, str)
+
+	if match {
+		Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...)
+	}
+
+	return !match
+
+}
diff --git a/vendor/github.com/stretchr/testify/assert/doc.go b/vendor/github.com/stretchr/testify/assert/doc.go
new file mode 100644
index 00000000..f6781062
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/assert/doc.go
@@ -0,0 +1,154 @@
+// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
+//
+// Example Usage
+//
+// The following is a complete example using assert in a standard test function:
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/assert"
+//    )
+//
+//    func TestSomething(t *testing.T) {
+//
+//      var a string = "Hello"
+//      var b string = "Hello"
+//
+//      assert.Equal(t, a, b, "The two words should be the same.")
+//
+//    }
+//
+// if you assert many times, use the below:
+//
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/assert"
+//    )
+//
+//    func TestSomething(t *testing.T) {
+//      assert := assert.New(t)
+//
+//      var a string = "Hello"
+//      var b string = "Hello"
+//
+//      assert.Equal(a, b, "The two words should be the same.")
+//    }
+//
+// Assertions
+//
+// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
+// All assertion functions take, as the first argument, the `*testing.T` object provided by the
+// testing framework. This allows the assertion funcs to write the failings and other details to
+// the correct place.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+//
+// Here is an overview of the assert functions:
+//
+//    assert.Equal(t, expected, actual [, message [, format-args]])
+//
+//    assert.EqualValues(t, expected, actual [, message [, format-args]])
+//
+//    assert.NotEqual(t, notExpected, actual [, message [, format-args]])
+//
+//    assert.True(t, actualBool [, message [, format-args]])
+//
+//    assert.False(t, actualBool [, message [, format-args]])
+//
+//    assert.Nil(t, actualObject [, message [, format-args]])
+//
+//    assert.NotNil(t, actualObject [, message [, format-args]])
+//
+//    assert.Empty(t, actualObject [, message [, format-args]])
+//
+//    assert.NotEmpty(t, actualObject [, message [, format-args]])
+//
+//    assert.Len(t, actualObject, expectedLength, [, message [, format-args]])
+//
+//    assert.Error(t, errorObject [, message [, format-args]])
+//
+//    assert.NoError(t, errorObject [, message [, format-args]])
+//
+//    assert.EqualError(t, theError, errString [, message [, format-args]])
+//
+//    assert.Implements(t, (*MyInterface)(nil), new(MyObject) [,message [, format-args]])
+//
+//    assert.IsType(t, expectedObject, actualObject [, message [, format-args]])
+//
+//    assert.Contains(t, stringOrSlice, substringOrElement [, message [, format-args]])
+//
+//    assert.NotContains(t, stringOrSlice, substringOrElement [, message [, format-args]])
+//
+//    assert.Panics(t, func(){
+//
+//	    // call code that should panic
+//
+//    } [, message [, format-args]])
+//
+//    assert.NotPanics(t, func(){
+//
+//	    // call code that should not panic
+//
+//    } [, message [, format-args]])
+//
+//    assert.WithinDuration(t, timeA, timeB, deltaTime, [, message [, format-args]])
+//
+//    assert.InDelta(t, numA, numB, delta, [, message [, format-args]])
+//
+//    assert.InEpsilon(t, numA, numB, epsilon, [, message [, format-args]])
+//
+// assert package contains Assertions object. it has assertion methods.
+//
+// Here is an overview of the assert functions:
+//    assert.Equal(expected, actual [, message [, format-args]])
+//
+//    assert.EqualValues(expected, actual [, message [, format-args]])
+//
+//    assert.NotEqual(notExpected, actual [, message [, format-args]])
+//
+//    assert.True(actualBool [, message [, format-args]])
+//
+//    assert.False(actualBool [, message [, format-args]])
+//
+//    assert.Nil(actualObject [, message [, format-args]])
+//
+//    assert.NotNil(actualObject [, message [, format-args]])
+//
+//    assert.Empty(actualObject [, message [, format-args]])
+//
+//    assert.NotEmpty(actualObject [, message [, format-args]])
+//
+//    assert.Len(actualObject, expectedLength, [, message [, format-args]])
+//
+//    assert.Error(errorObject [, message [, format-args]])
+//
+//    assert.NoError(errorObject [, message [, format-args]])
+//
+//    assert.EqualError(theError, errString [, message [, format-args]])
+//
+//    assert.Implements((*MyInterface)(nil), new(MyObject) [,message [, format-args]])
+//
+//    assert.IsType(expectedObject, actualObject [, message [, format-args]])
+//
+//    assert.Contains(stringOrSlice, substringOrElement [, message [, format-args]])
+//
+//    assert.NotContains(stringOrSlice, substringOrElement [, message [, format-args]])
+//
+//    assert.Panics(func(){
+//
+//	    // call code that should panic
+//
+//    } [, message [, format-args]])
+//
+//    assert.NotPanics(func(){
+//
+//	    // call code that should not panic
+//
+//    } [, message [, format-args]])
+//
+//    assert.WithinDuration(timeA, timeB, deltaTime, [, message [, format-args]])
+//
+//    assert.InDelta(numA, numB, delta, [, message [, format-args]])
+//
+//    assert.InEpsilon(numA, numB, epsilon, [, message [, format-args]])
+package assert
diff --git a/vendor/github.com/stretchr/testify/assert/errors.go b/vendor/github.com/stretchr/testify/assert/errors.go
new file mode 100644
index 00000000..ac9dc9d1
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/assert/errors.go
@@ -0,0 +1,10 @@
+package assert
+
+import (
+	"errors"
+)
+
+// AnError is an error instance useful for testing.  If the code does not care
+// about error specifics, and only needs to return the error for example, this
+// error should be used to make the test code more readable.
+var AnError = errors.New("assert.AnError general error for testing")
diff --git a/vendor/github.com/stretchr/testify/assert/forward_assertions.go b/vendor/github.com/stretchr/testify/assert/forward_assertions.go
new file mode 100644
index 00000000..d8d3f531
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/assert/forward_assertions.go
@@ -0,0 +1,265 @@
+package assert
+
+import "time"
+
+// Assertions provides assertion methods around the
+// TestingT interface.
+type Assertions struct {
+	t TestingT
+}
+
+// New makes a new Assertions object for the specified TestingT.
+func New(t TestingT) *Assertions {
+	return &Assertions{
+		t: t,
+	}
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
+	return Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//    assert.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	return Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	return IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// Equal asserts that two objects are equal.
+//
+//    assert.Equal(123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Equal(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	return Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualValues asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    assert.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualValues(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	return EqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+//    assert.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Exactly(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	return Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//    assert.NotNil(err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
+	return NotNil(a.t, object, msgAndArgs...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+//    assert.Nil(err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
+	return Nil(a.t, object, msgAndArgs...)
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or a
+// slice with len == 0.
+//
+// assert.Empty(obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
+	return Empty(a.t, object, msgAndArgs...)
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or a
+// slice with len == 0.
+//
+// if assert.NotEmpty(obj) {
+//   assert.Equal("two", obj[1])
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
+	return NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//    assert.Len(mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
+	return Len(a.t, object, length, msgAndArgs...)
+}
+
+// True asserts that the specified value is true.
+//
+//    assert.True(myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
+	return True(a.t, value, msgAndArgs...)
+}
+
+// False asserts that the specified value is true.
+//
+//    assert.False(myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
+	return False(a.t, value, msgAndArgs...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//    assert.NotEqual(obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEqual(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	return NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// Contains asserts that the specified string contains the specified substring.
+//
+//    assert.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Contains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+	return Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotContains asserts that the specified string does NOT contain the specified substring.
+//
+//    assert.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotContains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+	return NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// Condition uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
+	return Condition(a.t, comp, msgAndArgs...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//   assert.Panics(func(){
+//     GoCrazy()
+//   }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	return Panics(a.t, f, msgAndArgs...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   assert.NotPanics(func(){
+//     RemainCalm()
+//   }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	return NotPanics(a.t, f, msgAndArgs...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//   assert.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) WithinDuration(expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// 	 assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InDelta(expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InEpsilon(expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.NoError(err) {
+//	   assert.Equal(actualObj, expectedObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NoError(theError error, msgAndArgs ...interface{}) bool {
+	return NoError(a.t, theError, msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.Error(err, "An error was expected") {
+//	   assert.Equal(err, expectedError)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Error(theError error, msgAndArgs ...interface{}) bool {
+	return Error(a.t, theError, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   if assert.Error(err, "An error was expected") {
+//	   assert.Equal(err, expectedError)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
+	return EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//  assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+//  assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	return Regexp(a.t, rx, str, msgAndArgs...)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//  assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+//  assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	return NotRegexp(a.t, rx, str, msgAndArgs...)
+}
diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go
new file mode 100644
index 00000000..1246e58e
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go
@@ -0,0 +1,157 @@
+package assert
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+)
+
+// httpCode is a helper that returns HTTP code of the response. It returns -1
+// if building a new request fails.
+func httpCode(handler http.HandlerFunc, mode, url string, values url.Values) int {
+	w := httptest.NewRecorder()
+	req, err := http.NewRequest(mode, url+"?"+values.Encode(), nil)
+	if err != nil {
+		return -1
+	}
+	handler(w, req)
+	return w.Code
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+	code := httpCode(handler, mode, url, values)
+	if code == -1 {
+		return false
+	}
+	return code >= http.StatusOK && code <= http.StatusPartialContent
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+	code := httpCode(handler, mode, url, values)
+	if code == -1 {
+		return false
+	}
+	return code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+	code := httpCode(handler, mode, url, values)
+	if code == -1 {
+		return false
+	}
+	return code >= http.StatusBadRequest
+}
+
+// HTTPBody is a helper that returns HTTP body of the response. It returns
+// empty string if building a new request fails.
+func HTTPBody(handler http.HandlerFunc, mode, url string, values url.Values) string {
+	w := httptest.NewRecorder()
+	req, err := http.NewRequest(mode, url+"?"+values.Encode(), nil)
+	if err != nil {
+		return ""
+	}
+	handler(w, req)
+	return w.Body.String()
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+	body := HTTPBody(handler, mode, url, values)
+
+	contains := strings.Contains(body, fmt.Sprint(str))
+	if !contains {
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+	}
+
+	return contains
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+	body := HTTPBody(handler, mode, url, values)
+
+	contains := strings.Contains(body, fmt.Sprint(str))
+	if contains {
+		Fail(t, "Expected response body for %s to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)
+	}
+
+	return !contains
+}
+
+//
+// Assertions Wrappers
+//
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//  assert.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+	return HTTPSuccess(a.t, handler, mode, url, values)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//  assert.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+	return HTTPRedirect(a.t, handler, mode, url, values)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//  assert.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+	return HTTPError(a.t, handler, mode, url, values)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyContains(a.t, handler, mode, url, values, str)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyNotContains(a.t, handler, mode, url, values, str)
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/batch.go b/vendor/github.com/syndtr/goleveldb/leveldb/batch.go
new file mode 100644
index 00000000..ccf390c9
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/batch.go
@@ -0,0 +1,252 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/memdb"
+)
+
+type ErrBatchCorrupted struct {
+	Reason string
+}
+
+func (e *ErrBatchCorrupted) Error() string {
+	return fmt.Sprintf("leveldb: batch corrupted: %s", e.Reason)
+}
+
+func newErrBatchCorrupted(reason string) error {
+	return errors.NewErrCorrupted(nil, &ErrBatchCorrupted{reason})
+}
+
+const (
+	batchHdrLen  = 8 + 4
+	batchGrowRec = 3000
+)
+
+type BatchReplay interface {
+	Put(key, value []byte)
+	Delete(key []byte)
+}
+
+// Batch is a write batch.
+type Batch struct {
+	data       []byte
+	rLen, bLen int
+	seq        uint64
+	sync       bool
+}
+
+func (b *Batch) grow(n int) {
+	off := len(b.data)
+	if off == 0 {
+		off = batchHdrLen
+		if b.data != nil {
+			b.data = b.data[:off]
+		}
+	}
+	if cap(b.data)-off < n {
+		if b.data == nil {
+			b.data = make([]byte, off, off+n)
+		} else {
+			odata := b.data
+			div := 1
+			if b.rLen > batchGrowRec {
+				div = b.rLen / batchGrowRec
+			}
+			b.data = make([]byte, off, off+n+(off-batchHdrLen)/div)
+			copy(b.data, odata)
+		}
+	}
+}
+
+func (b *Batch) appendRec(kt kType, key, value []byte) {
+	n := 1 + binary.MaxVarintLen32 + len(key)
+	if kt == ktVal {
+		n += binary.MaxVarintLen32 + len(value)
+	}
+	b.grow(n)
+	off := len(b.data)
+	data := b.data[:off+n]
+	data[off] = byte(kt)
+	off += 1
+	off += binary.PutUvarint(data[off:], uint64(len(key)))
+	copy(data[off:], key)
+	off += len(key)
+	if kt == ktVal {
+		off += binary.PutUvarint(data[off:], uint64(len(value)))
+		copy(data[off:], value)
+		off += len(value)
+	}
+	b.data = data[:off]
+	b.rLen++
+	//  Include 8-byte ikey header
+	b.bLen += len(key) + len(value) + 8
+}
+
+// Put appends 'put operation' of the given key/value pair to the batch.
+// It is safe to modify the contents of the argument after Put returns.
+func (b *Batch) Put(key, value []byte) {
+	b.appendRec(ktVal, key, value)
+}
+
+// Delete appends 'delete operation' of the given key to the batch.
+// It is safe to modify the contents of the argument after Delete returns.
+func (b *Batch) Delete(key []byte) {
+	b.appendRec(ktDel, key, nil)
+}
+
+// Dump dumps batch contents. The returned slice can be loaded into the
+// batch using Load method.
+// The returned slice is not its own copy, so the contents should not be
+// modified.
+func (b *Batch) Dump() []byte {
+	return b.encode()
+}
+
+// Load loads given slice into the batch. Previous contents of the batch
+// will be discarded.
+// The given slice will not be copied and will be used as batch buffer, so
+// it is not safe to modify the contents of the slice.
+func (b *Batch) Load(data []byte) error {
+	return b.decode(0, data)
+}
+
+// Replay replays batch contents.
+func (b *Batch) Replay(r BatchReplay) error {
+	return b.decodeRec(func(i int, kt kType, key, value []byte) {
+		switch kt {
+		case ktVal:
+			r.Put(key, value)
+		case ktDel:
+			r.Delete(key)
+		}
+	})
+}
+
+// Len returns number of records in the batch.
+func (b *Batch) Len() int {
+	return b.rLen
+}
+
+// Reset resets the batch.
+func (b *Batch) Reset() {
+	b.data = b.data[:0]
+	b.seq = 0
+	b.rLen = 0
+	b.bLen = 0
+	b.sync = false
+}
+
+func (b *Batch) init(sync bool) {
+	b.sync = sync
+}
+
+func (b *Batch) append(p *Batch) {
+	if p.rLen > 0 {
+		b.grow(len(p.data) - batchHdrLen)
+		b.data = append(b.data, p.data[batchHdrLen:]...)
+		b.rLen += p.rLen
+	}
+	if p.sync {
+		b.sync = true
+	}
+}
+
+// size returns sums of key/value pair length plus 8-bytes ikey.
+func (b *Batch) size() int {
+	return b.bLen
+}
+
+func (b *Batch) encode() []byte {
+	b.grow(0)
+	binary.LittleEndian.PutUint64(b.data, b.seq)
+	binary.LittleEndian.PutUint32(b.data[8:], uint32(b.rLen))
+
+	return b.data
+}
+
+func (b *Batch) decode(prevSeq uint64, data []byte) error {
+	if len(data) < batchHdrLen {
+		return newErrBatchCorrupted("too short")
+	}
+
+	b.seq = binary.LittleEndian.Uint64(data)
+	if b.seq < prevSeq {
+		return newErrBatchCorrupted("invalid sequence number")
+	}
+	b.rLen = int(binary.LittleEndian.Uint32(data[8:]))
+	if b.rLen < 0 {
+		return newErrBatchCorrupted("invalid records length")
+	}
+	// No need to be precise at this point, it won't be used anyway
+	b.bLen = len(data) - batchHdrLen
+	b.data = data
+
+	return nil
+}
+
+func (b *Batch) decodeRec(f func(i int, kt kType, key, value []byte)) (err error) {
+	off := batchHdrLen
+	for i := 0; i < b.rLen; i++ {
+		if off >= len(b.data) {
+			return newErrBatchCorrupted("invalid records length")
+		}
+
+		kt := kType(b.data[off])
+		if kt > ktVal {
+			return newErrBatchCorrupted("bad record: invalid type")
+		}
+		off += 1
+
+		x, n := binary.Uvarint(b.data[off:])
+		off += n
+		if n <= 0 || off+int(x) > len(b.data) {
+			return newErrBatchCorrupted("bad record: invalid key length")
+		}
+		key := b.data[off : off+int(x)]
+		off += int(x)
+		var value []byte
+		if kt == ktVal {
+			x, n := binary.Uvarint(b.data[off:])
+			off += n
+			if n <= 0 || off+int(x) > len(b.data) {
+				return newErrBatchCorrupted("bad record: invalid value length")
+			}
+			value = b.data[off : off+int(x)]
+			off += int(x)
+		}
+
+		f(i, kt, key, value)
+	}
+
+	return nil
+}
+
+func (b *Batch) memReplay(to *memdb.DB) error {
+	return b.decodeRec(func(i int, kt kType, key, value []byte) {
+		ikey := newIkey(key, b.seq+uint64(i), kt)
+		to.Put(ikey, value)
+	})
+}
+
+func (b *Batch) memDecodeAndReplay(prevSeq uint64, data []byte, to *memdb.DB) error {
+	if err := b.decode(prevSeq, data); err != nil {
+		return err
+	}
+	return b.memReplay(to)
+}
+
+func (b *Batch) revertMemReplay(to *memdb.DB) error {
+	return b.decodeRec(func(i int, kt kType, key, value []byte) {
+		ikey := newIkey(key, b.seq+uint64(i), kt)
+		to.Delete(ikey)
+	})
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/cache/cache.go b/vendor/github.com/syndtr/goleveldb/leveldb/cache/cache.go
new file mode 100644
index 00000000..c9670de5
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/cache/cache.go
@@ -0,0 +1,676 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package cache provides interface and implementation of a cache algorithms.
+package cache
+
+import (
+	"sync"
+	"sync/atomic"
+	"unsafe"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// Cacher provides interface to implements a caching functionality.
+// An implementation must be goroutine-safe.
+type Cacher interface {
+	// Capacity returns cache capacity.
+	Capacity() int
+
+	// SetCapacity sets cache capacity.
+	SetCapacity(capacity int)
+
+	// Promote promotes the 'cache node'.
+	Promote(n *Node)
+
+	// Ban evicts the 'cache node' and prevent subsequent 'promote'.
+	Ban(n *Node)
+
+	// Evict evicts the 'cache node'.
+	Evict(n *Node)
+
+	// EvictNS evicts 'cache node' with the given namespace.
+	EvictNS(ns uint64)
+
+	// EvictAll evicts all 'cache node'.
+	EvictAll()
+
+	// Close closes the 'cache tree'
+	Close() error
+}
+
+// Value is a 'cacheable object'. It may implements util.Releaser, if
+// so the the Release method will be called once object is released.
+type Value interface{}
+
+type CacheGetter struct {
+	Cache *Cache
+	NS    uint64
+}
+
+func (g *CacheGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle {
+	return g.Cache.Get(g.NS, key, setFunc)
+}
+
+// The hash tables implementation is based on:
+// "Dynamic-Sized Nonblocking Hash Tables", by Yujie Liu, Kunlong Zhang, and Michael Spear. ACM Symposium on Principles of Distributed Computing, Jul 2014.
+
+const (
+	mInitialSize           = 1 << 4
+	mOverflowThreshold     = 1 << 5
+	mOverflowGrowThreshold = 1 << 7
+)
+
+type mBucket struct {
+	mu     sync.Mutex
+	node   []*Node
+	frozen bool
+}
+
+func (b *mBucket) freeze() []*Node {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if !b.frozen {
+		b.frozen = true
+	}
+	return b.node
+}
+
+func (b *mBucket) get(r *Cache, h *mNode, hash uint32, ns, key uint64, noset bool) (done, added bool, n *Node) {
+	b.mu.Lock()
+
+	if b.frozen {
+		b.mu.Unlock()
+		return
+	}
+
+	// Scan the node.
+	for _, n := range b.node {
+		if n.hash == hash && n.ns == ns && n.key == key {
+			atomic.AddInt32(&n.ref, 1)
+			b.mu.Unlock()
+			return true, false, n
+		}
+	}
+
+	// Get only.
+	if noset {
+		b.mu.Unlock()
+		return true, false, nil
+	}
+
+	// Create node.
+	n = &Node{
+		r:    r,
+		hash: hash,
+		ns:   ns,
+		key:  key,
+		ref:  1,
+	}
+	// Add node to bucket.
+	b.node = append(b.node, n)
+	bLen := len(b.node)
+	b.mu.Unlock()
+
+	// Update counter.
+	grow := atomic.AddInt32(&r.nodes, 1) >= h.growThreshold
+	if bLen > mOverflowThreshold {
+		grow = grow || atomic.AddInt32(&h.overflow, 1) >= mOverflowGrowThreshold
+	}
+
+	// Grow.
+	if grow && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+		nhLen := len(h.buckets) << 1
+		nh := &mNode{
+			buckets:         make([]unsafe.Pointer, nhLen),
+			mask:            uint32(nhLen) - 1,
+			pred:            unsafe.Pointer(h),
+			growThreshold:   int32(nhLen * mOverflowThreshold),
+			shrinkThreshold: int32(nhLen >> 1),
+		}
+		ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+		if !ok {
+			panic("BUG: failed swapping head")
+		}
+		go nh.initBuckets()
+	}
+
+	return true, true, n
+}
+
+func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
+	b.mu.Lock()
+
+	if b.frozen {
+		b.mu.Unlock()
+		return
+	}
+
+	// Scan the node.
+	var (
+		n    *Node
+		bLen int
+	)
+	for i := range b.node {
+		n = b.node[i]
+		if n.ns == ns && n.key == key {
+			if atomic.LoadInt32(&n.ref) == 0 {
+				deleted = true
+
+				// Call releaser.
+				if n.value != nil {
+					if r, ok := n.value.(util.Releaser); ok {
+						r.Release()
+					}
+					n.value = nil
+				}
+
+				// Remove node from bucket.
+				b.node = append(b.node[:i], b.node[i+1:]...)
+				bLen = len(b.node)
+			}
+			break
+		}
+	}
+	b.mu.Unlock()
+
+	if deleted {
+		// Call OnDel.
+		for _, f := range n.onDel {
+			f()
+		}
+
+		// Update counter.
+		atomic.AddInt32(&r.size, int32(n.size)*-1)
+		shrink := atomic.AddInt32(&r.nodes, -1) < h.shrinkThreshold
+		if bLen >= mOverflowThreshold {
+			atomic.AddInt32(&h.overflow, -1)
+		}
+
+		// Shrink.
+		if shrink && len(h.buckets) > mInitialSize && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+			nhLen := len(h.buckets) >> 1
+			nh := &mNode{
+				buckets:         make([]unsafe.Pointer, nhLen),
+				mask:            uint32(nhLen) - 1,
+				pred:            unsafe.Pointer(h),
+				growThreshold:   int32(nhLen * mOverflowThreshold),
+				shrinkThreshold: int32(nhLen >> 1),
+			}
+			ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+			if !ok {
+				panic("BUG: failed swapping head")
+			}
+			go nh.initBuckets()
+		}
+	}
+
+	return true, deleted
+}
+
+type mNode struct {
+	buckets         []unsafe.Pointer // []*mBucket
+	mask            uint32
+	pred            unsafe.Pointer // *mNode
+	resizeInProgess int32
+
+	overflow        int32
+	growThreshold   int32
+	shrinkThreshold int32
+}
+
+func (n *mNode) initBucket(i uint32) *mBucket {
+	if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
+		return b
+	}
+
+	p := (*mNode)(atomic.LoadPointer(&n.pred))
+	if p != nil {
+		var node []*Node
+		if n.mask > p.mask {
+			// Grow.
+			pb := (*mBucket)(atomic.LoadPointer(&p.buckets[i&p.mask]))
+			if pb == nil {
+				pb = p.initBucket(i & p.mask)
+			}
+			m := pb.freeze()
+			// Split nodes.
+			for _, x := range m {
+				if x.hash&n.mask == i {
+					node = append(node, x)
+				}
+			}
+		} else {
+			// Shrink.
+			pb0 := (*mBucket)(atomic.LoadPointer(&p.buckets[i]))
+			if pb0 == nil {
+				pb0 = p.initBucket(i)
+			}
+			pb1 := (*mBucket)(atomic.LoadPointer(&p.buckets[i+uint32(len(n.buckets))]))
+			if pb1 == nil {
+				pb1 = p.initBucket(i + uint32(len(n.buckets)))
+			}
+			m0 := pb0.freeze()
+			m1 := pb1.freeze()
+			// Merge nodes.
+			node = make([]*Node, 0, len(m0)+len(m1))
+			node = append(node, m0...)
+			node = append(node, m1...)
+		}
+		b := &mBucket{node: node}
+		if atomic.CompareAndSwapPointer(&n.buckets[i], nil, unsafe.Pointer(b)) {
+			if len(node) > mOverflowThreshold {
+				atomic.AddInt32(&n.overflow, int32(len(node)-mOverflowThreshold))
+			}
+			return b
+		}
+	}
+
+	return (*mBucket)(atomic.LoadPointer(&n.buckets[i]))
+}
+
+func (n *mNode) initBuckets() {
+	for i := range n.buckets {
+		n.initBucket(uint32(i))
+	}
+	atomic.StorePointer(&n.pred, nil)
+}
+
+// Cache is a 'cache map'.
+type Cache struct {
+	mu     sync.RWMutex
+	mHead  unsafe.Pointer // *mNode
+	nodes  int32
+	size   int32
+	cacher Cacher
+	closed bool
+}
+
+// NewCache creates a new 'cache map'. The cacher is optional and
+// may be nil.
+func NewCache(cacher Cacher) *Cache {
+	h := &mNode{
+		buckets:         make([]unsafe.Pointer, mInitialSize),
+		mask:            mInitialSize - 1,
+		growThreshold:   int32(mInitialSize * mOverflowThreshold),
+		shrinkThreshold: 0,
+	}
+	for i := range h.buckets {
+		h.buckets[i] = unsafe.Pointer(&mBucket{})
+	}
+	r := &Cache{
+		mHead:  unsafe.Pointer(h),
+		cacher: cacher,
+	}
+	return r
+}
+
+func (r *Cache) getBucket(hash uint32) (*mNode, *mBucket) {
+	h := (*mNode)(atomic.LoadPointer(&r.mHead))
+	i := hash & h.mask
+	b := (*mBucket)(atomic.LoadPointer(&h.buckets[i]))
+	if b == nil {
+		b = h.initBucket(i)
+	}
+	return h, b
+}
+
+func (r *Cache) delete(n *Node) bool {
+	for {
+		h, b := r.getBucket(n.hash)
+		done, deleted := b.delete(r, h, n.hash, n.ns, n.key)
+		if done {
+			return deleted
+		}
+	}
+	return false
+}
+
+// Nodes returns number of 'cache node' in the map.
+func (r *Cache) Nodes() int {
+	return int(atomic.LoadInt32(&r.nodes))
+}
+
+// Size returns sums of 'cache node' size in the map.
+func (r *Cache) Size() int {
+	return int(atomic.LoadInt32(&r.size))
+}
+
+// Capacity returns cache capacity.
+func (r *Cache) Capacity() int {
+	if r.cacher == nil {
+		return 0
+	}
+	return r.cacher.Capacity()
+}
+
+// SetCapacity sets cache capacity.
+func (r *Cache) SetCapacity(capacity int) {
+	if r.cacher != nil {
+		r.cacher.SetCapacity(capacity)
+	}
+}
+
+// Get gets 'cache node' with the given namespace and key.
+// If cache node is not found and setFunc is not nil, Get will atomically creates
+// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
+//
+// The returned 'cache handle' should be released after use by calling Release
+// method.
+func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return nil
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
+		if done {
+			if n != nil {
+				n.mu.Lock()
+				if n.value == nil {
+					if setFunc == nil {
+						n.mu.Unlock()
+						n.unref()
+						return nil
+					}
+
+					n.size, n.value = setFunc()
+					if n.value == nil {
+						n.size = 0
+						n.mu.Unlock()
+						n.unref()
+						return nil
+					}
+					atomic.AddInt32(&r.size, int32(n.size))
+				}
+				n.mu.Unlock()
+				if r.cacher != nil {
+					r.cacher.Promote(n)
+				}
+				return &Handle{unsafe.Pointer(n)}
+			}
+
+			break
+		}
+	}
+	return nil
+}
+
+// Delete removes and ban 'cache node' with the given namespace and key.
+// A banned 'cache node' will never inserted into the 'cache tree'. Ban
+// only attributed to the particular 'cache node', so when a 'cache node'
+// is recreated it will not be banned.
+//
+// If onDel is not nil, then it will be executed if such 'cache node'
+// doesn't exist or once the 'cache node' is released.
+//
+// Delete return true is such 'cache node' exist.
+func (r *Cache) Delete(ns, key uint64, onDel func()) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return false
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, true)
+		if done {
+			if n != nil {
+				if onDel != nil {
+					n.mu.Lock()
+					n.onDel = append(n.onDel, onDel)
+					n.mu.Unlock()
+				}
+				if r.cacher != nil {
+					r.cacher.Ban(n)
+				}
+				n.unref()
+				return true
+			}
+
+			break
+		}
+	}
+
+	if onDel != nil {
+		onDel()
+	}
+
+	return false
+}
+
+// Evict evicts 'cache node' with the given namespace and key. This will
+// simply call Cacher.Evict.
+//
+// Evict return true is such 'cache node' exist.
+func (r *Cache) Evict(ns, key uint64) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return false
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, true)
+		if done {
+			if n != nil {
+				if r.cacher != nil {
+					r.cacher.Evict(n)
+				}
+				n.unref()
+				return true
+			}
+
+			break
+		}
+	}
+
+	return false
+}
+
+// EvictNS evicts 'cache node' with the given namespace. This will
+// simply call Cacher.EvictNS.
+func (r *Cache) EvictNS(ns uint64) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return
+	}
+
+	if r.cacher != nil {
+		r.cacher.EvictNS(ns)
+	}
+}
+
+// EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
+func (r *Cache) EvictAll() {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return
+	}
+
+	if r.cacher != nil {
+		r.cacher.EvictAll()
+	}
+}
+
+// Close closes the 'cache map' and releases all 'cache node'.
+func (r *Cache) Close() error {
+	r.mu.Lock()
+	if !r.closed {
+		r.closed = true
+
+		if r.cacher != nil {
+			if err := r.cacher.Close(); err != nil {
+				return err
+			}
+		}
+
+		h := (*mNode)(r.mHead)
+		h.initBuckets()
+
+		for i := range h.buckets {
+			b := (*mBucket)(h.buckets[i])
+			for _, n := range b.node {
+				// Call releaser.
+				if n.value != nil {
+					if r, ok := n.value.(util.Releaser); ok {
+						r.Release()
+					}
+					n.value = nil
+				}
+
+				// Call OnDel.
+				for _, f := range n.onDel {
+					f()
+				}
+			}
+		}
+	}
+	r.mu.Unlock()
+	return nil
+}
+
+// Node is a 'cache node'.
+type Node struct {
+	r *Cache
+
+	hash    uint32
+	ns, key uint64
+
+	mu    sync.Mutex
+	size  int
+	value Value
+
+	ref   int32
+	onDel []func()
+
+	CacheData unsafe.Pointer
+}
+
+// NS returns this 'cache node' namespace.
+func (n *Node) NS() uint64 {
+	return n.ns
+}
+
+// Key returns this 'cache node' key.
+func (n *Node) Key() uint64 {
+	return n.key
+}
+
+// Size returns this 'cache node' size.
+func (n *Node) Size() int {
+	return n.size
+}
+
+// Value returns this 'cache node' value.
+func (n *Node) Value() Value {
+	return n.value
+}
+
+// Ref returns this 'cache node' ref counter.
+func (n *Node) Ref() int32 {
+	return atomic.LoadInt32(&n.ref)
+}
+
+// GetHandle returns an handle for this 'cache node'.
+func (n *Node) GetHandle() *Handle {
+	if atomic.AddInt32(&n.ref, 1) <= 1 {
+		panic("BUG: Node.GetHandle on zero ref")
+	}
+	return &Handle{unsafe.Pointer(n)}
+}
+
+func (n *Node) unref() {
+	if atomic.AddInt32(&n.ref, -1) == 0 {
+		n.r.delete(n)
+	}
+}
+
+func (n *Node) unrefLocked() {
+	if atomic.AddInt32(&n.ref, -1) == 0 {
+		n.r.mu.RLock()
+		if !n.r.closed {
+			n.r.delete(n)
+		}
+		n.r.mu.RUnlock()
+	}
+}
+
+type Handle struct {
+	n unsafe.Pointer // *Node
+}
+
+func (h *Handle) Value() Value {
+	n := (*Node)(atomic.LoadPointer(&h.n))
+	if n != nil {
+		return n.value
+	}
+	return nil
+}
+
+func (h *Handle) Release() {
+	nPtr := atomic.LoadPointer(&h.n)
+	if nPtr != nil && atomic.CompareAndSwapPointer(&h.n, nPtr, nil) {
+		n := (*Node)(nPtr)
+		n.unrefLocked()
+	}
+}
+
+func murmur32(ns, key uint64, seed uint32) uint32 {
+	const (
+		m = uint32(0x5bd1e995)
+		r = 24
+	)
+
+	k1 := uint32(ns >> 32)
+	k2 := uint32(ns)
+	k3 := uint32(key >> 32)
+	k4 := uint32(key)
+
+	k1 *= m
+	k1 ^= k1 >> r
+	k1 *= m
+
+	k2 *= m
+	k2 ^= k2 >> r
+	k2 *= m
+
+	k3 *= m
+	k3 ^= k3 >> r
+	k3 *= m
+
+	k4 *= m
+	k4 ^= k4 >> r
+	k4 *= m
+
+	h := seed
+
+	h *= m
+	h ^= k1
+	h *= m
+	h ^= k2
+	h *= m
+	h ^= k3
+	h *= m
+	h ^= k4
+
+	h ^= h >> 13
+	h *= m
+	h ^= h >> 15
+
+	return h
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/cache/lru.go b/vendor/github.com/syndtr/goleveldb/leveldb/cache/lru.go
new file mode 100644
index 00000000..d9a84cde
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/cache/lru.go
@@ -0,0 +1,195 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package cache
+
+import (
+	"sync"
+	"unsafe"
+)
+
+type lruNode struct {
+	n   *Node
+	h   *Handle
+	ban bool
+
+	next, prev *lruNode
+}
+
+func (n *lruNode) insert(at *lruNode) {
+	x := at.next
+	at.next = n
+	n.prev = at
+	n.next = x
+	x.prev = n
+}
+
+func (n *lruNode) remove() {
+	if n.prev != nil {
+		n.prev.next = n.next
+		n.next.prev = n.prev
+		n.prev = nil
+		n.next = nil
+	} else {
+		panic("BUG: removing removed node")
+	}
+}
+
+type lru struct {
+	mu       sync.Mutex
+	capacity int
+	used     int
+	recent   lruNode
+}
+
+func (r *lru) reset() {
+	r.recent.next = &r.recent
+	r.recent.prev = &r.recent
+	r.used = 0
+}
+
+func (r *lru) Capacity() int {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.capacity
+}
+
+func (r *lru) SetCapacity(capacity int) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	r.capacity = capacity
+	for r.used > r.capacity {
+		rn := r.recent.prev
+		if rn == nil {
+			panic("BUG: invalid LRU used or capacity counter")
+		}
+		rn.remove()
+		rn.n.CacheData = nil
+		r.used -= rn.n.Size()
+		evicted = append(evicted, rn)
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Promote(n *Node) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	if n.CacheData == nil {
+		if n.Size() <= r.capacity {
+			rn := &lruNode{n: n, h: n.GetHandle()}
+			rn.insert(&r.recent)
+			n.CacheData = unsafe.Pointer(rn)
+			r.used += n.Size()
+
+			for r.used > r.capacity {
+				rn := r.recent.prev
+				if rn == nil {
+					panic("BUG: invalid LRU used or capacity counter")
+				}
+				rn.remove()
+				rn.n.CacheData = nil
+				r.used -= rn.n.Size()
+				evicted = append(evicted, rn)
+			}
+		}
+	} else {
+		rn := (*lruNode)(n.CacheData)
+		if !rn.ban {
+			rn.remove()
+			rn.insert(&r.recent)
+		}
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Ban(n *Node) {
+	r.mu.Lock()
+	if n.CacheData == nil {
+		n.CacheData = unsafe.Pointer(&lruNode{n: n, ban: true})
+	} else {
+		rn := (*lruNode)(n.CacheData)
+		if !rn.ban {
+			rn.remove()
+			rn.ban = true
+			r.used -= rn.n.Size()
+			r.mu.Unlock()
+
+			rn.h.Release()
+			rn.h = nil
+			return
+		}
+	}
+	r.mu.Unlock()
+}
+
+func (r *lru) Evict(n *Node) {
+	r.mu.Lock()
+	rn := (*lruNode)(n.CacheData)
+	if rn == nil || rn.ban {
+		r.mu.Unlock()
+		return
+	}
+	n.CacheData = nil
+	r.mu.Unlock()
+
+	rn.h.Release()
+}
+
+func (r *lru) EvictNS(ns uint64) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	for e := r.recent.prev; e != &r.recent; {
+		rn := e
+		e = e.prev
+		if rn.n.NS() == ns {
+			rn.remove()
+			rn.n.CacheData = nil
+			r.used -= rn.n.Size()
+			evicted = append(evicted, rn)
+		}
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) EvictAll() {
+	r.mu.Lock()
+	back := r.recent.prev
+	for rn := back; rn != &r.recent; rn = rn.prev {
+		rn.n.CacheData = nil
+	}
+	r.reset()
+	r.mu.Unlock()
+
+	for rn := back; rn != &r.recent; rn = rn.prev {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Close() error {
+	return nil
+}
+
+// NewLRU create a new LRU-cache.
+func NewLRU(capacity int) Cacher {
+	r := &lru{capacity: capacity}
+	r.reset()
+	return r
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/comparer.go b/vendor/github.com/syndtr/goleveldb/leveldb/comparer.go
new file mode 100644
index 00000000..d33d5e9c
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/comparer.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import "github.com/syndtr/goleveldb/leveldb/comparer"
+
+type iComparer struct {
+	ucmp comparer.Comparer
+}
+
+func (icmp *iComparer) uName() string {
+	return icmp.ucmp.Name()
+}
+
+func (icmp *iComparer) uCompare(a, b []byte) int {
+	return icmp.ucmp.Compare(a, b)
+}
+
+func (icmp *iComparer) uSeparator(dst, a, b []byte) []byte {
+	return icmp.ucmp.Separator(dst, a, b)
+}
+
+func (icmp *iComparer) uSuccessor(dst, b []byte) []byte {
+	return icmp.ucmp.Successor(dst, b)
+}
+
+func (icmp *iComparer) Name() string {
+	return icmp.uName()
+}
+
+func (icmp *iComparer) Compare(a, b []byte) int {
+	x := icmp.ucmp.Compare(iKey(a).ukey(), iKey(b).ukey())
+	if x == 0 {
+		if m, n := iKey(a).num(), iKey(b).num(); m > n {
+			x = -1
+		} else if m < n {
+			x = 1
+		}
+	}
+	return x
+}
+
+func (icmp *iComparer) Separator(dst, a, b []byte) []byte {
+	ua, ub := iKey(a).ukey(), iKey(b).ukey()
+	dst = icmp.ucmp.Separator(dst, ua, ub)
+	if dst == nil {
+		return nil
+	}
+	if len(dst) < len(ua) && icmp.uCompare(ua, dst) < 0 {
+		dst = append(dst, kMaxNumBytes...)
+	} else {
+		// Did not close possibilities that n maybe longer than len(ub).
+		dst = append(dst, a[len(a)-8:]...)
+	}
+	return dst
+}
+
+func (icmp *iComparer) Successor(dst, b []byte) []byte {
+	ub := iKey(b).ukey()
+	dst = icmp.ucmp.Successor(dst, ub)
+	if dst == nil {
+		return nil
+	}
+	if len(dst) < len(ub) && icmp.uCompare(ub, dst) < 0 {
+		dst = append(dst, kMaxNumBytes...)
+	} else {
+		// Did not close possibilities that n maybe longer than len(ub).
+		dst = append(dst, b[len(b)-8:]...)
+	}
+	return dst
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/comparer/bytes_comparer.go b/vendor/github.com/syndtr/goleveldb/leveldb/comparer/bytes_comparer.go
new file mode 100644
index 00000000..14dddf88
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/comparer/bytes_comparer.go
@@ -0,0 +1,51 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package comparer
+
+import "bytes"
+
+type bytesComparer struct{}
+
+func (bytesComparer) Compare(a, b []byte) int {
+	return bytes.Compare(a, b)
+}
+
+func (bytesComparer) Name() string {
+	return "leveldb.BytewiseComparator"
+}
+
+func (bytesComparer) Separator(dst, a, b []byte) []byte {
+	i, n := 0, len(a)
+	if n > len(b) {
+		n = len(b)
+	}
+	for ; i < n && a[i] == b[i]; i++ {
+	}
+	if i >= n {
+		// Do not shorten if one string is a prefix of the other
+	} else if c := a[i]; c < 0xff && c+1 < b[i] {
+		dst = append(dst, a[:i+1]...)
+		dst[i]++
+		return dst
+	}
+	return nil
+}
+
+func (bytesComparer) Successor(dst, b []byte) []byte {
+	for i, c := range b {
+		if c != 0xff {
+			dst = append(dst, b[:i+1]...)
+			dst[i]++
+			return dst
+		}
+	}
+	return nil
+}
+
+// DefaultComparer are default implementation of the Comparer interface.
+// It uses the natural ordering, consistent with bytes.Compare.
+var DefaultComparer = bytesComparer{}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/comparer/comparer.go b/vendor/github.com/syndtr/goleveldb/leveldb/comparer/comparer.go
new file mode 100644
index 00000000..14a28f16
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/comparer/comparer.go
@@ -0,0 +1,57 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package comparer provides interface and implementation for ordering
+// sets of data.
+package comparer
+
+// BasicComparer is the interface that wraps the basic Compare method.
+type BasicComparer interface {
+	// Compare returns -1, 0, or +1 depending on whether a is 'less than',
+	// 'equal to' or 'greater than' b. The two arguments can only be 'equal'
+	// if their contents are exactly equal. Furthermore, the empty slice
+	// must be 'less than' any non-empty slice.
+	Compare(a, b []byte) int
+}
+
+// Comparer defines a total ordering over the space of []byte keys: a 'less
+// than' relationship.
+type Comparer interface {
+	BasicComparer
+
+	// Name returns name of the comparer.
+	//
+	// The Level-DB on-disk format stores the comparer name, and opening a
+	// database with a different comparer from the one it was created with
+	// will result in an error.
+	//
+	// An implementation to a new name whenever the comparer implementation
+	// changes in a way that will cause the relative ordering of any two keys
+	// to change.
+	//
+	// Names starting with "leveldb." are reserved and should not be used
+	// by any users of this package.
+	Name() string
+
+	// Bellow are advanced functions used used to reduce the space requirements
+	// for internal data structures such as index blocks.
+
+	// Separator appends a sequence of bytes x to dst such that a <= x && x < b,
+	// where 'less than' is consistent with Compare. An implementation should
+	// return nil if x equal to a.
+	//
+	// Either contents of a or b should not by any means modified. Doing so
+	// may cause corruption on the internal state.
+	Separator(dst, a, b []byte) []byte
+
+	// Successor appends a sequence of bytes x to dst such that x >= b, where
+	// 'less than' is consistent with Compare. An implementation should return
+	// nil if x equal to b.
+	//
+	// Contents of b should not by any means modified. Doing so may cause
+	// corruption on the internal state.
+	Successor(dst, b []byte) []byte
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db.go b/vendor/github.com/syndtr/goleveldb/leveldb/db.go
new file mode 100644
index 00000000..def86bc1
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db.go
@@ -0,0 +1,1068 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"container/list"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/journal"
+	"github.com/syndtr/goleveldb/leveldb/memdb"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/table"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// DB is a LevelDB database.
+type DB struct {
+	// Need 64-bit alignment.
+	seq uint64
+
+	// Session.
+	s *session
+
+	// MemDB.
+	memMu             sync.RWMutex
+	memPool           chan *memdb.DB
+	mem, frozenMem    *memDB
+	journal           *journal.Writer
+	journalWriter     storage.Writer
+	journalFile       storage.File
+	frozenJournalFile storage.File
+	frozenSeq         uint64
+
+	// Snapshot.
+	snapsMu   sync.Mutex
+	snapsList *list.List
+
+	// Stats.
+	aliveSnaps, aliveIters int32
+
+	// Write.
+	writeC       chan *Batch
+	writeMergedC chan bool
+	writeLockC   chan struct{}
+	writeAckC    chan error
+	writeDelay   time.Duration
+	writeDelayN  int
+	journalC     chan *Batch
+	journalAckC  chan error
+
+	// Compaction.
+	tcompCmdC        chan cCmd
+	tcompPauseC      chan chan<- struct{}
+	mcompCmdC        chan cCmd
+	compErrC         chan error
+	compPerErrC      chan error
+	compErrSetC      chan error
+	compWriteLocking bool
+	compStats        []cStats
+
+	// Close.
+	closeW sync.WaitGroup
+	closeC chan struct{}
+	closed uint32
+	closer io.Closer
+}
+
+func openDB(s *session) (*DB, error) {
+	s.log("db@open opening")
+	start := time.Now()
+	db := &DB{
+		s: s,
+		// Initial sequence
+		seq: s.stSeqNum,
+		// MemDB
+		memPool: make(chan *memdb.DB, 1),
+		// Snapshot
+		snapsList: list.New(),
+		// Write
+		writeC:       make(chan *Batch),
+		writeMergedC: make(chan bool),
+		writeLockC:   make(chan struct{}, 1),
+		writeAckC:    make(chan error),
+		journalC:     make(chan *Batch),
+		journalAckC:  make(chan error),
+		// Compaction
+		tcompCmdC:   make(chan cCmd),
+		tcompPauseC: make(chan chan<- struct{}),
+		mcompCmdC:   make(chan cCmd),
+		compErrC:    make(chan error),
+		compPerErrC: make(chan error),
+		compErrSetC: make(chan error),
+		compStats:   make([]cStats, s.o.GetNumLevel()),
+		// Close
+		closeC: make(chan struct{}),
+	}
+
+	// Read-only mode.
+	readOnly := s.o.GetReadOnly()
+
+	if readOnly {
+		// Recover journals (read-only mode).
+		if err := db.recoverJournalRO(); err != nil {
+			return nil, err
+		}
+	} else {
+		// Recover journals.
+		if err := db.recoverJournal(); err != nil {
+			return nil, err
+		}
+
+		// Remove any obsolete files.
+		if err := db.checkAndCleanFiles(); err != nil {
+			// Close journal.
+			if db.journal != nil {
+				db.journal.Close()
+				db.journalWriter.Close()
+			}
+			return nil, err
+		}
+
+	}
+
+	// Doesn't need to be included in the wait group.
+	go db.compactionError()
+	go db.mpoolDrain()
+
+	if readOnly {
+		db.SetReadOnly()
+	} else {
+		db.closeW.Add(3)
+		go db.tCompaction()
+		go db.mCompaction()
+		go db.jWriter()
+	}
+
+	s.logf("db@open done T·%v", time.Since(start))
+
+	runtime.SetFinalizer(db, (*DB).Close)
+	return db, nil
+}
+
+// Open opens or creates a DB for the given storage.
+// The DB will be created if not exist, unless ErrorIfMissing is true.
+// Also, if ErrorIfExist is true and the DB exist Open will returns
+// os.ErrExist error.
+//
+// Open will return an error with type of ErrCorrupted if corruption
+// detected in the DB. Corrupted DB can be recovered with Recover
+// function.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func Open(stor storage.Storage, o *opt.Options) (db *DB, err error) {
+	s, err := newSession(stor, o)
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			s.close()
+			s.release()
+		}
+	}()
+
+	err = s.recover()
+	if err != nil {
+		if !os.IsNotExist(err) || s.o.GetErrorIfMissing() {
+			return
+		}
+		err = s.create()
+		if err != nil {
+			return
+		}
+	} else if s.o.GetErrorIfExist() {
+		err = os.ErrExist
+		return
+	}
+
+	return openDB(s)
+}
+
+// OpenFile opens or creates a DB for the given path.
+// The DB will be created if not exist, unless ErrorIfMissing is true.
+// Also, if ErrorIfExist is true and the DB exist OpenFile will returns
+// os.ErrExist error.
+//
+// OpenFile uses standard file-system backed storage implementation as
+// desribed in the leveldb/storage package.
+//
+// OpenFile will return an error with type of ErrCorrupted if corruption
+// detected in the DB. Corrupted DB can be recovered with Recover
+// function.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func OpenFile(path string, o *opt.Options) (db *DB, err error) {
+	stor, err := storage.OpenFile(path)
+	if err != nil {
+		return
+	}
+	db, err = Open(stor, o)
+	if err != nil {
+		stor.Close()
+	} else {
+		db.closer = stor
+	}
+	return
+}
+
+// Recover recovers and opens a DB with missing or corrupted manifest files
+// for the given storage. It will ignore any manifest files, valid or not.
+// The DB must already exist or it will returns an error.
+// Also, Recover will ignore ErrorIfMissing and ErrorIfExist options.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func Recover(stor storage.Storage, o *opt.Options) (db *DB, err error) {
+	s, err := newSession(stor, o)
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			s.close()
+			s.release()
+		}
+	}()
+
+	err = recoverTable(s, o)
+	if err != nil {
+		return
+	}
+	return openDB(s)
+}
+
+// RecoverFile recovers and opens a DB with missing or corrupted manifest files
+// for the given path. It will ignore any manifest files, valid or not.
+// The DB must already exist or it will returns an error.
+// Also, Recover will ignore ErrorIfMissing and ErrorIfExist options.
+//
+// RecoverFile uses standard file-system backed storage implementation as desribed
+// in the leveldb/storage package.
+//
+// The returned DB instance is goroutine-safe.
+// The DB must be closed after use, by calling Close method.
+func RecoverFile(path string, o *opt.Options) (db *DB, err error) {
+	stor, err := storage.OpenFile(path)
+	if err != nil {
+		return
+	}
+	db, err = Recover(stor, o)
+	if err != nil {
+		stor.Close()
+	} else {
+		db.closer = stor
+	}
+	return
+}
+
+func recoverTable(s *session, o *opt.Options) error {
+	o = dupOptions(o)
+	// Mask StrictReader, lets StrictRecovery doing its job.
+	o.Strict &= ^opt.StrictReader
+
+	// Get all tables and sort it by file number.
+	tableFiles_, err := s.getFiles(storage.TypeTable)
+	if err != nil {
+		return err
+	}
+	tableFiles := files(tableFiles_)
+	tableFiles.sort()
+
+	var (
+		maxSeq                                                            uint64
+		recoveredKey, goodKey, corruptedKey, corruptedBlock, droppedTable int
+
+		// We will drop corrupted table.
+		strict = o.GetStrict(opt.StrictRecovery)
+
+		rec   = &sessionRecord{}
+		bpool = util.NewBufferPool(o.GetBlockSize() + 5)
+	)
+	buildTable := func(iter iterator.Iterator) (tmp storage.File, size int64, err error) {
+		tmp = s.newTemp()
+		writer, err := tmp.Create()
+		if err != nil {
+			return
+		}
+		defer func() {
+			writer.Close()
+			if err != nil {
+				tmp.Remove()
+				tmp = nil
+			}
+		}()
+
+		// Copy entries.
+		tw := table.NewWriter(writer, o)
+		for iter.Next() {
+			key := iter.Key()
+			if validIkey(key) {
+				err = tw.Append(key, iter.Value())
+				if err != nil {
+					return
+				}
+			}
+		}
+		err = iter.Error()
+		if err != nil {
+			return
+		}
+		err = tw.Close()
+		if err != nil {
+			return
+		}
+		err = writer.Sync()
+		if err != nil {
+			return
+		}
+		size = int64(tw.BytesLen())
+		return
+	}
+	recoverTable := func(file storage.File) error {
+		s.logf("table@recovery recovering @%d", file.Num())
+		reader, err := file.Open()
+		if err != nil {
+			return err
+		}
+		var closed bool
+		defer func() {
+			if !closed {
+				reader.Close()
+			}
+		}()
+
+		// Get file size.
+		size, err := reader.Seek(0, 2)
+		if err != nil {
+			return err
+		}
+
+		var (
+			tSeq                                     uint64
+			tgoodKey, tcorruptedKey, tcorruptedBlock int
+			imin, imax                               []byte
+		)
+		tr, err := table.NewReader(reader, size, storage.NewFileInfo(file), nil, bpool, o)
+		if err != nil {
+			return err
+		}
+		iter := tr.NewIterator(nil, nil)
+		if itererr, ok := iter.(iterator.ErrorCallbackSetter); ok {
+			itererr.SetErrorCallback(func(err error) {
+				if errors.IsCorrupted(err) {
+					s.logf("table@recovery block corruption @%d %q", file.Num(), err)
+					tcorruptedBlock++
+				}
+			})
+		}
+
+		// Scan the table.
+		for iter.Next() {
+			key := iter.Key()
+			_, seq, _, kerr := parseIkey(key)
+			if kerr != nil {
+				tcorruptedKey++
+				continue
+			}
+			tgoodKey++
+			if seq > tSeq {
+				tSeq = seq
+			}
+			if imin == nil {
+				imin = append([]byte{}, key...)
+			}
+			imax = append(imax[:0], key...)
+		}
+		if err := iter.Error(); err != nil {
+			iter.Release()
+			return err
+		}
+		iter.Release()
+
+		goodKey += tgoodKey
+		corruptedKey += tcorruptedKey
+		corruptedBlock += tcorruptedBlock
+
+		if strict && (tcorruptedKey > 0 || tcorruptedBlock > 0) {
+			droppedTable++
+			s.logf("table@recovery dropped @%d Gk·%d Ck·%d Cb·%d S·%d Q·%d", file.Num(), tgoodKey, tcorruptedKey, tcorruptedBlock, size, tSeq)
+			return nil
+		}
+
+		if tgoodKey > 0 {
+			if tcorruptedKey > 0 || tcorruptedBlock > 0 {
+				// Rebuild the table.
+				s.logf("table@recovery rebuilding @%d", file.Num())
+				iter := tr.NewIterator(nil, nil)
+				tmp, newSize, err := buildTable(iter)
+				iter.Release()
+				if err != nil {
+					return err
+				}
+				closed = true
+				reader.Close()
+				if err := file.Replace(tmp); err != nil {
+					return err
+				}
+				size = newSize
+			}
+			if tSeq > maxSeq {
+				maxSeq = tSeq
+			}
+			recoveredKey += tgoodKey
+			// Add table to level 0.
+			rec.addTable(0, file.Num(), uint64(size), imin, imax)
+			s.logf("table@recovery recovered @%d Gk·%d Ck·%d Cb·%d S·%d Q·%d", file.Num(), tgoodKey, tcorruptedKey, tcorruptedBlock, size, tSeq)
+		} else {
+			droppedTable++
+			s.logf("table@recovery unrecoverable @%d Ck·%d Cb·%d S·%d", file.Num(), tcorruptedKey, tcorruptedBlock, size)
+		}
+
+		return nil
+	}
+
+	// Recover all tables.
+	if len(tableFiles) > 0 {
+		s.logf("table@recovery F·%d", len(tableFiles))
+
+		// Mark file number as used.
+		s.markFileNum(tableFiles[len(tableFiles)-1].Num())
+
+		for _, file := range tableFiles {
+			if err := recoverTable(file); err != nil {
+				return err
+			}
+		}
+
+		s.logf("table@recovery recovered F·%d N·%d Gk·%d Ck·%d Q·%d", len(tableFiles), recoveredKey, goodKey, corruptedKey, maxSeq)
+	}
+
+	// Set sequence number.
+	rec.setSeqNum(maxSeq)
+
+	// Create new manifest.
+	if err := s.create(); err != nil {
+		return err
+	}
+
+	// Commit.
+	return s.commit(rec)
+}
+
+func (db *DB) recoverJournal() error {
+	// Get all journals and sort it by file number.
+	allJournalFiles, err := db.s.getFiles(storage.TypeJournal)
+	if err != nil {
+		return err
+	}
+	files(allJournalFiles).sort()
+
+	// Journals that will be recovered.
+	var recJournalFiles []storage.File
+	for _, jf := range allJournalFiles {
+		if jf.Num() >= db.s.stJournalNum || jf.Num() == db.s.stPrevJournalNum {
+			recJournalFiles = append(recJournalFiles, jf)
+		}
+	}
+
+	var (
+		of  storage.File // Obsolete file.
+		rec = &sessionRecord{}
+	)
+
+	// Recover journals.
+	if len(recJournalFiles) > 0 {
+		db.logf("journal@recovery F·%d", len(recJournalFiles))
+
+		// Mark file number as used.
+		db.s.markFileNum(recJournalFiles[len(recJournalFiles)-1].Num())
+
+		var (
+			// Options.
+			strict      = db.s.o.GetStrict(opt.StrictJournal)
+			checksum    = db.s.o.GetStrict(opt.StrictJournalChecksum)
+			writeBuffer = db.s.o.GetWriteBuffer()
+
+			jr    *journal.Reader
+			mdb   = memdb.New(db.s.icmp, writeBuffer)
+			buf   = &util.Buffer{}
+			batch = &Batch{}
+		)
+
+		for _, jf := range recJournalFiles {
+			db.logf("journal@recovery recovering @%d", jf.Num())
+
+			fr, err := jf.Open()
+			if err != nil {
+				return err
+			}
+
+			// Create or reset journal reader instance.
+			if jr == nil {
+				jr = journal.NewReader(fr, dropper{db.s, jf}, strict, checksum)
+			} else {
+				jr.Reset(fr, dropper{db.s, jf}, strict, checksum)
+			}
+
+			// Flush memdb and remove obsolete journal file.
+			if of != nil {
+				if mdb.Len() > 0 {
+					if _, err := db.s.flushMemdb(rec, mdb, -1); err != nil {
+						fr.Close()
+						return err
+					}
+				}
+
+				rec.setJournalNum(jf.Num())
+				rec.setSeqNum(db.seq)
+				if err := db.s.commit(rec); err != nil {
+					fr.Close()
+					return err
+				}
+				rec.resetAddedTables()
+
+				of.Remove()
+				of = nil
+			}
+
+			// Replay journal to memdb.
+			mdb.Reset()
+			for {
+				r, err := jr.Next()
+				if err != nil {
+					if err == io.EOF {
+						break
+					}
+
+					fr.Close()
+					return errors.SetFile(err, jf)
+				}
+
+				buf.Reset()
+				if _, err := buf.ReadFrom(r); err != nil {
+					if err == io.ErrUnexpectedEOF {
+						// This is error returned due to corruption, with strict == false.
+						continue
+					}
+
+					fr.Close()
+					return errors.SetFile(err, jf)
+				}
+				if err := batch.memDecodeAndReplay(db.seq, buf.Bytes(), mdb); err != nil {
+					if !strict && errors.IsCorrupted(err) {
+						db.s.logf("journal error: %v (skipped)", err)
+						// We won't apply sequence number as it might be corrupted.
+						continue
+					}
+
+					fr.Close()
+					return errors.SetFile(err, jf)
+				}
+
+				// Save sequence number.
+				db.seq = batch.seq + uint64(batch.Len())
+
+				// Flush it if large enough.
+				if mdb.Size() >= writeBuffer {
+					if _, err := db.s.flushMemdb(rec, mdb, 0); err != nil {
+						fr.Close()
+						return err
+					}
+
+					mdb.Reset()
+				}
+			}
+
+			fr.Close()
+			of = jf
+		}
+
+		// Flush the last memdb.
+		if mdb.Len() > 0 {
+			if _, err := db.s.flushMemdb(rec, mdb, 0); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Create a new journal.
+	if _, err := db.newMem(0); err != nil {
+		return err
+	}
+
+	// Commit.
+	rec.setJournalNum(db.journalFile.Num())
+	rec.setSeqNum(db.seq)
+	if err := db.s.commit(rec); err != nil {
+		// Close journal on error.
+		if db.journal != nil {
+			db.journal.Close()
+			db.journalWriter.Close()
+		}
+		return err
+	}
+
+	// Remove the last obsolete journal file.
+	if of != nil {
+		of.Remove()
+	}
+
+	return nil
+}
+
+func (db *DB) recoverJournalRO() error {
+	// Get all journals and sort it by file number.
+	allJournalFiles, err := db.s.getFiles(storage.TypeJournal)
+	if err != nil {
+		return err
+	}
+	files(allJournalFiles).sort()
+
+	// Journals that will be recovered.
+	var recJournalFiles []storage.File
+	for _, jf := range allJournalFiles {
+		if jf.Num() >= db.s.stJournalNum || jf.Num() == db.s.stPrevJournalNum {
+			recJournalFiles = append(recJournalFiles, jf)
+		}
+	}
+
+	var (
+		// Options.
+		strict      = db.s.o.GetStrict(opt.StrictJournal)
+		checksum    = db.s.o.GetStrict(opt.StrictJournalChecksum)
+		writeBuffer = db.s.o.GetWriteBuffer()
+
+		mdb = memdb.New(db.s.icmp, writeBuffer)
+	)
+
+	// Recover journals.
+	if len(recJournalFiles) > 0 {
+		db.logf("journal@recovery RO·Mode F·%d", len(recJournalFiles))
+
+		var (
+			jr    *journal.Reader
+			buf   = &util.Buffer{}
+			batch = &Batch{}
+		)
+
+		for _, jf := range recJournalFiles {
+			db.logf("journal@recovery recovering @%d", jf.Num())
+
+			fr, err := jf.Open()
+			if err != nil {
+				return err
+			}
+
+			// Create or reset journal reader instance.
+			if jr == nil {
+				jr = journal.NewReader(fr, dropper{db.s, jf}, strict, checksum)
+			} else {
+				jr.Reset(fr, dropper{db.s, jf}, strict, checksum)
+			}
+
+			// Replay journal to memdb.
+			for {
+				r, err := jr.Next()
+				if err != nil {
+					if err == io.EOF {
+						break
+					}
+
+					fr.Close()
+					return errors.SetFile(err, jf)
+				}
+
+				buf.Reset()
+				if _, err := buf.ReadFrom(r); err != nil {
+					if err == io.ErrUnexpectedEOF {
+						// This is error returned due to corruption, with strict == false.
+						continue
+					}
+
+					fr.Close()
+					return errors.SetFile(err, jf)
+				}
+				if err := batch.memDecodeAndReplay(db.seq, buf.Bytes(), mdb); err != nil {
+					if !strict && errors.IsCorrupted(err) {
+						db.s.logf("journal error: %v (skipped)", err)
+						// We won't apply sequence number as it might be corrupted.
+						continue
+					}
+
+					fr.Close()
+					return errors.SetFile(err, jf)
+				}
+
+				// Save sequence number.
+				db.seq = batch.seq + uint64(batch.Len())
+			}
+
+			fr.Close()
+		}
+	}
+
+	// Set memDB.
+	db.mem = &memDB{db: db, DB: mdb, ref: 1}
+
+	return nil
+}
+
+func (db *DB) get(key []byte, seq uint64, ro *opt.ReadOptions) (value []byte, err error) {
+	ikey := newIkey(key, seq, ktSeek)
+
+	em, fm := db.getMems()
+	for _, m := range [...]*memDB{em, fm} {
+		if m == nil {
+			continue
+		}
+		defer m.decref()
+
+		mk, mv, me := m.Find(ikey)
+		if me == nil {
+			ukey, _, kt, kerr := parseIkey(mk)
+			if kerr != nil {
+				// Shouldn't have had happen.
+				panic(kerr)
+			}
+			if db.s.icmp.uCompare(ukey, key) == 0 {
+				if kt == ktDel {
+					return nil, ErrNotFound
+				}
+				return append([]byte{}, mv...), nil
+			}
+		} else if me != ErrNotFound {
+			return nil, me
+		}
+	}
+
+	v := db.s.version()
+	value, cSched, err := v.get(ikey, ro, false)
+	v.release()
+	if cSched {
+		// Trigger table compaction.
+		db.compSendTrigger(db.tcompCmdC)
+	}
+	return
+}
+
+func (db *DB) has(key []byte, seq uint64, ro *opt.ReadOptions) (ret bool, err error) {
+	ikey := newIkey(key, seq, ktSeek)
+
+	em, fm := db.getMems()
+	for _, m := range [...]*memDB{em, fm} {
+		if m == nil {
+			continue
+		}
+		defer m.decref()
+
+		mk, _, me := m.Find(ikey)
+		if me == nil {
+			ukey, _, kt, kerr := parseIkey(mk)
+			if kerr != nil {
+				// Shouldn't have had happen.
+				panic(kerr)
+			}
+			if db.s.icmp.uCompare(ukey, key) == 0 {
+				if kt == ktDel {
+					return false, nil
+				}
+				return true, nil
+			}
+		} else if me != ErrNotFound {
+			return false, me
+		}
+	}
+
+	v := db.s.version()
+	_, cSched, err := v.get(ikey, ro, true)
+	v.release()
+	if cSched {
+		// Trigger table compaction.
+		db.compSendTrigger(db.tcompCmdC)
+	}
+	if err == nil {
+		ret = true
+	} else if err == ErrNotFound {
+		err = nil
+	}
+	return
+}
+
+// Get gets the value for the given key. It returns ErrNotFound if the
+// DB does not contains the key.
+//
+// The returned slice is its own copy, it is safe to modify the contents
+// of the returned slice.
+// It is safe to modify the contents of the argument after Get returns.
+func (db *DB) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
+	err = db.ok()
+	if err != nil {
+		return
+	}
+
+	se := db.acquireSnapshot()
+	defer db.releaseSnapshot(se)
+	return db.get(key, se.seq, ro)
+}
+
+// Has returns true if the DB does contains the given key.
+//
+// It is safe to modify the contents of the argument after Get returns.
+func (db *DB) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
+	err = db.ok()
+	if err != nil {
+		return
+	}
+
+	se := db.acquireSnapshot()
+	defer db.releaseSnapshot(se)
+	return db.has(key, se.seq, ro)
+}
+
+// NewIterator returns an iterator for the latest snapshot of the
+// uderlying DB.
+// The returned iterator is not goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+// It is also safe to use an iterator concurrently with modifying its
+// underlying DB. The resultant key/value pairs are guaranteed to be
+// consistent.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// DB. And a nil Range.Limit is treated as a key after all keys in
+// the DB.
+//
+// The iterator must be released after use, by calling Release method.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (db *DB) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+	if err := db.ok(); err != nil {
+		return iterator.NewEmptyIterator(err)
+	}
+
+	se := db.acquireSnapshot()
+	defer db.releaseSnapshot(se)
+	// Iterator holds 'version' lock, 'version' is immutable so snapshot
+	// can be released after iterator created.
+	return db.newIterator(se.seq, slice, ro)
+}
+
+// GetSnapshot returns a latest snapshot of the underlying DB. A snapshot
+// is a frozen snapshot of a DB state at a particular point in time. The
+// content of snapshot are guaranteed to be consistent.
+//
+// The snapshot must be released after use, by calling Release method.
+func (db *DB) GetSnapshot() (*Snapshot, error) {
+	if err := db.ok(); err != nil {
+		return nil, err
+	}
+
+	return db.newSnapshot(), nil
+}
+
+// GetProperty returns value of the given property name.
+//
+// Property names:
+//	leveldb.num-files-at-level{n}
+//		Returns the number of files at level 'n'.
+//	leveldb.stats
+//		Returns statistics of the underlying DB.
+//	leveldb.sstables
+//		Returns sstables list for each level.
+//	leveldb.blockpool
+//		Returns block pool stats.
+//	leveldb.cachedblock
+//		Returns size of cached block.
+//	leveldb.openedtables
+//		Returns number of opened tables.
+//	leveldb.alivesnaps
+//		Returns number of alive snapshots.
+//	leveldb.aliveiters
+//		Returns number of alive iterators.
+func (db *DB) GetProperty(name string) (value string, err error) {
+	err = db.ok()
+	if err != nil {
+		return
+	}
+
+	const prefix = "leveldb."
+	if !strings.HasPrefix(name, prefix) {
+		return "", ErrNotFound
+	}
+	p := name[len(prefix):]
+
+	v := db.s.version()
+	defer v.release()
+
+	numFilesPrefix := "num-files-at-level"
+	switch {
+	case strings.HasPrefix(p, numFilesPrefix):
+		var level uint
+		var rest string
+		n, _ := fmt.Sscanf(p[len(numFilesPrefix):], "%d%s", &level, &rest)
+		if n != 1 || int(level) >= db.s.o.GetNumLevel() {
+			err = ErrNotFound
+		} else {
+			value = fmt.Sprint(v.tLen(int(level)))
+		}
+	case p == "stats":
+		value = "Compactions\n" +
+			" Level |   Tables   |    Size(MB)   |    Time(sec)  |    Read(MB)   |   Write(MB)\n" +
+			"-------+------------+---------------+---------------+---------------+---------------\n"
+		for level, tables := range v.tables {
+			duration, read, write := db.compStats[level].get()
+			if len(tables) == 0 && duration == 0 {
+				continue
+			}
+			value += fmt.Sprintf(" %3d   | %10d | %13.5f | %13.5f | %13.5f | %13.5f\n",
+				level, len(tables), float64(tables.size())/1048576.0, duration.Seconds(),
+				float64(read)/1048576.0, float64(write)/1048576.0)
+		}
+	case p == "sstables":
+		for level, tables := range v.tables {
+			value += fmt.Sprintf("--- level %d ---\n", level)
+			for _, t := range tables {
+				value += fmt.Sprintf("%d:%d[%q .. %q]\n", t.file.Num(), t.size, t.imin, t.imax)
+			}
+		}
+	case p == "blockpool":
+		value = fmt.Sprintf("%v", db.s.tops.bpool)
+	case p == "cachedblock":
+		if db.s.tops.bcache != nil {
+			value = fmt.Sprintf("%d", db.s.tops.bcache.Size())
+		} else {
+			value = "<nil>"
+		}
+	case p == "openedtables":
+		value = fmt.Sprintf("%d", db.s.tops.cache.Size())
+	case p == "alivesnaps":
+		value = fmt.Sprintf("%d", atomic.LoadInt32(&db.aliveSnaps))
+	case p == "aliveiters":
+		value = fmt.Sprintf("%d", atomic.LoadInt32(&db.aliveIters))
+	default:
+		err = ErrNotFound
+	}
+
+	return
+}
+
+// SizeOf calculates approximate sizes of the given key ranges.
+// The length of the returned sizes are equal with the length of the given
+// ranges. The returned sizes measure storage space usage, so if the user
+// data compresses by a factor of ten, the returned sizes will be one-tenth
+// the size of the corresponding user data size.
+// The results may not include the sizes of recently written data.
+func (db *DB) SizeOf(ranges []util.Range) (Sizes, error) {
+	if err := db.ok(); err != nil {
+		return nil, err
+	}
+
+	v := db.s.version()
+	defer v.release()
+
+	sizes := make(Sizes, 0, len(ranges))
+	for _, r := range ranges {
+		imin := newIkey(r.Start, kMaxSeq, ktSeek)
+		imax := newIkey(r.Limit, kMaxSeq, ktSeek)
+		start, err := v.offsetOf(imin)
+		if err != nil {
+			return nil, err
+		}
+		limit, err := v.offsetOf(imax)
+		if err != nil {
+			return nil, err
+		}
+		var size uint64
+		if limit >= start {
+			size = limit - start
+		}
+		sizes = append(sizes, size)
+	}
+
+	return sizes, nil
+}
+
+// Close closes the DB. This will also releases any outstanding snapshot and
+// abort any in-flight compaction.
+//
+// It is not safe to close a DB until all outstanding iterators are released.
+// It is valid to call Close multiple times. Other methods should not be
+// called after the DB has been closed.
+func (db *DB) Close() error {
+	if !db.setClosed() {
+		return ErrClosed
+	}
+
+	start := time.Now()
+	db.log("db@close closing")
+
+	// Clear the finalizer.
+	runtime.SetFinalizer(db, nil)
+
+	// Get compaction error.
+	var err error
+	select {
+	case err = <-db.compErrC:
+		if err == ErrReadOnly {
+			err = nil
+		}
+	default:
+	}
+
+	// Signal all goroutines.
+	close(db.closeC)
+
+	// Wait for all gorotines to exit.
+	db.closeW.Wait()
+
+	// Lock writer and closes journal.
+	db.writeLockC <- struct{}{}
+	if db.journal != nil {
+		db.journal.Close()
+		db.journalWriter.Close()
+	}
+
+	if db.writeDelayN > 0 {
+		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
+	}
+
+	// Close session.
+	db.s.close()
+	db.logf("db@close done T·%v", time.Since(start))
+	db.s.release()
+
+	if db.closer != nil {
+		if err1 := db.closer.Close(); err == nil {
+			err = err1
+		}
+	}
+
+	// NIL'ing pointers.
+	db.s = nil
+	db.mem = nil
+	db.frozenMem = nil
+	db.journal = nil
+	db.journalWriter = nil
+	db.journalFile = nil
+	db.frozenJournalFile = nil
+	db.closer = nil
+
+	return err
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_compaction.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_compaction.go
new file mode 100644
index 00000000..26003106
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_compaction.go
@@ -0,0 +1,791 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"sync"
+	"time"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+var (
+	errCompactionTransactExiting = errors.New("leveldb: compaction transact exiting")
+)
+
+type cStats struct {
+	sync.Mutex
+	duration time.Duration
+	read     uint64
+	write    uint64
+}
+
+func (p *cStats) add(n *cStatsStaging) {
+	p.Lock()
+	p.duration += n.duration
+	p.read += n.read
+	p.write += n.write
+	p.Unlock()
+}
+
+func (p *cStats) get() (duration time.Duration, read, write uint64) {
+	p.Lock()
+	defer p.Unlock()
+	return p.duration, p.read, p.write
+}
+
+type cStatsStaging struct {
+	start    time.Time
+	duration time.Duration
+	on       bool
+	read     uint64
+	write    uint64
+}
+
+func (p *cStatsStaging) startTimer() {
+	if !p.on {
+		p.start = time.Now()
+		p.on = true
+	}
+}
+
+func (p *cStatsStaging) stopTimer() {
+	if p.on {
+		p.duration += time.Since(p.start)
+		p.on = false
+	}
+}
+
+func (db *DB) compactionError() {
+	var err error
+noerr:
+	// No error.
+	for {
+		select {
+		case err = <-db.compErrSetC:
+			switch {
+			case err == nil:
+			case err == ErrReadOnly, errors.IsCorrupted(err):
+				goto hasperr
+			default:
+				goto haserr
+			}
+		case _, _ = <-db.closeC:
+			return
+		}
+	}
+haserr:
+	// Transient error.
+	for {
+		select {
+		case db.compErrC <- err:
+		case err = <-db.compErrSetC:
+			switch {
+			case err == nil:
+				goto noerr
+			case err == ErrReadOnly, errors.IsCorrupted(err):
+				goto hasperr
+			default:
+			}
+		case _, _ = <-db.closeC:
+			return
+		}
+	}
+hasperr:
+	// Persistent error.
+	for {
+		select {
+		case db.compErrC <- err:
+		case db.compPerErrC <- err:
+		case db.writeLockC <- struct{}{}:
+			// Hold write lock, so that write won't pass-through.
+			db.compWriteLocking = true
+		case _, _ = <-db.closeC:
+			if db.compWriteLocking {
+				// We should release the lock or Close will hang.
+				<-db.writeLockC
+			}
+			return
+		}
+	}
+}
+
+type compactionTransactCounter int
+
+func (cnt *compactionTransactCounter) incr() {
+	*cnt++
+}
+
+type compactionTransactInterface interface {
+	run(cnt *compactionTransactCounter) error
+	revert() error
+}
+
+func (db *DB) compactionTransact(name string, t compactionTransactInterface) {
+	defer func() {
+		if x := recover(); x != nil {
+			if x == errCompactionTransactExiting {
+				if err := t.revert(); err != nil {
+					db.logf("%s revert error %q", name, err)
+				}
+			}
+			panic(x)
+		}
+	}()
+
+	const (
+		backoffMin = 1 * time.Second
+		backoffMax = 8 * time.Second
+		backoffMul = 2 * time.Second
+	)
+	var (
+		backoff  = backoffMin
+		backoffT = time.NewTimer(backoff)
+		lastCnt  = compactionTransactCounter(0)
+
+		disableBackoff = db.s.o.GetDisableCompactionBackoff()
+	)
+	for n := 0; ; n++ {
+		// Check wether the DB is closed.
+		if db.isClosed() {
+			db.logf("%s exiting", name)
+			db.compactionExitTransact()
+		} else if n > 0 {
+			db.logf("%s retrying N·%d", name, n)
+		}
+
+		// Execute.
+		cnt := compactionTransactCounter(0)
+		err := t.run(&cnt)
+		if err != nil {
+			db.logf("%s error I·%d %q", name, cnt, err)
+		}
+
+		// Set compaction error status.
+		select {
+		case db.compErrSetC <- err:
+		case perr := <-db.compPerErrC:
+			if err != nil {
+				db.logf("%s exiting (persistent error %q)", name, perr)
+				db.compactionExitTransact()
+			}
+		case _, _ = <-db.closeC:
+			db.logf("%s exiting", name)
+			db.compactionExitTransact()
+		}
+		if err == nil {
+			return
+		}
+		if errors.IsCorrupted(err) {
+			db.logf("%s exiting (corruption detected)", name)
+			db.compactionExitTransact()
+		}
+
+		if !disableBackoff {
+			// Reset backoff duration if counter is advancing.
+			if cnt > lastCnt {
+				backoff = backoffMin
+				lastCnt = cnt
+			}
+
+			// Backoff.
+			backoffT.Reset(backoff)
+			if backoff < backoffMax {
+				backoff *= backoffMul
+				if backoff > backoffMax {
+					backoff = backoffMax
+				}
+			}
+			select {
+			case <-backoffT.C:
+			case _, _ = <-db.closeC:
+				db.logf("%s exiting", name)
+				db.compactionExitTransact()
+			}
+		}
+	}
+}
+
+type compactionTransactFunc struct {
+	runFunc    func(cnt *compactionTransactCounter) error
+	revertFunc func() error
+}
+
+func (t *compactionTransactFunc) run(cnt *compactionTransactCounter) error {
+	return t.runFunc(cnt)
+}
+
+func (t *compactionTransactFunc) revert() error {
+	if t.revertFunc != nil {
+		return t.revertFunc()
+	}
+	return nil
+}
+
+func (db *DB) compactionTransactFunc(name string, run func(cnt *compactionTransactCounter) error, revert func() error) {
+	db.compactionTransact(name, &compactionTransactFunc{run, revert})
+}
+
+func (db *DB) compactionExitTransact() {
+	panic(errCompactionTransactExiting)
+}
+
+func (db *DB) memCompaction() {
+	mdb := db.getFrozenMem()
+	if mdb == nil {
+		return
+	}
+	defer mdb.decref()
+
+	db.logf("memdb@flush N·%d S·%s", mdb.Len(), shortenb(mdb.Size()))
+
+	// Don't compact empty memdb.
+	if mdb.Len() == 0 {
+		db.logf("memdb@flush skipping")
+		// drop frozen memdb
+		db.dropFrozenMem()
+		return
+	}
+
+	// Pause table compaction.
+	resumeC := make(chan struct{})
+	select {
+	case db.tcompPauseC <- (chan<- struct{})(resumeC):
+	case <-db.compPerErrC:
+		close(resumeC)
+		resumeC = nil
+	case _, _ = <-db.closeC:
+		return
+	}
+
+	var (
+		rec        = &sessionRecord{}
+		stats      = &cStatsStaging{}
+		flushLevel int
+	)
+
+	db.compactionTransactFunc("memdb@flush", func(cnt *compactionTransactCounter) (err error) {
+		stats.startTimer()
+		flushLevel, err = db.s.flushMemdb(rec, mdb.DB, -1)
+		stats.stopTimer()
+		return
+	}, func() error {
+		for _, r := range rec.addedTables {
+			db.logf("memdb@flush revert @%d", r.num)
+			f := db.s.getTableFile(r.num)
+			if err := f.Remove(); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+
+	db.compactionTransactFunc("memdb@commit", func(cnt *compactionTransactCounter) (err error) {
+		stats.startTimer()
+		rec.setJournalNum(db.journalFile.Num())
+		rec.setSeqNum(db.frozenSeq)
+		err = db.s.commit(rec)
+		stats.stopTimer()
+		return
+	}, nil)
+
+	db.logf("memdb@flush committed F·%d T·%v", len(rec.addedTables), stats.duration)
+
+	for _, r := range rec.addedTables {
+		stats.write += r.size
+	}
+	db.compStats[flushLevel].add(stats)
+
+	// Drop frozen memdb.
+	db.dropFrozenMem()
+
+	// Resume table compaction.
+	if resumeC != nil {
+		select {
+		case <-resumeC:
+			close(resumeC)
+		case _, _ = <-db.closeC:
+			return
+		}
+	}
+
+	// Trigger table compaction.
+	db.compSendTrigger(db.tcompCmdC)
+}
+
+type tableCompactionBuilder struct {
+	db           *DB
+	s            *session
+	c            *compaction
+	rec          *sessionRecord
+	stat0, stat1 *cStatsStaging
+
+	snapHasLastUkey bool
+	snapLastUkey    []byte
+	snapLastSeq     uint64
+	snapIter        int
+	snapKerrCnt     int
+	snapDropCnt     int
+
+	kerrCnt int
+	dropCnt int
+
+	minSeq    uint64
+	strict    bool
+	tableSize int
+
+	tw *tWriter
+}
+
+func (b *tableCompactionBuilder) appendKV(key, value []byte) error {
+	// Create new table if not already.
+	if b.tw == nil {
+		// Check for pause event.
+		if b.db != nil {
+			select {
+			case ch := <-b.db.tcompPauseC:
+				b.db.pauseCompaction(ch)
+			case _, _ = <-b.db.closeC:
+				b.db.compactionExitTransact()
+			default:
+			}
+		}
+
+		// Create new table.
+		var err error
+		b.tw, err = b.s.tops.create()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Write key/value into table.
+	return b.tw.append(key, value)
+}
+
+func (b *tableCompactionBuilder) needFlush() bool {
+	return b.tw.tw.BytesLen() >= b.tableSize
+}
+
+func (b *tableCompactionBuilder) flush() error {
+	t, err := b.tw.finish()
+	if err != nil {
+		return err
+	}
+	b.rec.addTableFile(b.c.level+1, t)
+	b.stat1.write += t.size
+	b.s.logf("table@build created L%d@%d N·%d S·%s %q:%q", b.c.level+1, t.file.Num(), b.tw.tw.EntriesLen(), shortenb(int(t.size)), t.imin, t.imax)
+	b.tw = nil
+	return nil
+}
+
+func (b *tableCompactionBuilder) cleanup() {
+	if b.tw != nil {
+		b.tw.drop()
+		b.tw = nil
+	}
+}
+
+func (b *tableCompactionBuilder) run(cnt *compactionTransactCounter) error {
+	snapResumed := b.snapIter > 0
+	hasLastUkey := b.snapHasLastUkey // The key might has zero length, so this is necessary.
+	lastUkey := append([]byte{}, b.snapLastUkey...)
+	lastSeq := b.snapLastSeq
+	b.kerrCnt = b.snapKerrCnt
+	b.dropCnt = b.snapDropCnt
+	// Restore compaction state.
+	b.c.restore()
+
+	defer b.cleanup()
+
+	b.stat1.startTimer()
+	defer b.stat1.stopTimer()
+
+	iter := b.c.newIterator()
+	defer iter.Release()
+	for i := 0; iter.Next(); i++ {
+		// Incr transact counter.
+		cnt.incr()
+
+		// Skip until last state.
+		if i < b.snapIter {
+			continue
+		}
+
+		resumed := false
+		if snapResumed {
+			resumed = true
+			snapResumed = false
+		}
+
+		ikey := iter.Key()
+		ukey, seq, kt, kerr := parseIkey(ikey)
+
+		if kerr == nil {
+			shouldStop := !resumed && b.c.shouldStopBefore(ikey)
+
+			if !hasLastUkey || b.s.icmp.uCompare(lastUkey, ukey) != 0 {
+				// First occurrence of this user key.
+
+				// Only rotate tables if ukey doesn't hop across.
+				if b.tw != nil && (shouldStop || b.needFlush()) {
+					if err := b.flush(); err != nil {
+						return err
+					}
+
+					// Creates snapshot of the state.
+					b.c.save()
+					b.snapHasLastUkey = hasLastUkey
+					b.snapLastUkey = append(b.snapLastUkey[:0], lastUkey...)
+					b.snapLastSeq = lastSeq
+					b.snapIter = i
+					b.snapKerrCnt = b.kerrCnt
+					b.snapDropCnt = b.dropCnt
+				}
+
+				hasLastUkey = true
+				lastUkey = append(lastUkey[:0], ukey...)
+				lastSeq = kMaxSeq
+			}
+
+			switch {
+			case lastSeq <= b.minSeq:
+				// Dropped because newer entry for same user key exist
+				fallthrough // (A)
+			case kt == ktDel && seq <= b.minSeq && b.c.baseLevelForKey(lastUkey):
+				// For this user key:
+				// (1) there is no data in higher levels
+				// (2) data in lower levels will have larger seq numbers
+				// (3) data in layers that are being compacted here and have
+				//     smaller seq numbers will be dropped in the next
+				//     few iterations of this loop (by rule (A) above).
+				// Therefore this deletion marker is obsolete and can be dropped.
+				lastSeq = seq
+				b.dropCnt++
+				continue
+			default:
+				lastSeq = seq
+			}
+		} else {
+			if b.strict {
+				return kerr
+			}
+
+			// Don't drop corrupted keys.
+			hasLastUkey = false
+			lastUkey = lastUkey[:0]
+			lastSeq = kMaxSeq
+			b.kerrCnt++
+		}
+
+		if err := b.appendKV(ikey, iter.Value()); err != nil {
+			return err
+		}
+	}
+
+	if err := iter.Error(); err != nil {
+		return err
+	}
+
+	// Finish last table.
+	if b.tw != nil && !b.tw.empty() {
+		return b.flush()
+	}
+	return nil
+}
+
+func (b *tableCompactionBuilder) revert() error {
+	for _, at := range b.rec.addedTables {
+		b.s.logf("table@build revert @%d", at.num)
+		f := b.s.getTableFile(at.num)
+		if err := f.Remove(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (db *DB) tableCompaction(c *compaction, noTrivial bool) {
+	defer c.release()
+
+	rec := &sessionRecord{}
+	rec.addCompPtr(c.level, c.imax)
+
+	if !noTrivial && c.trivial() {
+		t := c.tables[0][0]
+		db.logf("table@move L%d@%d -> L%d", c.level, t.file.Num(), c.level+1)
+		rec.delTable(c.level, t.file.Num())
+		rec.addTableFile(c.level+1, t)
+		db.compactionTransactFunc("table@move", func(cnt *compactionTransactCounter) (err error) {
+			return db.s.commit(rec)
+		}, nil)
+		return
+	}
+
+	var stats [2]cStatsStaging
+	for i, tables := range c.tables {
+		for _, t := range tables {
+			stats[i].read += t.size
+			// Insert deleted tables into record
+			rec.delTable(c.level+i, t.file.Num())
+		}
+	}
+	sourceSize := int(stats[0].read + stats[1].read)
+	minSeq := db.minSeq()
+	db.logf("table@compaction L%d·%d -> L%d·%d S·%s Q·%d", c.level, len(c.tables[0]), c.level+1, len(c.tables[1]), shortenb(sourceSize), minSeq)
+
+	b := &tableCompactionBuilder{
+		db:        db,
+		s:         db.s,
+		c:         c,
+		rec:       rec,
+		stat1:     &stats[1],
+		minSeq:    minSeq,
+		strict:    db.s.o.GetStrict(opt.StrictCompaction),
+		tableSize: db.s.o.GetCompactionTableSize(c.level + 1),
+	}
+	db.compactionTransact("table@build", b)
+
+	// Commit changes
+	db.compactionTransactFunc("table@commit", func(cnt *compactionTransactCounter) (err error) {
+		stats[1].startTimer()
+		defer stats[1].stopTimer()
+		return db.s.commit(rec)
+	}, nil)
+
+	resultSize := int(stats[1].write)
+	db.logf("table@compaction committed F%s S%s Ke·%d D·%d T·%v", sint(len(rec.addedTables)-len(rec.deletedTables)), sshortenb(resultSize-sourceSize), b.kerrCnt, b.dropCnt, stats[1].duration)
+
+	// Save compaction stats
+	for i := range stats {
+		db.compStats[c.level+1].add(&stats[i])
+	}
+}
+
+func (db *DB) tableRangeCompaction(level int, umin, umax []byte) {
+	db.logf("table@compaction range L%d %q:%q", level, umin, umax)
+
+	if level >= 0 {
+		if c := db.s.getCompactionRange(level, umin, umax); c != nil {
+			db.tableCompaction(c, true)
+		}
+	} else {
+		v := db.s.version()
+		m := 1
+		for i, t := range v.tables[1:] {
+			if t.overlaps(db.s.icmp, umin, umax, false) {
+				m = i + 1
+			}
+		}
+		v.release()
+
+		for level := 0; level < m; level++ {
+			if c := db.s.getCompactionRange(level, umin, umax); c != nil {
+				db.tableCompaction(c, true)
+			}
+		}
+	}
+}
+
+func (db *DB) tableAutoCompaction() {
+	if c := db.s.pickCompaction(); c != nil {
+		db.tableCompaction(c, false)
+	}
+}
+
+func (db *DB) tableNeedCompaction() bool {
+	v := db.s.version()
+	defer v.release()
+	return v.needCompaction()
+}
+
+func (db *DB) pauseCompaction(ch chan<- struct{}) {
+	select {
+	case ch <- struct{}{}:
+	case _, _ = <-db.closeC:
+		db.compactionExitTransact()
+	}
+}
+
+type cCmd interface {
+	ack(err error)
+}
+
+type cIdle struct {
+	ackC chan<- error
+}
+
+func (r cIdle) ack(err error) {
+	if r.ackC != nil {
+		defer func() {
+			recover()
+		}()
+		r.ackC <- err
+	}
+}
+
+type cRange struct {
+	level    int
+	min, max []byte
+	ackC     chan<- error
+}
+
+func (r cRange) ack(err error) {
+	if r.ackC != nil {
+		defer func() {
+			recover()
+		}()
+		r.ackC <- err
+	}
+}
+
+// This will trigger auto compation and/or wait for all compaction to be done.
+func (db *DB) compSendIdle(compC chan<- cCmd) (err error) {
+	ch := make(chan error)
+	defer close(ch)
+	// Send cmd.
+	select {
+	case compC <- cIdle{ch}:
+	case err = <-db.compErrC:
+		return
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+	// Wait cmd.
+	select {
+	case err = <-ch:
+	case err = <-db.compErrC:
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+	return err
+}
+
+// This will trigger auto compaction but will not wait for it.
+func (db *DB) compSendTrigger(compC chan<- cCmd) {
+	select {
+	case compC <- cIdle{}:
+	default:
+	}
+}
+
+// Send range compaction request.
+func (db *DB) compSendRange(compC chan<- cCmd, level int, min, max []byte) (err error) {
+	ch := make(chan error)
+	defer close(ch)
+	// Send cmd.
+	select {
+	case compC <- cRange{level, min, max, ch}:
+	case err := <-db.compErrC:
+		return err
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+	// Wait cmd.
+	select {
+	case err = <-ch:
+	case err = <-db.compErrC:
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+	return err
+}
+
+func (db *DB) mCompaction() {
+	var x cCmd
+
+	defer func() {
+		if x := recover(); x != nil {
+			if x != errCompactionTransactExiting {
+				panic(x)
+			}
+		}
+		if x != nil {
+			x.ack(ErrClosed)
+		}
+		db.closeW.Done()
+	}()
+
+	for {
+		select {
+		case x = <-db.mcompCmdC:
+			switch x.(type) {
+			case cIdle:
+				db.memCompaction()
+				x.ack(nil)
+				x = nil
+			default:
+				panic("leveldb: unknown command")
+			}
+		case _, _ = <-db.closeC:
+			return
+		}
+	}
+}
+
+func (db *DB) tCompaction() {
+	var x cCmd
+	var ackQ []cCmd
+
+	defer func() {
+		if x := recover(); x != nil {
+			if x != errCompactionTransactExiting {
+				panic(x)
+			}
+		}
+		for i := range ackQ {
+			ackQ[i].ack(ErrClosed)
+			ackQ[i] = nil
+		}
+		if x != nil {
+			x.ack(ErrClosed)
+		}
+		db.closeW.Done()
+	}()
+
+	for {
+		if db.tableNeedCompaction() {
+			select {
+			case x = <-db.tcompCmdC:
+			case ch := <-db.tcompPauseC:
+				db.pauseCompaction(ch)
+				continue
+			case _, _ = <-db.closeC:
+				return
+			default:
+			}
+		} else {
+			for i := range ackQ {
+				ackQ[i].ack(nil)
+				ackQ[i] = nil
+			}
+			ackQ = ackQ[:0]
+			select {
+			case x = <-db.tcompCmdC:
+			case ch := <-db.tcompPauseC:
+				db.pauseCompaction(ch)
+				continue
+			case _, _ = <-db.closeC:
+				return
+			}
+		}
+		if x != nil {
+			switch cmd := x.(type) {
+			case cIdle:
+				ackQ = append(ackQ, x)
+			case cRange:
+				db.tableRangeCompaction(cmd.level, cmd.min, cmd.max)
+				x.ack(nil)
+			default:
+				panic("leveldb: unknown command")
+			}
+			x = nil
+		}
+		db.tableAutoCompaction()
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_iter.go
new file mode 100644
index 00000000..656ae985
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_iter.go
@@ -0,0 +1,350 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"errors"
+	"math/rand"
+	"runtime"
+	"sync"
+	"sync/atomic"
+
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+	errInvalidIkey = errors.New("leveldb: Iterator: invalid internal key")
+)
+
+type memdbReleaser struct {
+	once sync.Once
+	m    *memDB
+}
+
+func (mr *memdbReleaser) Release() {
+	mr.once.Do(func() {
+		mr.m.decref()
+	})
+}
+
+func (db *DB) newRawIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+	em, fm := db.getMems()
+	v := db.s.version()
+
+	ti := v.getIterators(slice, ro)
+	n := len(ti) + 2
+	i := make([]iterator.Iterator, 0, n)
+	emi := em.NewIterator(slice)
+	emi.SetReleaser(&memdbReleaser{m: em})
+	i = append(i, emi)
+	if fm != nil {
+		fmi := fm.NewIterator(slice)
+		fmi.SetReleaser(&memdbReleaser{m: fm})
+		i = append(i, fmi)
+	}
+	i = append(i, ti...)
+	strict := opt.GetStrict(db.s.o.Options, ro, opt.StrictReader)
+	mi := iterator.NewMergedIterator(i, db.s.icmp, strict)
+	mi.SetReleaser(&versionReleaser{v: v})
+	return mi
+}
+
+func (db *DB) newIterator(seq uint64, slice *util.Range, ro *opt.ReadOptions) *dbIter {
+	var islice *util.Range
+	if slice != nil {
+		islice = &util.Range{}
+		if slice.Start != nil {
+			islice.Start = newIkey(slice.Start, kMaxSeq, ktSeek)
+		}
+		if slice.Limit != nil {
+			islice.Limit = newIkey(slice.Limit, kMaxSeq, ktSeek)
+		}
+	}
+	rawIter := db.newRawIterator(islice, ro)
+	iter := &dbIter{
+		db:     db,
+		icmp:   db.s.icmp,
+		iter:   rawIter,
+		seq:    seq,
+		strict: opt.GetStrict(db.s.o.Options, ro, opt.StrictReader),
+		key:    make([]byte, 0),
+		value:  make([]byte, 0),
+	}
+	atomic.AddInt32(&db.aliveIters, 1)
+	runtime.SetFinalizer(iter, (*dbIter).Release)
+	return iter
+}
+
+func (db *DB) iterSamplingRate() int {
+	return rand.Intn(2 * db.s.o.GetIteratorSamplingRate())
+}
+
+type dir int
+
+const (
+	dirReleased dir = iota - 1
+	dirSOI
+	dirEOI
+	dirBackward
+	dirForward
+)
+
+// dbIter represent an interator states over a database session.
+type dbIter struct {
+	db     *DB
+	icmp   *iComparer
+	iter   iterator.Iterator
+	seq    uint64
+	strict bool
+
+	smaplingGap int
+	dir         dir
+	key         []byte
+	value       []byte
+	err         error
+	releaser    util.Releaser
+}
+
+func (i *dbIter) sampleSeek() {
+	ikey := i.iter.Key()
+	i.smaplingGap -= len(ikey) + len(i.iter.Value())
+	for i.smaplingGap < 0 {
+		i.smaplingGap += i.db.iterSamplingRate()
+		i.db.sampleSeek(ikey)
+	}
+}
+
+func (i *dbIter) setErr(err error) {
+	i.err = err
+	i.key = nil
+	i.value = nil
+}
+
+func (i *dbIter) iterErr() {
+	if err := i.iter.Error(); err != nil {
+		i.setErr(err)
+	}
+}
+
+func (i *dbIter) Valid() bool {
+	return i.err == nil && i.dir > dirEOI
+}
+
+func (i *dbIter) First() bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.iter.First() {
+		i.dir = dirSOI
+		return i.next()
+	}
+	i.dir = dirEOI
+	i.iterErr()
+	return false
+}
+
+func (i *dbIter) Last() bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.iter.Last() {
+		return i.prev()
+	}
+	i.dir = dirSOI
+	i.iterErr()
+	return false
+}
+
+func (i *dbIter) Seek(key []byte) bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	ikey := newIkey(key, i.seq, ktSeek)
+	if i.iter.Seek(ikey) {
+		i.dir = dirSOI
+		return i.next()
+	}
+	i.dir = dirEOI
+	i.iterErr()
+	return false
+}
+
+func (i *dbIter) next() bool {
+	for {
+		if ukey, seq, kt, kerr := parseIkey(i.iter.Key()); kerr == nil {
+			i.sampleSeek()
+			if seq <= i.seq {
+				switch kt {
+				case ktDel:
+					// Skip deleted key.
+					i.key = append(i.key[:0], ukey...)
+					i.dir = dirForward
+				case ktVal:
+					if i.dir == dirSOI || i.icmp.uCompare(ukey, i.key) > 0 {
+						i.key = append(i.key[:0], ukey...)
+						i.value = append(i.value[:0], i.iter.Value()...)
+						i.dir = dirForward
+						return true
+					}
+				}
+			}
+		} else if i.strict {
+			i.setErr(kerr)
+			break
+		}
+		if !i.iter.Next() {
+			i.dir = dirEOI
+			i.iterErr()
+			break
+		}
+	}
+	return false
+}
+
+func (i *dbIter) Next() bool {
+	if i.dir == dirEOI || i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if !i.iter.Next() || (i.dir == dirBackward && !i.iter.Next()) {
+		i.dir = dirEOI
+		i.iterErr()
+		return false
+	}
+	return i.next()
+}
+
+func (i *dbIter) prev() bool {
+	i.dir = dirBackward
+	del := true
+	if i.iter.Valid() {
+		for {
+			if ukey, seq, kt, kerr := parseIkey(i.iter.Key()); kerr == nil {
+				i.sampleSeek()
+				if seq <= i.seq {
+					if !del && i.icmp.uCompare(ukey, i.key) < 0 {
+						return true
+					}
+					del = (kt == ktDel)
+					if !del {
+						i.key = append(i.key[:0], ukey...)
+						i.value = append(i.value[:0], i.iter.Value()...)
+					}
+				}
+			} else if i.strict {
+				i.setErr(kerr)
+				return false
+			}
+			if !i.iter.Prev() {
+				break
+			}
+		}
+	}
+	if del {
+		i.dir = dirSOI
+		i.iterErr()
+		return false
+	}
+	return true
+}
+
+func (i *dbIter) Prev() bool {
+	if i.dir == dirSOI || i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	switch i.dir {
+	case dirEOI:
+		return i.Last()
+	case dirForward:
+		for i.iter.Prev() {
+			if ukey, _, _, kerr := parseIkey(i.iter.Key()); kerr == nil {
+				i.sampleSeek()
+				if i.icmp.uCompare(ukey, i.key) < 0 {
+					goto cont
+				}
+			} else if i.strict {
+				i.setErr(kerr)
+				return false
+			}
+		}
+		i.dir = dirSOI
+		i.iterErr()
+		return false
+	}
+
+cont:
+	return i.prev()
+}
+
+func (i *dbIter) Key() []byte {
+	if i.err != nil || i.dir <= dirEOI {
+		return nil
+	}
+	return i.key
+}
+
+func (i *dbIter) Value() []byte {
+	if i.err != nil || i.dir <= dirEOI {
+		return nil
+	}
+	return i.value
+}
+
+func (i *dbIter) Release() {
+	if i.dir != dirReleased {
+		// Clear the finalizer.
+		runtime.SetFinalizer(i, nil)
+
+		if i.releaser != nil {
+			i.releaser.Release()
+			i.releaser = nil
+		}
+
+		i.dir = dirReleased
+		i.key = nil
+		i.value = nil
+		i.iter.Release()
+		i.iter = nil
+		atomic.AddInt32(&i.db.aliveIters, -1)
+		i.db = nil
+	}
+}
+
+func (i *dbIter) SetReleaser(releaser util.Releaser) {
+	if i.dir == dirReleased {
+		panic(util.ErrReleased)
+	}
+	if i.releaser != nil && releaser != nil {
+		panic(util.ErrHasReleaser)
+	}
+	i.releaser = releaser
+}
+
+func (i *dbIter) Error() error {
+	return i.err
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_snapshot.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_snapshot.go
new file mode 100644
index 00000000..0372848f
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_snapshot.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"container/list"
+	"fmt"
+	"runtime"
+	"sync"
+	"sync/atomic"
+
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type snapshotElement struct {
+	seq uint64
+	ref int
+	e   *list.Element
+}
+
+// Acquires a snapshot, based on latest sequence.
+func (db *DB) acquireSnapshot() *snapshotElement {
+	db.snapsMu.Lock()
+	defer db.snapsMu.Unlock()
+
+	seq := db.getSeq()
+
+	if e := db.snapsList.Back(); e != nil {
+		se := e.Value.(*snapshotElement)
+		if se.seq == seq {
+			se.ref++
+			return se
+		} else if seq < se.seq {
+			panic("leveldb: sequence number is not increasing")
+		}
+	}
+	se := &snapshotElement{seq: seq, ref: 1}
+	se.e = db.snapsList.PushBack(se)
+	return se
+}
+
+// Releases given snapshot element.
+func (db *DB) releaseSnapshot(se *snapshotElement) {
+	db.snapsMu.Lock()
+	defer db.snapsMu.Unlock()
+
+	se.ref--
+	if se.ref == 0 {
+		db.snapsList.Remove(se.e)
+		se.e = nil
+	} else if se.ref < 0 {
+		panic("leveldb: Snapshot: negative element reference")
+	}
+}
+
+// Gets minimum sequence that not being snapshoted.
+func (db *DB) minSeq() uint64 {
+	db.snapsMu.Lock()
+	defer db.snapsMu.Unlock()
+
+	if e := db.snapsList.Front(); e != nil {
+		return e.Value.(*snapshotElement).seq
+	}
+
+	return db.getSeq()
+}
+
+// Snapshot is a DB snapshot.
+type Snapshot struct {
+	db       *DB
+	elem     *snapshotElement
+	mu       sync.RWMutex
+	released bool
+}
+
+// Creates new snapshot object.
+func (db *DB) newSnapshot() *Snapshot {
+	snap := &Snapshot{
+		db:   db,
+		elem: db.acquireSnapshot(),
+	}
+	atomic.AddInt32(&db.aliveSnaps, 1)
+	runtime.SetFinalizer(snap, (*Snapshot).Release)
+	return snap
+}
+
+func (snap *Snapshot) String() string {
+	return fmt.Sprintf("leveldb.Snapshot{%d}", snap.elem.seq)
+}
+
+// Get gets the value for the given key. It returns ErrNotFound if
+// the DB does not contains the key.
+//
+// The caller should not modify the contents of the returned slice, but
+// it is safe to modify the contents of the argument after Get returns.
+func (snap *Snapshot) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
+	err = snap.db.ok()
+	if err != nil {
+		return
+	}
+	snap.mu.RLock()
+	defer snap.mu.RUnlock()
+	if snap.released {
+		err = ErrSnapshotReleased
+		return
+	}
+	return snap.db.get(key, snap.elem.seq, ro)
+}
+
+// Has returns true if the DB does contains the given key.
+//
+// It is safe to modify the contents of the argument after Get returns.
+func (snap *Snapshot) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
+	err = snap.db.ok()
+	if err != nil {
+		return
+	}
+	snap.mu.RLock()
+	defer snap.mu.RUnlock()
+	if snap.released {
+		err = ErrSnapshotReleased
+		return
+	}
+	return snap.db.has(key, snap.elem.seq, ro)
+}
+
+// NewIterator returns an iterator for the snapshot of the uderlying DB.
+// The returned iterator is not goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+// It is also safe to use an iterator concurrently with modifying its
+// underlying DB. The resultant key/value pairs are guaranteed to be
+// consistent.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// DB. And a nil Range.Limit is treated as a key after all keys in
+// the DB.
+//
+// The iterator must be released after use, by calling Release method.
+// Releasing the snapshot doesn't mean releasing the iterator too, the
+// iterator would be still valid until released.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (snap *Snapshot) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+	if err := snap.db.ok(); err != nil {
+		return iterator.NewEmptyIterator(err)
+	}
+	snap.mu.Lock()
+	defer snap.mu.Unlock()
+	if snap.released {
+		return iterator.NewEmptyIterator(ErrSnapshotReleased)
+	}
+	// Since iterator already hold version ref, it doesn't need to
+	// hold snapshot ref.
+	return snap.db.newIterator(snap.elem.seq, slice, ro)
+}
+
+// Release releases the snapshot. This will not release any returned
+// iterators, the iterators would still be valid until released or the
+// underlying DB is closed.
+//
+// Other methods should not be called after the snapshot has been released.
+func (snap *Snapshot) Release() {
+	snap.mu.Lock()
+	defer snap.mu.Unlock()
+
+	if !snap.released {
+		// Clear the finalizer.
+		runtime.SetFinalizer(snap, nil)
+
+		snap.released = true
+		snap.db.releaseSnapshot(snap.elem)
+		atomic.AddInt32(&snap.db.aliveSnaps, -1)
+		snap.db = nil
+		snap.elem = nil
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_state.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_state.go
new file mode 100644
index 00000000..24671dd3
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_state.go
@@ -0,0 +1,211 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"sync/atomic"
+	"time"
+
+	"github.com/syndtr/goleveldb/leveldb/journal"
+	"github.com/syndtr/goleveldb/leveldb/memdb"
+)
+
+type memDB struct {
+	db *DB
+	*memdb.DB
+	ref int32
+}
+
+func (m *memDB) incref() {
+	atomic.AddInt32(&m.ref, 1)
+}
+
+func (m *memDB) decref() {
+	if ref := atomic.AddInt32(&m.ref, -1); ref == 0 {
+		// Only put back memdb with std capacity.
+		if m.Capacity() == m.db.s.o.GetWriteBuffer() {
+			m.Reset()
+			m.db.mpoolPut(m.DB)
+		}
+		m.db = nil
+		m.DB = nil
+	} else if ref < 0 {
+		panic("negative memdb ref")
+	}
+}
+
+// Get latest sequence number.
+func (db *DB) getSeq() uint64 {
+	return atomic.LoadUint64(&db.seq)
+}
+
+// Atomically adds delta to seq.
+func (db *DB) addSeq(delta uint64) {
+	atomic.AddUint64(&db.seq, delta)
+}
+
+func (db *DB) sampleSeek(ikey iKey) {
+	v := db.s.version()
+	if v.sampleSeek(ikey) {
+		// Trigger table compaction.
+		db.compSendTrigger(db.tcompCmdC)
+	}
+	v.release()
+}
+
+func (db *DB) mpoolPut(mem *memdb.DB) {
+	defer func() {
+		recover()
+	}()
+	select {
+	case db.memPool <- mem:
+	default:
+	}
+}
+
+func (db *DB) mpoolGet() *memdb.DB {
+	select {
+	case mem := <-db.memPool:
+		return mem
+	default:
+		return nil
+	}
+}
+
+func (db *DB) mpoolDrain() {
+	ticker := time.NewTicker(30 * time.Second)
+	for {
+		select {
+		case <-ticker.C:
+			select {
+			case <-db.memPool:
+			default:
+			}
+		case _, _ = <-db.closeC:
+			close(db.memPool)
+			return
+		}
+	}
+}
+
+// Create new memdb and froze the old one; need external synchronization.
+// newMem only called synchronously by the writer.
+func (db *DB) newMem(n int) (mem *memDB, err error) {
+	num := db.s.allocFileNum()
+	file := db.s.getJournalFile(num)
+	w, err := file.Create()
+	if err != nil {
+		db.s.reuseFileNum(num)
+		return
+	}
+
+	db.memMu.Lock()
+	defer db.memMu.Unlock()
+
+	if db.frozenMem != nil {
+		panic("still has frozen mem")
+	}
+
+	if db.journal == nil {
+		db.journal = journal.NewWriter(w)
+	} else {
+		db.journal.Reset(w)
+		db.journalWriter.Close()
+		db.frozenJournalFile = db.journalFile
+	}
+	db.journalWriter = w
+	db.journalFile = file
+	db.frozenMem = db.mem
+	mdb := db.mpoolGet()
+	if mdb == nil || mdb.Capacity() < n {
+		mdb = memdb.New(db.s.icmp, maxInt(db.s.o.GetWriteBuffer(), n))
+	}
+	mem = &memDB{
+		db:  db,
+		DB:  mdb,
+		ref: 2,
+	}
+	db.mem = mem
+	// The seq only incremented by the writer. And whoever called newMem
+	// should hold write lock, so no need additional synchronization here.
+	db.frozenSeq = db.seq
+	return
+}
+
+// Get all memdbs.
+func (db *DB) getMems() (e, f *memDB) {
+	db.memMu.RLock()
+	defer db.memMu.RUnlock()
+	if db.mem == nil {
+		panic("nil effective mem")
+	}
+	db.mem.incref()
+	if db.frozenMem != nil {
+		db.frozenMem.incref()
+	}
+	return db.mem, db.frozenMem
+}
+
+// Get frozen memdb.
+func (db *DB) getEffectiveMem() *memDB {
+	db.memMu.RLock()
+	defer db.memMu.RUnlock()
+	if db.mem == nil {
+		panic("nil effective mem")
+	}
+	db.mem.incref()
+	return db.mem
+}
+
+// Check whether we has frozen memdb.
+func (db *DB) hasFrozenMem() bool {
+	db.memMu.RLock()
+	defer db.memMu.RUnlock()
+	return db.frozenMem != nil
+}
+
+// Get frozen memdb.
+func (db *DB) getFrozenMem() *memDB {
+	db.memMu.RLock()
+	defer db.memMu.RUnlock()
+	if db.frozenMem != nil {
+		db.frozenMem.incref()
+	}
+	return db.frozenMem
+}
+
+// Drop frozen memdb; assume that frozen memdb isn't nil.
+func (db *DB) dropFrozenMem() {
+	db.memMu.Lock()
+	if err := db.frozenJournalFile.Remove(); err != nil {
+		db.logf("journal@remove removing @%d %q", db.frozenJournalFile.Num(), err)
+	} else {
+		db.logf("journal@remove removed @%d", db.frozenJournalFile.Num())
+	}
+	db.frozenJournalFile = nil
+	db.frozenMem.decref()
+	db.frozenMem = nil
+	db.memMu.Unlock()
+}
+
+// Set closed flag; return true if not already closed.
+func (db *DB) setClosed() bool {
+	return atomic.CompareAndSwapUint32(&db.closed, 0, 1)
+}
+
+// Check whether DB was closed.
+func (db *DB) isClosed() bool {
+	return atomic.LoadUint32(&db.closed) != 0
+}
+
+// Check read ok status.
+func (db *DB) ok() error {
+	if db.isClosed() {
+		return ErrClosed
+	}
+	return nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_util.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_util.go
new file mode 100644
index 00000000..a8a2bdf7
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_util.go
@@ -0,0 +1,100 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// Reader is the interface that wraps basic Get and NewIterator methods.
+// This interface implemented by both DB and Snapshot.
+type Reader interface {
+	Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)
+	NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator
+}
+
+type Sizes []uint64
+
+// Sum returns sum of the sizes.
+func (p Sizes) Sum() (n uint64) {
+	for _, s := range p {
+		n += s
+	}
+	return n
+}
+
+// Logging.
+func (db *DB) log(v ...interface{})                 { db.s.log(v...) }
+func (db *DB) logf(format string, v ...interface{}) { db.s.logf(format, v...) }
+
+// Check and clean files.
+func (db *DB) checkAndCleanFiles() error {
+	v := db.s.version()
+	defer v.release()
+
+	tablesMap := make(map[uint64]bool)
+	for _, tables := range v.tables {
+		for _, t := range tables {
+			tablesMap[t.file.Num()] = false
+		}
+	}
+
+	files, err := db.s.getFiles(storage.TypeAll)
+	if err != nil {
+		return err
+	}
+
+	var nTables int
+	var rem []storage.File
+	for _, f := range files {
+		keep := true
+		switch f.Type() {
+		case storage.TypeManifest:
+			keep = f.Num() >= db.s.manifestFile.Num()
+		case storage.TypeJournal:
+			if db.frozenJournalFile != nil {
+				keep = f.Num() >= db.frozenJournalFile.Num()
+			} else {
+				keep = f.Num() >= db.journalFile.Num()
+			}
+		case storage.TypeTable:
+			_, keep = tablesMap[f.Num()]
+			if keep {
+				tablesMap[f.Num()] = true
+				nTables++
+			}
+		}
+
+		if !keep {
+			rem = append(rem, f)
+		}
+	}
+
+	if nTables != len(tablesMap) {
+		var missing []*storage.FileInfo
+		for num, present := range tablesMap {
+			if !present {
+				missing = append(missing, &storage.FileInfo{Type: storage.TypeTable, Num: num})
+				db.logf("db@janitor table missing @%d", num)
+			}
+		}
+		return errors.NewErrCorrupted(nil, &errors.ErrMissingFiles{Files: missing})
+	}
+
+	db.logf("db@janitor F·%d G·%d", len(files), len(rem))
+	for _, f := range rem {
+		db.logf("db@janitor removing %s-%d", f.Type(), f.Num())
+		if err := f.Remove(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go
new file mode 100644
index 00000000..99ee85da
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go
@@ -0,0 +1,339 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"time"
+
+	"github.com/syndtr/goleveldb/leveldb/memdb"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func (db *DB) writeJournal(b *Batch) error {
+	w, err := db.journal.Next()
+	if err != nil {
+		return err
+	}
+	if _, err := w.Write(b.encode()); err != nil {
+		return err
+	}
+	if err := db.journal.Flush(); err != nil {
+		return err
+	}
+	if b.sync {
+		return db.journalWriter.Sync()
+	}
+	return nil
+}
+
+func (db *DB) jWriter() {
+	defer db.closeW.Done()
+	for {
+		select {
+		case b := <-db.journalC:
+			if b != nil {
+				db.journalAckC <- db.writeJournal(b)
+			}
+		case _, _ = <-db.closeC:
+			return
+		}
+	}
+}
+
+func (db *DB) rotateMem(n int) (mem *memDB, err error) {
+	// Wait for pending memdb compaction.
+	err = db.compSendIdle(db.mcompCmdC)
+	if err != nil {
+		return
+	}
+
+	// Create new memdb and journal.
+	mem, err = db.newMem(n)
+	if err != nil {
+		return
+	}
+
+	// Schedule memdb compaction.
+	db.compSendTrigger(db.mcompCmdC)
+	return
+}
+
+func (db *DB) flush(n int) (mdb *memDB, mdbFree int, err error) {
+	delayed := false
+	flush := func() (retry bool) {
+		v := db.s.version()
+		defer v.release()
+		mdb = db.getEffectiveMem()
+		defer func() {
+			if retry {
+				mdb.decref()
+				mdb = nil
+			}
+		}()
+		mdbFree = mdb.Free()
+		switch {
+		case v.tLen(0) >= db.s.o.GetWriteL0SlowdownTrigger() && !delayed:
+			delayed = true
+			time.Sleep(time.Millisecond)
+		case mdbFree >= n:
+			return false
+		case v.tLen(0) >= db.s.o.GetWriteL0PauseTrigger():
+			delayed = true
+			err = db.compSendIdle(db.tcompCmdC)
+			if err != nil {
+				return false
+			}
+		default:
+			// Allow memdb to grow if it has no entry.
+			if mdb.Len() == 0 {
+				mdbFree = n
+			} else {
+				mdb.decref()
+				mdb, err = db.rotateMem(n)
+				if err == nil {
+					mdbFree = mdb.Free()
+				} else {
+					mdbFree = 0
+				}
+			}
+			return false
+		}
+		return true
+	}
+	start := time.Now()
+	for flush() {
+	}
+	if delayed {
+		db.writeDelay += time.Since(start)
+		db.writeDelayN++
+	} else if db.writeDelayN > 0 {
+		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
+		db.writeDelay = 0
+		db.writeDelayN = 0
+	}
+	return
+}
+
+// Write apply the given batch to the DB. The batch will be applied
+// sequentially.
+//
+// It is safe to modify the contents of the arguments after Write returns.
+func (db *DB) Write(b *Batch, wo *opt.WriteOptions) (err error) {
+	err = db.ok()
+	if err != nil || b == nil || b.Len() == 0 {
+		return
+	}
+
+	b.init(wo.GetSync())
+
+	// The write happen synchronously.
+	select {
+	case db.writeC <- b:
+		if <-db.writeMergedC {
+			return <-db.writeAckC
+		}
+	case db.writeLockC <- struct{}{}:
+	case err = <-db.compPerErrC:
+		return
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+
+	merged := 0
+	danglingMerge := false
+	defer func() {
+		if danglingMerge {
+			db.writeMergedC <- false
+		} else {
+			<-db.writeLockC
+		}
+		for i := 0; i < merged; i++ {
+			db.writeAckC <- err
+		}
+	}()
+
+	mdb, mdbFree, err := db.flush(b.size())
+	if err != nil {
+		return
+	}
+	defer mdb.decref()
+
+	// Calculate maximum size of the batch.
+	m := 1 << 20
+	if x := b.size(); x <= 128<<10 {
+		m = x + (128 << 10)
+	}
+	m = minInt(m, mdbFree)
+
+	// Merge with other batch.
+drain:
+	for b.size() < m && !b.sync {
+		select {
+		case nb := <-db.writeC:
+			if b.size()+nb.size() <= m {
+				b.append(nb)
+				db.writeMergedC <- true
+				merged++
+			} else {
+				danglingMerge = true
+				break drain
+			}
+		default:
+			break drain
+		}
+	}
+
+	// Set batch first seq number relative from last seq.
+	b.seq = db.seq + 1
+
+	// Write journal concurrently if it is large enough.
+	if b.size() >= (128 << 10) {
+		// Push the write batch to the journal writer
+		select {
+		case db.journalC <- b:
+			// Write into memdb
+			if berr := b.memReplay(mdb.DB); berr != nil {
+				panic(berr)
+			}
+		case err = <-db.compPerErrC:
+			return
+		case _, _ = <-db.closeC:
+			err = ErrClosed
+			return
+		}
+		// Wait for journal writer
+		select {
+		case err = <-db.journalAckC:
+			if err != nil {
+				// Revert memdb if error detected
+				if berr := b.revertMemReplay(mdb.DB); berr != nil {
+					panic(berr)
+				}
+				return
+			}
+		case _, _ = <-db.closeC:
+			err = ErrClosed
+			return
+		}
+	} else {
+		err = db.writeJournal(b)
+		if err != nil {
+			return
+		}
+		if berr := b.memReplay(mdb.DB); berr != nil {
+			panic(berr)
+		}
+	}
+
+	// Set last seq number.
+	db.addSeq(uint64(b.Len()))
+
+	if b.size() >= mdbFree {
+		db.rotateMem(0)
+	}
+	return
+}
+
+// Put sets the value for the given key. It overwrites any previous value
+// for that key; a DB is not a multi-map.
+//
+// It is safe to modify the contents of the arguments after Put returns.
+func (db *DB) Put(key, value []byte, wo *opt.WriteOptions) error {
+	b := new(Batch)
+	b.Put(key, value)
+	return db.Write(b, wo)
+}
+
+// Delete deletes the value for the given key. It returns ErrNotFound if
+// the DB does not contain the key.
+//
+// It is safe to modify the contents of the arguments after Delete returns.
+func (db *DB) Delete(key []byte, wo *opt.WriteOptions) error {
+	b := new(Batch)
+	b.Delete(key)
+	return db.Write(b, wo)
+}
+
+func isMemOverlaps(icmp *iComparer, mem *memdb.DB, min, max []byte) bool {
+	iter := mem.NewIterator(nil)
+	defer iter.Release()
+	return (max == nil || (iter.First() && icmp.uCompare(max, iKey(iter.Key()).ukey()) >= 0)) &&
+		(min == nil || (iter.Last() && icmp.uCompare(min, iKey(iter.Key()).ukey()) <= 0))
+}
+
+// CompactRange compacts the underlying DB for the given key range.
+// In particular, deleted and overwritten versions are discarded,
+// and the data is rearranged to reduce the cost of operations
+// needed to access the data. This operation should typically only
+// be invoked by users who understand the underlying implementation.
+//
+// A nil Range.Start is treated as a key before all keys in the DB.
+// And a nil Range.Limit is treated as a key after all keys in the DB.
+// Therefore if both is nil then it will compact entire DB.
+func (db *DB) CompactRange(r util.Range) error {
+	if err := db.ok(); err != nil {
+		return err
+	}
+
+	// Lock writer.
+	select {
+	case db.writeLockC <- struct{}{}:
+	case err := <-db.compPerErrC:
+		return err
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+
+	// Check for overlaps in memdb.
+	mdb := db.getEffectiveMem()
+	defer mdb.decref()
+	if isMemOverlaps(db.s.icmp, mdb.DB, r.Start, r.Limit) {
+		// Memdb compaction.
+		if _, err := db.rotateMem(0); err != nil {
+			<-db.writeLockC
+			return err
+		}
+		<-db.writeLockC
+		if err := db.compSendIdle(db.mcompCmdC); err != nil {
+			return err
+		}
+	} else {
+		<-db.writeLockC
+	}
+
+	// Table compaction.
+	return db.compSendRange(db.tcompCmdC, -1, r.Start, r.Limit)
+}
+
+// SetReadOnly makes DB read-only. It will stay read-only until reopened.
+func (db *DB) SetReadOnly() error {
+	if err := db.ok(); err != nil {
+		return err
+	}
+
+	// Lock writer.
+	select {
+	case db.writeLockC <- struct{}{}:
+		db.compWriteLocking = true
+	case err := <-db.compPerErrC:
+		return err
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+
+	// Set compaction read-only.
+	select {
+	case db.compErrSetC <- ErrReadOnly:
+	case perr := <-db.compPerErrC:
+		return perr
+	case _, _ = <-db.closeC:
+		return ErrClosed
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/doc.go b/vendor/github.com/syndtr/goleveldb/leveldb/doc.go
new file mode 100644
index 00000000..53f13bb2
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/doc.go
@@ -0,0 +1,90 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package leveldb provides implementation of LevelDB key/value database.
+//
+// Create or open a database:
+//
+//	db, err := leveldb.OpenFile("path/to/db", nil)
+//	...
+//	defer db.Close()
+//	...
+//
+// Read or modify the database content:
+//
+//	// Remember that the contents of the returned slice should not be modified.
+//	data, err := db.Get([]byte("key"), nil)
+//	...
+//	err = db.Put([]byte("key"), []byte("value"), nil)
+//	...
+//	err = db.Delete([]byte("key"), nil)
+//	...
+//
+// Iterate over database content:
+//
+//	iter := db.NewIterator(nil, nil)
+//	for iter.Next() {
+//		// Remember that the contents of the returned slice should not be modified, and
+//		// only valid until the next call to Next.
+//		key := iter.Key()
+//		value := iter.Value()
+//		...
+//	}
+//	iter.Release()
+//	err = iter.Error()
+//	...
+//
+// Iterate over subset of database content with a particular prefix:
+//	iter := db.NewIterator(util.BytesPrefix([]byte("foo-")), nil)
+//	for iter.Next() {
+//		// Use key/value.
+//		...
+//	}
+//	iter.Release()
+//	err = iter.Error()
+//	...
+//
+// Seek-then-Iterate:
+//
+// 	iter := db.NewIterator(nil, nil)
+// 	for ok := iter.Seek(key); ok; ok = iter.Next() {
+// 		// Use key/value.
+// 		...
+// 	}
+// 	iter.Release()
+// 	err = iter.Error()
+// 	...
+//
+// Iterate over subset of database content:
+//
+// 	iter := db.NewIterator(&util.Range{Start: []byte("foo"), Limit: []byte("xoo")}, nil)
+// 	for iter.Next() {
+// 		// Use key/value.
+// 		...
+// 	}
+// 	iter.Release()
+// 	err = iter.Error()
+// 	...
+//
+// Batch writes:
+//
+//	batch := new(leveldb.Batch)
+//	batch.Put([]byte("foo"), []byte("value"))
+//	batch.Put([]byte("bar"), []byte("another value"))
+//	batch.Delete([]byte("baz"))
+//	err = db.Write(batch, nil)
+//	...
+//
+// Use bloom filter:
+//
+//	o := &opt.Options{
+//		Filter: filter.NewBloomFilter(10),
+//	}
+//	db, err := leveldb.OpenFile("path/to/db", o)
+//	...
+//	defer db.Close()
+//	...
+package leveldb
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/errors.go b/vendor/github.com/syndtr/goleveldb/leveldb/errors.go
new file mode 100644
index 00000000..c8bd66a5
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/errors.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/errors"
+)
+
+var (
+	ErrNotFound         = errors.ErrNotFound
+	ErrReadOnly         = errors.New("leveldb: read-only mode")
+	ErrSnapshotReleased = errors.New("leveldb: snapshot released")
+	ErrIterReleased     = errors.New("leveldb: iterator released")
+	ErrClosed           = errors.New("leveldb: closed")
+)
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/errors/errors.go b/vendor/github.com/syndtr/goleveldb/leveldb/errors/errors.go
new file mode 100644
index 00000000..84b5d6b7
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/errors/errors.go
@@ -0,0 +1,76 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package errors provides common error types used throughout leveldb.
+package errors
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+	ErrNotFound    = New("leveldb: not found")
+	ErrReleased    = util.ErrReleased
+	ErrHasReleaser = util.ErrHasReleaser
+)
+
+// New returns an error that formats as the given text.
+func New(text string) error {
+	return errors.New(text)
+}
+
+// ErrCorrupted is the type that wraps errors that indicate corruption in
+// the database.
+type ErrCorrupted struct {
+	File *storage.FileInfo
+	Err  error
+}
+
+func (e *ErrCorrupted) Error() string {
+	if e.File != nil {
+		return fmt.Sprintf("%v [file=%v]", e.Err, e.File)
+	} else {
+		return e.Err.Error()
+	}
+}
+
+// NewErrCorrupted creates new ErrCorrupted error.
+func NewErrCorrupted(f storage.File, err error) error {
+	return &ErrCorrupted{storage.NewFileInfo(f), err}
+}
+
+// IsCorrupted returns a boolean indicating whether the error is indicating
+// a corruption.
+func IsCorrupted(err error) bool {
+	switch err.(type) {
+	case *ErrCorrupted:
+		return true
+	}
+	return false
+}
+
+// ErrMissingFiles is the type that indicating a corruption due to missing
+// files.
+type ErrMissingFiles struct {
+	Files []*storage.FileInfo
+}
+
+func (e *ErrMissingFiles) Error() string { return "file missing" }
+
+// SetFile sets 'file info' of the given error with the given file.
+// Currently only ErrCorrupted is supported, otherwise will do nothing.
+func SetFile(err error, f storage.File) error {
+	switch x := err.(type) {
+	case *ErrCorrupted:
+		x.File = storage.NewFileInfo(f)
+		return x
+	}
+	return err
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/filter.go b/vendor/github.com/syndtr/goleveldb/leveldb/filter.go
new file mode 100644
index 00000000..37c1e146
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/filter.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/filter"
+)
+
+type iFilter struct {
+	filter.Filter
+}
+
+func (f iFilter) Contains(filter, key []byte) bool {
+	return f.Filter.Contains(filter, iKey(key).ukey())
+}
+
+func (f iFilter) NewGenerator() filter.FilterGenerator {
+	return iFilterGenerator{f.Filter.NewGenerator()}
+}
+
+type iFilterGenerator struct {
+	filter.FilterGenerator
+}
+
+func (g iFilterGenerator) Add(key []byte) {
+	g.FilterGenerator.Add(iKey(key).ukey())
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/filter/bloom.go b/vendor/github.com/syndtr/goleveldb/leveldb/filter/bloom.go
new file mode 100644
index 00000000..bab0e997
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/filter/bloom.go
@@ -0,0 +1,116 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package filter
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func bloomHash(key []byte) uint32 {
+	return util.Hash(key, 0xbc9f1d34)
+}
+
+type bloomFilter int
+
+// The bloom filter serializes its parameters and is backward compatible
+// with respect to them. Therefor, its parameters are not added to its
+// name.
+func (bloomFilter) Name() string {
+	return "leveldb.BuiltinBloomFilter"
+}
+
+func (f bloomFilter) Contains(filter, key []byte) bool {
+	nBytes := len(filter) - 1
+	if nBytes < 1 {
+		return false
+	}
+	nBits := uint32(nBytes * 8)
+
+	// Use the encoded k so that we can read filters generated by
+	// bloom filters created using different parameters.
+	k := filter[nBytes]
+	if k > 30 {
+		// Reserved for potentially new encodings for short bloom filters.
+		// Consider it a match.
+		return true
+	}
+
+	kh := bloomHash(key)
+	delta := (kh >> 17) | (kh << 15) // Rotate right 17 bits
+	for j := uint8(0); j < k; j++ {
+		bitpos := kh % nBits
+		if (uint32(filter[bitpos/8]) & (1 << (bitpos % 8))) == 0 {
+			return false
+		}
+		kh += delta
+	}
+	return true
+}
+
+func (f bloomFilter) NewGenerator() FilterGenerator {
+	// Round down to reduce probing cost a little bit.
+	k := uint8(f * 69 / 100) // 0.69 =~ ln(2)
+	if k < 1 {
+		k = 1
+	} else if k > 30 {
+		k = 30
+	}
+	return &bloomFilterGenerator{
+		n: int(f),
+		k: k,
+	}
+}
+
+type bloomFilterGenerator struct {
+	n int
+	k uint8
+
+	keyHashes []uint32
+}
+
+func (g *bloomFilterGenerator) Add(key []byte) {
+	// Use double-hashing to generate a sequence of hash values.
+	// See analysis in [Kirsch,Mitzenmacher 2006].
+	g.keyHashes = append(g.keyHashes, bloomHash(key))
+}
+
+func (g *bloomFilterGenerator) Generate(b Buffer) {
+	// Compute bloom filter size (in both bits and bytes)
+	nBits := uint32(len(g.keyHashes) * g.n)
+	// For small n, we can see a very high false positive rate.  Fix it
+	// by enforcing a minimum bloom filter length.
+	if nBits < 64 {
+		nBits = 64
+	}
+	nBytes := (nBits + 7) / 8
+	nBits = nBytes * 8
+
+	dest := b.Alloc(int(nBytes) + 1)
+	dest[nBytes] = g.k
+	for _, kh := range g.keyHashes {
+		delta := (kh >> 17) | (kh << 15) // Rotate right 17 bits
+		for j := uint8(0); j < g.k; j++ {
+			bitpos := kh % nBits
+			dest[bitpos/8] |= (1 << (bitpos % 8))
+			kh += delta
+		}
+	}
+
+	g.keyHashes = g.keyHashes[:0]
+}
+
+// NewBloomFilter creates a new initialized bloom filter for given
+// bitsPerKey.
+//
+// Since bitsPerKey is persisted individually for each bloom filter
+// serialization, bloom filters are backwards compatible with respect to
+// changing bitsPerKey. This means that no big performance penalty will
+// be experienced when changing the parameter. See documentation for
+// opt.Options.Filter for more information.
+func NewBloomFilter(bitsPerKey int) Filter {
+	return bloomFilter(bitsPerKey)
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/filter/filter.go b/vendor/github.com/syndtr/goleveldb/leveldb/filter/filter.go
new file mode 100644
index 00000000..7a925c5a
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/filter/filter.go
@@ -0,0 +1,60 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package filter provides interface and implementation of probabilistic
+// data structure.
+//
+// The filter is resposible for creating small filter from a set of keys.
+// These filter will then used to test whether a key is a member of the set.
+// In many cases, a filter can cut down the number of disk seeks from a
+// handful to a single disk seek per DB.Get call.
+package filter
+
+// Buffer is the interface that wraps basic Alloc, Write and WriteByte methods.
+type Buffer interface {
+	// Alloc allocs n bytes of slice from the buffer. This also advancing
+	// write offset.
+	Alloc(n int) []byte
+
+	// Write appends the contents of p to the buffer.
+	Write(p []byte) (n int, err error)
+
+	// WriteByte appends the byte c to the buffer.
+	WriteByte(c byte) error
+}
+
+// Filter is the filter.
+type Filter interface {
+	// Name returns the name of this policy.
+	//
+	// Note that if the filter encoding changes in an incompatible way,
+	// the name returned by this method must be changed. Otherwise, old
+	// incompatible filters may be passed to methods of this type.
+	Name() string
+
+	// NewGenerator creates a new filter generator.
+	NewGenerator() FilterGenerator
+
+	// Contains returns true if the filter contains the given key.
+	//
+	// The filter are filters generated by the filter generator.
+	Contains(filter, key []byte) bool
+}
+
+// FilterGenerator is the filter generator.
+type FilterGenerator interface {
+	// Add adds a key to the filter generator.
+	//
+	// The key may become invalid after call to this method end, therefor
+	// key must be copied if implementation require keeping key for later
+	// use. The key should not modified directly, doing so may cause
+	// undefined results.
+	Add(key []byte)
+
+	// Generate generates filters based on keys passed so far. After call
+	// to Generate the filter generator maybe resetted, depends on implementation.
+	Generate(b Buffer)
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go
new file mode 100644
index 00000000..a23ab05f
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go
@@ -0,0 +1,184 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// BasicArray is the interface that wraps basic Len and Search method.
+type BasicArray interface {
+	// Len returns length of the array.
+	Len() int
+
+	// Search finds smallest index that point to a key that is greater
+	// than or equal to the given key.
+	Search(key []byte) int
+}
+
+// Array is the interface that wraps BasicArray and basic Index method.
+type Array interface {
+	BasicArray
+
+	// Index returns key/value pair with index of i.
+	Index(i int) (key, value []byte)
+}
+
+// Array is the interface that wraps BasicArray and basic Get method.
+type ArrayIndexer interface {
+	BasicArray
+
+	// Get returns a new data iterator with index of i.
+	Get(i int) Iterator
+}
+
+type basicArrayIterator struct {
+	util.BasicReleaser
+	array BasicArray
+	pos   int
+	err   error
+}
+
+func (i *basicArrayIterator) Valid() bool {
+	return i.pos >= 0 && i.pos < i.array.Len() && !i.Released()
+}
+
+func (i *basicArrayIterator) First() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.array.Len() == 0 {
+		i.pos = -1
+		return false
+	}
+	i.pos = 0
+	return true
+}
+
+func (i *basicArrayIterator) Last() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	n := i.array.Len()
+	if n == 0 {
+		i.pos = 0
+		return false
+	}
+	i.pos = n - 1
+	return true
+}
+
+func (i *basicArrayIterator) Seek(key []byte) bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	n := i.array.Len()
+	if n == 0 {
+		i.pos = 0
+		return false
+	}
+	i.pos = i.array.Search(key)
+	if i.pos >= n {
+		return false
+	}
+	return true
+}
+
+func (i *basicArrayIterator) Next() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	i.pos++
+	if n := i.array.Len(); i.pos >= n {
+		i.pos = n
+		return false
+	}
+	return true
+}
+
+func (i *basicArrayIterator) Prev() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	i.pos--
+	if i.pos < 0 {
+		i.pos = -1
+		return false
+	}
+	return true
+}
+
+func (i *basicArrayIterator) Error() error { return i.err }
+
+type arrayIterator struct {
+	basicArrayIterator
+	array      Array
+	pos        int
+	key, value []byte
+}
+
+func (i *arrayIterator) updateKV() {
+	if i.pos == i.basicArrayIterator.pos {
+		return
+	}
+	i.pos = i.basicArrayIterator.pos
+	if i.Valid() {
+		i.key, i.value = i.array.Index(i.pos)
+	} else {
+		i.key = nil
+		i.value = nil
+	}
+}
+
+func (i *arrayIterator) Key() []byte {
+	i.updateKV()
+	return i.key
+}
+
+func (i *arrayIterator) Value() []byte {
+	i.updateKV()
+	return i.value
+}
+
+type arrayIteratorIndexer struct {
+	basicArrayIterator
+	array ArrayIndexer
+}
+
+func (i *arrayIteratorIndexer) Get() Iterator {
+	if i.Valid() {
+		return i.array.Get(i.basicArrayIterator.pos)
+	}
+	return nil
+}
+
+// NewArrayIterator returns an iterator from the given array.
+func NewArrayIterator(array Array) Iterator {
+	return &arrayIterator{
+		basicArrayIterator: basicArrayIterator{array: array, pos: -1},
+		array:              array,
+		pos:                -1,
+	}
+}
+
+// NewArrayIndexer returns an index iterator from the given array.
+func NewArrayIndexer(array ArrayIndexer) IteratorIndexer {
+	return &arrayIteratorIndexer{
+		basicArrayIterator: basicArrayIterator{array: array, pos: -1},
+		array:              array,
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go
new file mode 100644
index 00000000..939adbb9
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go
@@ -0,0 +1,242 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// IteratorIndexer is the interface that wraps CommonIterator and basic Get
+// method. IteratorIndexer provides index for indexed iterator.
+type IteratorIndexer interface {
+	CommonIterator
+
+	// Get returns a new data iterator for the current position, or nil if
+	// done.
+	Get() Iterator
+}
+
+type indexedIterator struct {
+	util.BasicReleaser
+	index  IteratorIndexer
+	strict bool
+
+	data   Iterator
+	err    error
+	errf   func(err error)
+	closed bool
+}
+
+func (i *indexedIterator) setData() {
+	if i.data != nil {
+		i.data.Release()
+	}
+	i.data = i.index.Get()
+}
+
+func (i *indexedIterator) clearData() {
+	if i.data != nil {
+		i.data.Release()
+	}
+	i.data = nil
+}
+
+func (i *indexedIterator) indexErr() {
+	if err := i.index.Error(); err != nil {
+		if i.errf != nil {
+			i.errf(err)
+		}
+		i.err = err
+	}
+}
+
+func (i *indexedIterator) dataErr() bool {
+	if err := i.data.Error(); err != nil {
+		if i.errf != nil {
+			i.errf(err)
+		}
+		if i.strict || !errors.IsCorrupted(err) {
+			i.err = err
+			return true
+		}
+	}
+	return false
+}
+
+func (i *indexedIterator) Valid() bool {
+	return i.data != nil && i.data.Valid()
+}
+
+func (i *indexedIterator) First() bool {
+	if i.err != nil {
+		return false
+	} else if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if !i.index.First() {
+		i.indexErr()
+		i.clearData()
+		return false
+	}
+	i.setData()
+	return i.Next()
+}
+
+func (i *indexedIterator) Last() bool {
+	if i.err != nil {
+		return false
+	} else if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if !i.index.Last() {
+		i.indexErr()
+		i.clearData()
+		return false
+	}
+	i.setData()
+	if !i.data.Last() {
+		if i.dataErr() {
+			return false
+		}
+		i.clearData()
+		return i.Prev()
+	}
+	return true
+}
+
+func (i *indexedIterator) Seek(key []byte) bool {
+	if i.err != nil {
+		return false
+	} else if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if !i.index.Seek(key) {
+		i.indexErr()
+		i.clearData()
+		return false
+	}
+	i.setData()
+	if !i.data.Seek(key) {
+		if i.dataErr() {
+			return false
+		}
+		i.clearData()
+		return i.Next()
+	}
+	return true
+}
+
+func (i *indexedIterator) Next() bool {
+	if i.err != nil {
+		return false
+	} else if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	switch {
+	case i.data != nil && !i.data.Next():
+		if i.dataErr() {
+			return false
+		}
+		i.clearData()
+		fallthrough
+	case i.data == nil:
+		if !i.index.Next() {
+			i.indexErr()
+			return false
+		}
+		i.setData()
+		return i.Next()
+	}
+	return true
+}
+
+func (i *indexedIterator) Prev() bool {
+	if i.err != nil {
+		return false
+	} else if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	switch {
+	case i.data != nil && !i.data.Prev():
+		if i.dataErr() {
+			return false
+		}
+		i.clearData()
+		fallthrough
+	case i.data == nil:
+		if !i.index.Prev() {
+			i.indexErr()
+			return false
+		}
+		i.setData()
+		if !i.data.Last() {
+			if i.dataErr() {
+				return false
+			}
+			i.clearData()
+			return i.Prev()
+		}
+	}
+	return true
+}
+
+func (i *indexedIterator) Key() []byte {
+	if i.data == nil {
+		return nil
+	}
+	return i.data.Key()
+}
+
+func (i *indexedIterator) Value() []byte {
+	if i.data == nil {
+		return nil
+	}
+	return i.data.Value()
+}
+
+func (i *indexedIterator) Release() {
+	i.clearData()
+	i.index.Release()
+	i.BasicReleaser.Release()
+}
+
+func (i *indexedIterator) Error() error {
+	if i.err != nil {
+		return i.err
+	}
+	if err := i.index.Error(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (i *indexedIterator) SetErrorCallback(f func(err error)) {
+	i.errf = f
+}
+
+// NewIndexedIterator returns an 'indexed iterator'. An index is iterator
+// that returns another iterator, a 'data iterator'. A 'data iterator' is the
+// iterator that contains actual key/value pairs.
+//
+// If strict is true the any 'corruption errors' (i.e errors.IsCorrupted(err) == true)
+// won't be ignored and will halt 'indexed iterator', otherwise the iterator will
+// continue to the next 'data iterator'. Corruption on 'index iterator' will not be
+// ignored and will halt the iterator.
+func NewIndexedIterator(index IteratorIndexer, strict bool) Iterator {
+	return &indexedIterator{index: index, strict: strict}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
new file mode 100644
index 00000000..c2522860
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
@@ -0,0 +1,131 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package iterator provides interface and implementation to traverse over
+// contents of a database.
+package iterator
+
+import (
+	"errors"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+	ErrIterReleased = errors.New("leveldb/iterator: iterator released")
+)
+
+// IteratorSeeker is the interface that wraps the 'seeks method'.
+type IteratorSeeker interface {
+	// First moves the iterator to the first key/value pair. If the iterator
+	// only contains one key/value pair then First and Last whould moves
+	// to the same key/value pair.
+	// It returns whether such pair exist.
+	First() bool
+
+	// Last moves the iterator to the last key/value pair. If the iterator
+	// only contains one key/value pair then First and Last whould moves
+	// to the same key/value pair.
+	// It returns whether such pair exist.
+	Last() bool
+
+	// Seek moves the iterator to the first key/value pair whose key is greater
+	// than or equal to the given key.
+	// It returns whether such pair exist.
+	//
+	// It is safe to modify the contents of the argument after Seek returns.
+	Seek(key []byte) bool
+
+	// Next moves the iterator to the next key/value pair.
+	// It returns whether the iterator is exhausted.
+	Next() bool
+
+	// Prev moves the iterator to the previous key/value pair.
+	// It returns whether the iterator is exhausted.
+	Prev() bool
+}
+
+// CommonIterator is the interface that wraps common interator methods.
+type CommonIterator interface {
+	IteratorSeeker
+
+	// util.Releaser is the interface that wraps basic Release method.
+	// When called Release will releases any resources associated with the
+	// iterator.
+	util.Releaser
+
+	// util.ReleaseSetter is the interface that wraps the basic SetReleaser
+	// method.
+	util.ReleaseSetter
+
+	// TODO: Remove this when ready.
+	Valid() bool
+
+	// Error returns any accumulated error. Exhausting all the key/value pairs
+	// is not considered to be an error.
+	Error() error
+}
+
+// Iterator iterates over a DB's key/value pairs in key order.
+//
+// When encouter an error any 'seeks method' will return false and will
+// yield no key/value pairs. The error can be queried by calling the Error
+// method. Calling Release is still necessary.
+//
+// An iterator must be released after use, but it is not necessary to read
+// an iterator until exhaustion.
+// Also, an iterator is not necessarily goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+type Iterator interface {
+	CommonIterator
+
+	// Key returns the key of the current key/value pair, or nil if done.
+	// The caller should not modify the contents of the returned slice, and
+	// its contents may change on the next call to any 'seeks method'.
+	Key() []byte
+
+	// Value returns the key of the current key/value pair, or nil if done.
+	// The caller should not modify the contents of the returned slice, and
+	// its contents may change on the next call to any 'seeks method'.
+	Value() []byte
+}
+
+// ErrorCallbackSetter is the interface that wraps basic SetErrorCallback
+// method.
+//
+// ErrorCallbackSetter implemented by indexed and merged iterator.
+type ErrorCallbackSetter interface {
+	// SetErrorCallback allows set an error callback of the coresponding
+	// iterator. Use nil to clear the callback.
+	SetErrorCallback(f func(err error))
+}
+
+type emptyIterator struct {
+	util.BasicReleaser
+	err error
+}
+
+func (i *emptyIterator) rErr() {
+	if i.err == nil && i.Released() {
+		i.err = ErrIterReleased
+	}
+}
+
+func (*emptyIterator) Valid() bool            { return false }
+func (i *emptyIterator) First() bool          { i.rErr(); return false }
+func (i *emptyIterator) Last() bool           { i.rErr(); return false }
+func (i *emptyIterator) Seek(key []byte) bool { i.rErr(); return false }
+func (i *emptyIterator) Next() bool           { i.rErr(); return false }
+func (i *emptyIterator) Prev() bool           { i.rErr(); return false }
+func (*emptyIterator) Key() []byte            { return nil }
+func (*emptyIterator) Value() []byte          { return nil }
+func (i *emptyIterator) Error() error         { return i.err }
+
+// NewEmptyIterator creates an empty iterator. The err parameter can be
+// nil, but if not nil the given err will be returned by Error method.
+func NewEmptyIterator(err error) Iterator {
+	return &emptyIterator{err: err}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go
new file mode 100644
index 00000000..1a7e29df
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go
@@ -0,0 +1,304 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package iterator
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/comparer"
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type dir int
+
+const (
+	dirReleased dir = iota - 1
+	dirSOI
+	dirEOI
+	dirBackward
+	dirForward
+)
+
+type mergedIterator struct {
+	cmp    comparer.Comparer
+	iters  []Iterator
+	strict bool
+
+	keys     [][]byte
+	index    int
+	dir      dir
+	err      error
+	errf     func(err error)
+	releaser util.Releaser
+}
+
+func assertKey(key []byte) []byte {
+	if key == nil {
+		panic("leveldb/iterator: nil key")
+	}
+	return key
+}
+
+func (i *mergedIterator) iterErr(iter Iterator) bool {
+	if err := iter.Error(); err != nil {
+		if i.errf != nil {
+			i.errf(err)
+		}
+		if i.strict || !errors.IsCorrupted(err) {
+			i.err = err
+			return true
+		}
+	}
+	return false
+}
+
+func (i *mergedIterator) Valid() bool {
+	return i.err == nil && i.dir > dirEOI
+}
+
+func (i *mergedIterator) First() bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	for x, iter := range i.iters {
+		switch {
+		case iter.First():
+			i.keys[x] = assertKey(iter.Key())
+		case i.iterErr(iter):
+			return false
+		default:
+			i.keys[x] = nil
+		}
+	}
+	i.dir = dirSOI
+	return i.next()
+}
+
+func (i *mergedIterator) Last() bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	for x, iter := range i.iters {
+		switch {
+		case iter.Last():
+			i.keys[x] = assertKey(iter.Key())
+		case i.iterErr(iter):
+			return false
+		default:
+			i.keys[x] = nil
+		}
+	}
+	i.dir = dirEOI
+	return i.prev()
+}
+
+func (i *mergedIterator) Seek(key []byte) bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	for x, iter := range i.iters {
+		switch {
+		case iter.Seek(key):
+			i.keys[x] = assertKey(iter.Key())
+		case i.iterErr(iter):
+			return false
+		default:
+			i.keys[x] = nil
+		}
+	}
+	i.dir = dirSOI
+	return i.next()
+}
+
+func (i *mergedIterator) next() bool {
+	var key []byte
+	if i.dir == dirForward {
+		key = i.keys[i.index]
+	}
+	for x, tkey := range i.keys {
+		if tkey != nil && (key == nil || i.cmp.Compare(tkey, key) < 0) {
+			key = tkey
+			i.index = x
+		}
+	}
+	if key == nil {
+		i.dir = dirEOI
+		return false
+	}
+	i.dir = dirForward
+	return true
+}
+
+func (i *mergedIterator) Next() bool {
+	if i.dir == dirEOI || i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	switch i.dir {
+	case dirSOI:
+		return i.First()
+	case dirBackward:
+		key := append([]byte{}, i.keys[i.index]...)
+		if !i.Seek(key) {
+			return false
+		}
+		return i.Next()
+	}
+
+	x := i.index
+	iter := i.iters[x]
+	switch {
+	case iter.Next():
+		i.keys[x] = assertKey(iter.Key())
+	case i.iterErr(iter):
+		return false
+	default:
+		i.keys[x] = nil
+	}
+	return i.next()
+}
+
+func (i *mergedIterator) prev() bool {
+	var key []byte
+	if i.dir == dirBackward {
+		key = i.keys[i.index]
+	}
+	for x, tkey := range i.keys {
+		if tkey != nil && (key == nil || i.cmp.Compare(tkey, key) > 0) {
+			key = tkey
+			i.index = x
+		}
+	}
+	if key == nil {
+		i.dir = dirSOI
+		return false
+	}
+	i.dir = dirBackward
+	return true
+}
+
+func (i *mergedIterator) Prev() bool {
+	if i.dir == dirSOI || i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	switch i.dir {
+	case dirEOI:
+		return i.Last()
+	case dirForward:
+		key := append([]byte{}, i.keys[i.index]...)
+		for x, iter := range i.iters {
+			if x == i.index {
+				continue
+			}
+			seek := iter.Seek(key)
+			switch {
+			case seek && iter.Prev(), !seek && iter.Last():
+				i.keys[x] = assertKey(iter.Key())
+			case i.iterErr(iter):
+				return false
+			default:
+				i.keys[x] = nil
+			}
+		}
+	}
+
+	x := i.index
+	iter := i.iters[x]
+	switch {
+	case iter.Prev():
+		i.keys[x] = assertKey(iter.Key())
+	case i.iterErr(iter):
+		return false
+	default:
+		i.keys[x] = nil
+	}
+	return i.prev()
+}
+
+func (i *mergedIterator) Key() []byte {
+	if i.err != nil || i.dir <= dirEOI {
+		return nil
+	}
+	return i.keys[i.index]
+}
+
+func (i *mergedIterator) Value() []byte {
+	if i.err != nil || i.dir <= dirEOI {
+		return nil
+	}
+	return i.iters[i.index].Value()
+}
+
+func (i *mergedIterator) Release() {
+	if i.dir != dirReleased {
+		i.dir = dirReleased
+		for _, iter := range i.iters {
+			iter.Release()
+		}
+		i.iters = nil
+		i.keys = nil
+		if i.releaser != nil {
+			i.releaser.Release()
+			i.releaser = nil
+		}
+	}
+}
+
+func (i *mergedIterator) SetReleaser(releaser util.Releaser) {
+	if i.dir == dirReleased {
+		panic(util.ErrReleased)
+	}
+	if i.releaser != nil && releaser != nil {
+		panic(util.ErrHasReleaser)
+	}
+	i.releaser = releaser
+}
+
+func (i *mergedIterator) Error() error {
+	return i.err
+}
+
+func (i *mergedIterator) SetErrorCallback(f func(err error)) {
+	i.errf = f
+}
+
+// NewMergedIterator returns an iterator that merges its input. Walking the
+// resultant iterator will return all key/value pairs of all input iterators
+// in strictly increasing key order, as defined by cmp.
+// The input's key ranges may overlap, but there are assumed to be no duplicate
+// keys: if iters[i] contains a key k then iters[j] will not contain that key k.
+// None of the iters may be nil.
+//
+// If strict is true the any 'corruption errors' (i.e errors.IsCorrupted(err) == true)
+// won't be ignored and will halt 'merged iterator', otherwise the iterator will
+// continue to the next 'input iterator'.
+func NewMergedIterator(iters []Iterator, cmp comparer.Comparer, strict bool) Iterator {
+	return &mergedIterator{
+		iters:  iters,
+		cmp:    cmp,
+		strict: strict,
+		keys:   make([][]byte, len(iters)),
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/journal/journal.go b/vendor/github.com/syndtr/goleveldb/leveldb/journal/journal.go
new file mode 100644
index 00000000..6519ec66
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/journal/journal.go
@@ -0,0 +1,520 @@
+// Copyright 2011 The LevelDB-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.
+
+// Taken from: https://code.google.com/p/leveldb-go/source/browse/leveldb/record/record.go?r=1d5ccbe03246da926391ee12d1c6caae054ff4b0
+// License, authors and contributors informations can be found at bellow URLs respectively:
+// 	https://code.google.com/p/leveldb-go/source/browse/LICENSE
+//	https://code.google.com/p/leveldb-go/source/browse/AUTHORS
+//  https://code.google.com/p/leveldb-go/source/browse/CONTRIBUTORS
+
+// Package journal reads and writes sequences of journals. Each journal is a stream
+// of bytes that completes before the next journal starts.
+//
+// When reading, call Next to obtain an io.Reader for the next journal. Next will
+// return io.EOF when there are no more journals. It is valid to call Next
+// without reading the current journal to exhaustion.
+//
+// When writing, call Next to obtain an io.Writer for the next journal. Calling
+// Next finishes the current journal. Call Close to finish the final journal.
+//
+// Optionally, call Flush to finish the current journal and flush the underlying
+// writer without starting a new journal. To start a new journal after flushing,
+// call Next.
+//
+// Neither Readers or Writers are safe to use concurrently.
+//
+// Example code:
+//	func read(r io.Reader) ([]string, error) {
+//		var ss []string
+//		journals := journal.NewReader(r, nil, true, true)
+//		for {
+//			j, err := journals.Next()
+//			if err == io.EOF {
+//				break
+//			}
+//			if err != nil {
+//				return nil, err
+//			}
+//			s, err := ioutil.ReadAll(j)
+//			if err != nil {
+//				return nil, err
+//			}
+//			ss = append(ss, string(s))
+//		}
+//		return ss, nil
+//	}
+//
+//	func write(w io.Writer, ss []string) error {
+//		journals := journal.NewWriter(w)
+//		for _, s := range ss {
+//			j, err := journals.Next()
+//			if err != nil {
+//				return err
+//			}
+//			if _, err := j.Write([]byte(s)), err != nil {
+//				return err
+//			}
+//		}
+//		return journals.Close()
+//	}
+//
+// The wire format is that the stream is divided into 32KiB blocks, and each
+// block contains a number of tightly packed chunks. Chunks cannot cross block
+// boundaries. The last block may be shorter than 32 KiB. Any unused bytes in a
+// block must be zero.
+//
+// A journal maps to one or more chunks. Each chunk has a 7 byte header (a 4
+// byte checksum, a 2 byte little-endian uint16 length, and a 1 byte chunk type)
+// followed by a payload. The checksum is over the chunk type and the payload.
+//
+// There are four chunk types: whether the chunk is the full journal, or the
+// first, middle or last chunk of a multi-chunk journal. A multi-chunk journal
+// has one first chunk, zero or more middle chunks, and one last chunk.
+//
+// The wire format allows for limited recovery in the face of data corruption:
+// on a format error (such as a checksum mismatch), the reader moves to the
+// next block and looks for the next full or first chunk.
+package journal
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// These constants are part of the wire format and should not be changed.
+const (
+	fullChunkType   = 1
+	firstChunkType  = 2
+	middleChunkType = 3
+	lastChunkType   = 4
+)
+
+const (
+	blockSize  = 32 * 1024
+	headerSize = 7
+)
+
+type flusher interface {
+	Flush() error
+}
+
+// ErrCorrupted is the error type that generated by corrupted block or chunk.
+type ErrCorrupted struct {
+	Size   int
+	Reason string
+}
+
+func (e *ErrCorrupted) Error() string {
+	return fmt.Sprintf("leveldb/journal: block/chunk corrupted: %s (%d bytes)", e.Reason, e.Size)
+}
+
+// Dropper is the interface that wrap simple Drop method. The Drop
+// method will be called when the journal reader dropping a block or chunk.
+type Dropper interface {
+	Drop(err error)
+}
+
+// Reader reads journals from an underlying io.Reader.
+type Reader struct {
+	// r is the underlying reader.
+	r io.Reader
+	// the dropper.
+	dropper Dropper
+	// strict flag.
+	strict bool
+	// checksum flag.
+	checksum bool
+	// seq is the sequence number of the current journal.
+	seq int
+	// buf[i:j] is the unread portion of the current chunk's payload.
+	// The low bound, i, excludes the chunk header.
+	i, j int
+	// n is the number of bytes of buf that are valid. Once reading has started,
+	// only the final block can have n < blockSize.
+	n int
+	// last is whether the current chunk is the last chunk of the journal.
+	last bool
+	// err is any accumulated error.
+	err error
+	// buf is the buffer.
+	buf [blockSize]byte
+}
+
+// NewReader returns a new reader. The dropper may be nil, and if
+// strict is true then corrupted or invalid chunk will halt the journal
+// reader entirely.
+func NewReader(r io.Reader, dropper Dropper, strict, checksum bool) *Reader {
+	return &Reader{
+		r:        r,
+		dropper:  dropper,
+		strict:   strict,
+		checksum: checksum,
+		last:     true,
+	}
+}
+
+var errSkip = errors.New("leveldb/journal: skipped")
+
+func (r *Reader) corrupt(n int, reason string, skip bool) error {
+	if r.dropper != nil {
+		r.dropper.Drop(&ErrCorrupted{n, reason})
+	}
+	if r.strict && !skip {
+		r.err = errors.NewErrCorrupted(nil, &ErrCorrupted{n, reason})
+		return r.err
+	}
+	return errSkip
+}
+
+// nextChunk sets r.buf[r.i:r.j] to hold the next chunk's payload, reading the
+// next block into the buffer if necessary.
+func (r *Reader) nextChunk(first bool) error {
+	for {
+		if r.j+headerSize <= r.n {
+			checksum := binary.LittleEndian.Uint32(r.buf[r.j+0 : r.j+4])
+			length := binary.LittleEndian.Uint16(r.buf[r.j+4 : r.j+6])
+			chunkType := r.buf[r.j+6]
+
+			if checksum == 0 && length == 0 && chunkType == 0 {
+				// Drop entire block.
+				m := r.n - r.j
+				r.i = r.n
+				r.j = r.n
+				return r.corrupt(m, "zero header", false)
+			} else {
+				m := r.n - r.j
+				r.i = r.j + headerSize
+				r.j = r.j + headerSize + int(length)
+				if r.j > r.n {
+					// Drop entire block.
+					r.i = r.n
+					r.j = r.n
+					return r.corrupt(m, "chunk length overflows block", false)
+				} else if r.checksum && checksum != util.NewCRC(r.buf[r.i-1:r.j]).Value() {
+					// Drop entire block.
+					r.i = r.n
+					r.j = r.n
+					return r.corrupt(m, "checksum mismatch", false)
+				}
+			}
+			if first && chunkType != fullChunkType && chunkType != firstChunkType {
+				m := r.j - r.i
+				r.i = r.j
+				// Report the error, but skip it.
+				return r.corrupt(m+headerSize, "orphan chunk", true)
+			}
+			r.last = chunkType == fullChunkType || chunkType == lastChunkType
+			return nil
+		}
+
+		// The last block.
+		if r.n < blockSize && r.n > 0 {
+			if !first {
+				return r.corrupt(0, "missing chunk part", false)
+			}
+			r.err = io.EOF
+			return r.err
+		}
+
+		// Read block.
+		n, err := io.ReadFull(r.r, r.buf[:])
+		if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
+			return err
+		}
+		if n == 0 {
+			if !first {
+				return r.corrupt(0, "missing chunk part", false)
+			}
+			r.err = io.EOF
+			return r.err
+		}
+		r.i, r.j, r.n = 0, 0, n
+	}
+}
+
+// Next returns a reader for the next journal. It returns io.EOF if there are no
+// more journals. The reader returned becomes stale after the next Next call,
+// and should no longer be used. If strict is false, the reader will returns
+// io.ErrUnexpectedEOF error when found corrupted journal.
+func (r *Reader) Next() (io.Reader, error) {
+	r.seq++
+	if r.err != nil {
+		return nil, r.err
+	}
+	r.i = r.j
+	for {
+		if err := r.nextChunk(true); err == nil {
+			break
+		} else if err != errSkip {
+			return nil, err
+		}
+	}
+	return &singleReader{r, r.seq, nil}, nil
+}
+
+// Reset resets the journal reader, allows reuse of the journal reader. Reset returns
+// last accumulated error.
+func (r *Reader) Reset(reader io.Reader, dropper Dropper, strict, checksum bool) error {
+	r.seq++
+	err := r.err
+	r.r = reader
+	r.dropper = dropper
+	r.strict = strict
+	r.checksum = checksum
+	r.i = 0
+	r.j = 0
+	r.n = 0
+	r.last = true
+	r.err = nil
+	return err
+}
+
+type singleReader struct {
+	r   *Reader
+	seq int
+	err error
+}
+
+func (x *singleReader) Read(p []byte) (int, error) {
+	r := x.r
+	if r.seq != x.seq {
+		return 0, errors.New("leveldb/journal: stale reader")
+	}
+	if x.err != nil {
+		return 0, x.err
+	}
+	if r.err != nil {
+		return 0, r.err
+	}
+	for r.i == r.j {
+		if r.last {
+			return 0, io.EOF
+		}
+		x.err = r.nextChunk(false)
+		if x.err != nil {
+			if x.err == errSkip {
+				x.err = io.ErrUnexpectedEOF
+			}
+			return 0, x.err
+		}
+	}
+	n := copy(p, r.buf[r.i:r.j])
+	r.i += n
+	return n, nil
+}
+
+func (x *singleReader) ReadByte() (byte, error) {
+	r := x.r
+	if r.seq != x.seq {
+		return 0, errors.New("leveldb/journal: stale reader")
+	}
+	if x.err != nil {
+		return 0, x.err
+	}
+	if r.err != nil {
+		return 0, r.err
+	}
+	for r.i == r.j {
+		if r.last {
+			return 0, io.EOF
+		}
+		x.err = r.nextChunk(false)
+		if x.err != nil {
+			if x.err == errSkip {
+				x.err = io.ErrUnexpectedEOF
+			}
+			return 0, x.err
+		}
+	}
+	c := r.buf[r.i]
+	r.i++
+	return c, nil
+}
+
+// Writer writes journals to an underlying io.Writer.
+type Writer struct {
+	// w is the underlying writer.
+	w io.Writer
+	// seq is the sequence number of the current journal.
+	seq int
+	// f is w as a flusher.
+	f flusher
+	// buf[i:j] is the bytes that will become the current chunk.
+	// The low bound, i, includes the chunk header.
+	i, j int
+	// buf[:written] has already been written to w.
+	// written is zero unless Flush has been called.
+	written int
+	// first is whether the current chunk is the first chunk of the journal.
+	first bool
+	// pending is whether a chunk is buffered but not yet written.
+	pending bool
+	// err is any accumulated error.
+	err error
+	// buf is the buffer.
+	buf [blockSize]byte
+}
+
+// NewWriter returns a new Writer.
+func NewWriter(w io.Writer) *Writer {
+	f, _ := w.(flusher)
+	return &Writer{
+		w: w,
+		f: f,
+	}
+}
+
+// fillHeader fills in the header for the pending chunk.
+func (w *Writer) fillHeader(last bool) {
+	if w.i+headerSize > w.j || w.j > blockSize {
+		panic("leveldb/journal: bad writer state")
+	}
+	if last {
+		if w.first {
+			w.buf[w.i+6] = fullChunkType
+		} else {
+			w.buf[w.i+6] = lastChunkType
+		}
+	} else {
+		if w.first {
+			w.buf[w.i+6] = firstChunkType
+		} else {
+			w.buf[w.i+6] = middleChunkType
+		}
+	}
+	binary.LittleEndian.PutUint32(w.buf[w.i+0:w.i+4], util.NewCRC(w.buf[w.i+6:w.j]).Value())
+	binary.LittleEndian.PutUint16(w.buf[w.i+4:w.i+6], uint16(w.j-w.i-headerSize))
+}
+
+// writeBlock writes the buffered block to the underlying writer, and reserves
+// space for the next chunk's header.
+func (w *Writer) writeBlock() {
+	_, w.err = w.w.Write(w.buf[w.written:])
+	w.i = 0
+	w.j = headerSize
+	w.written = 0
+}
+
+// writePending finishes the current journal and writes the buffer to the
+// underlying writer.
+func (w *Writer) writePending() {
+	if w.err != nil {
+		return
+	}
+	if w.pending {
+		w.fillHeader(true)
+		w.pending = false
+	}
+	_, w.err = w.w.Write(w.buf[w.written:w.j])
+	w.written = w.j
+}
+
+// Close finishes the current journal and closes the writer.
+func (w *Writer) Close() error {
+	w.seq++
+	w.writePending()
+	if w.err != nil {
+		return w.err
+	}
+	w.err = errors.New("leveldb/journal: closed Writer")
+	return nil
+}
+
+// Flush finishes the current journal, writes to the underlying writer, and
+// flushes it if that writer implements interface{ Flush() error }.
+func (w *Writer) Flush() error {
+	w.seq++
+	w.writePending()
+	if w.err != nil {
+		return w.err
+	}
+	if w.f != nil {
+		w.err = w.f.Flush()
+		return w.err
+	}
+	return nil
+}
+
+// Reset resets the journal writer, allows reuse of the journal writer. Reset
+// will also closes the journal writer if not already.
+func (w *Writer) Reset(writer io.Writer) (err error) {
+	w.seq++
+	if w.err == nil {
+		w.writePending()
+		err = w.err
+	}
+	w.w = writer
+	w.f, _ = writer.(flusher)
+	w.i = 0
+	w.j = 0
+	w.written = 0
+	w.first = false
+	w.pending = false
+	w.err = nil
+	return
+}
+
+// Next returns a writer for the next journal. The writer returned becomes stale
+// after the next Close, Flush or Next call, and should no longer be used.
+func (w *Writer) Next() (io.Writer, error) {
+	w.seq++
+	if w.err != nil {
+		return nil, w.err
+	}
+	if w.pending {
+		w.fillHeader(true)
+	}
+	w.i = w.j
+	w.j = w.j + headerSize
+	// Check if there is room in the block for the header.
+	if w.j > blockSize {
+		// Fill in the rest of the block with zeroes.
+		for k := w.i; k < blockSize; k++ {
+			w.buf[k] = 0
+		}
+		w.writeBlock()
+		if w.err != nil {
+			return nil, w.err
+		}
+	}
+	w.first = true
+	w.pending = true
+	return singleWriter{w, w.seq}, nil
+}
+
+type singleWriter struct {
+	w   *Writer
+	seq int
+}
+
+func (x singleWriter) Write(p []byte) (int, error) {
+	w := x.w
+	if w.seq != x.seq {
+		return 0, errors.New("leveldb/journal: stale writer")
+	}
+	if w.err != nil {
+		return 0, w.err
+	}
+	n0 := len(p)
+	for len(p) > 0 {
+		// Write a block, if it is full.
+		if w.j == blockSize {
+			w.fillHeader(false)
+			w.writeBlock()
+			if w.err != nil {
+				return 0, w.err
+			}
+			w.first = false
+		}
+		// Copy bytes into the buffer.
+		n := copy(w.buf[w.j:], p)
+		w.j += n
+		p = p[n:]
+	}
+	return n0, nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/key.go b/vendor/github.com/syndtr/goleveldb/leveldb/key.go
new file mode 100644
index 00000000..572ae815
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/key.go
@@ -0,0 +1,142 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+)
+
+type ErrIkeyCorrupted struct {
+	Ikey   []byte
+	Reason string
+}
+
+func (e *ErrIkeyCorrupted) Error() string {
+	return fmt.Sprintf("leveldb: iKey %q corrupted: %s", e.Ikey, e.Reason)
+}
+
+func newErrIkeyCorrupted(ikey []byte, reason string) error {
+	return errors.NewErrCorrupted(nil, &ErrIkeyCorrupted{append([]byte{}, ikey...), reason})
+}
+
+type kType int
+
+func (kt kType) String() string {
+	switch kt {
+	case ktDel:
+		return "d"
+	case ktVal:
+		return "v"
+	}
+	return "x"
+}
+
+// Value types encoded as the last component of internal keys.
+// Don't modify; this value are saved to disk.
+const (
+	ktDel kType = iota
+	ktVal
+)
+
+// ktSeek defines the kType that should be passed when constructing an
+// internal key for seeking to a particular sequence number (since we
+// sort sequence numbers in decreasing order and the value type is
+// embedded as the low 8 bits in the sequence number in internal keys,
+// we need to use the highest-numbered ValueType, not the lowest).
+const ktSeek = ktVal
+
+const (
+	// Maximum value possible for sequence number; the 8-bits are
+	// used by value type, so its can packed together in single
+	// 64-bit integer.
+	kMaxSeq uint64 = (uint64(1) << 56) - 1
+	// Maximum value possible for packed sequence number and type.
+	kMaxNum uint64 = (kMaxSeq << 8) | uint64(ktSeek)
+)
+
+// Maximum number encoded in bytes.
+var kMaxNumBytes = make([]byte, 8)
+
+func init() {
+	binary.LittleEndian.PutUint64(kMaxNumBytes, kMaxNum)
+}
+
+type iKey []byte
+
+func newIkey(ukey []byte, seq uint64, kt kType) iKey {
+	if seq > kMaxSeq {
+		panic("leveldb: invalid sequence number")
+	} else if kt > ktVal {
+		panic("leveldb: invalid type")
+	}
+
+	ik := make(iKey, len(ukey)+8)
+	copy(ik, ukey)
+	binary.LittleEndian.PutUint64(ik[len(ukey):], (seq<<8)|uint64(kt))
+	return ik
+}
+
+func parseIkey(ik []byte) (ukey []byte, seq uint64, kt kType, err error) {
+	if len(ik) < 8 {
+		return nil, 0, 0, newErrIkeyCorrupted(ik, "invalid length")
+	}
+	num := binary.LittleEndian.Uint64(ik[len(ik)-8:])
+	seq, kt = uint64(num>>8), kType(num&0xff)
+	if kt > ktVal {
+		return nil, 0, 0, newErrIkeyCorrupted(ik, "invalid type")
+	}
+	ukey = ik[:len(ik)-8]
+	return
+}
+
+func validIkey(ik []byte) bool {
+	_, _, _, err := parseIkey(ik)
+	return err == nil
+}
+
+func (ik iKey) assert() {
+	if ik == nil {
+		panic("leveldb: nil iKey")
+	}
+	if len(ik) < 8 {
+		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", []byte(ik), len(ik)))
+	}
+}
+
+func (ik iKey) ukey() []byte {
+	ik.assert()
+	return ik[:len(ik)-8]
+}
+
+func (ik iKey) num() uint64 {
+	ik.assert()
+	return binary.LittleEndian.Uint64(ik[len(ik)-8:])
+}
+
+func (ik iKey) parseNum() (seq uint64, kt kType) {
+	num := ik.num()
+	seq, kt = uint64(num>>8), kType(num&0xff)
+	if kt > ktVal {
+		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", []byte(ik), len(ik), kt))
+	}
+	return
+}
+
+func (ik iKey) String() string {
+	if ik == nil {
+		return "<nil>"
+	}
+
+	if ukey, seq, kt, err := parseIkey(ik); err == nil {
+		return fmt.Sprintf("%s,%s%d", shorten(string(ukey)), kt, seq)
+	} else {
+		return "<invalid>"
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go b/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
new file mode 100644
index 00000000..1395bd92
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
@@ -0,0 +1,471 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package memdb provides in-memory key/value database implementation.
+package memdb
+
+import (
+	"math/rand"
+	"sync"
+
+	"github.com/syndtr/goleveldb/leveldb/comparer"
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+	ErrNotFound     = errors.ErrNotFound
+	ErrIterReleased = errors.New("leveldb/memdb: iterator released")
+)
+
+const tMaxHeight = 12
+
+type dbIter struct {
+	util.BasicReleaser
+	p          *DB
+	slice      *util.Range
+	node       int
+	forward    bool
+	key, value []byte
+	err        error
+}
+
+func (i *dbIter) fill(checkStart, checkLimit bool) bool {
+	if i.node != 0 {
+		n := i.p.nodeData[i.node]
+		m := n + i.p.nodeData[i.node+nKey]
+		i.key = i.p.kvData[n:m]
+		if i.slice != nil {
+			switch {
+			case checkLimit && i.slice.Limit != nil && i.p.cmp.Compare(i.key, i.slice.Limit) >= 0:
+				fallthrough
+			case checkStart && i.slice.Start != nil && i.p.cmp.Compare(i.key, i.slice.Start) < 0:
+				i.node = 0
+				goto bail
+			}
+		}
+		i.value = i.p.kvData[m : m+i.p.nodeData[i.node+nVal]]
+		return true
+	}
+bail:
+	i.key = nil
+	i.value = nil
+	return false
+}
+
+func (i *dbIter) Valid() bool {
+	return i.node != 0
+}
+
+func (i *dbIter) First() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	i.forward = true
+	i.p.mu.RLock()
+	defer i.p.mu.RUnlock()
+	if i.slice != nil && i.slice.Start != nil {
+		i.node, _ = i.p.findGE(i.slice.Start, false)
+	} else {
+		i.node = i.p.nodeData[nNext]
+	}
+	return i.fill(false, true)
+}
+
+func (i *dbIter) Last() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	i.forward = false
+	i.p.mu.RLock()
+	defer i.p.mu.RUnlock()
+	if i.slice != nil && i.slice.Limit != nil {
+		i.node = i.p.findLT(i.slice.Limit)
+	} else {
+		i.node = i.p.findLast()
+	}
+	return i.fill(true, false)
+}
+
+func (i *dbIter) Seek(key []byte) bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	i.forward = true
+	i.p.mu.RLock()
+	defer i.p.mu.RUnlock()
+	if i.slice != nil && i.slice.Start != nil && i.p.cmp.Compare(key, i.slice.Start) < 0 {
+		key = i.slice.Start
+	}
+	i.node, _ = i.p.findGE(key, false)
+	return i.fill(false, true)
+}
+
+func (i *dbIter) Next() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.node == 0 {
+		if !i.forward {
+			return i.First()
+		}
+		return false
+	}
+	i.forward = true
+	i.p.mu.RLock()
+	defer i.p.mu.RUnlock()
+	i.node = i.p.nodeData[i.node+nNext]
+	return i.fill(false, true)
+}
+
+func (i *dbIter) Prev() bool {
+	if i.Released() {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.node == 0 {
+		if i.forward {
+			return i.Last()
+		}
+		return false
+	}
+	i.forward = false
+	i.p.mu.RLock()
+	defer i.p.mu.RUnlock()
+	i.node = i.p.findLT(i.key)
+	return i.fill(true, false)
+}
+
+func (i *dbIter) Key() []byte {
+	return i.key
+}
+
+func (i *dbIter) Value() []byte {
+	return i.value
+}
+
+func (i *dbIter) Error() error { return i.err }
+
+func (i *dbIter) Release() {
+	if !i.Released() {
+		i.p = nil
+		i.node = 0
+		i.key = nil
+		i.value = nil
+		i.BasicReleaser.Release()
+	}
+}
+
+const (
+	nKV = iota
+	nKey
+	nVal
+	nHeight
+	nNext
+)
+
+// DB is an in-memory key/value database.
+type DB struct {
+	cmp comparer.BasicComparer
+	rnd *rand.Rand
+
+	mu     sync.RWMutex
+	kvData []byte
+	// Node data:
+	// [0]         : KV offset
+	// [1]         : Key length
+	// [2]         : Value length
+	// [3]         : Height
+	// [3..height] : Next nodes
+	nodeData  []int
+	prevNode  [tMaxHeight]int
+	maxHeight int
+	n         int
+	kvSize    int
+}
+
+func (p *DB) randHeight() (h int) {
+	const branching = 4
+	h = 1
+	for h < tMaxHeight && p.rnd.Int()%branching == 0 {
+		h++
+	}
+	return
+}
+
+// Must hold RW-lock if prev == true, as it use shared prevNode slice.
+func (p *DB) findGE(key []byte, prev bool) (int, bool) {
+	node := 0
+	h := p.maxHeight - 1
+	for {
+		next := p.nodeData[node+nNext+h]
+		cmp := 1
+		if next != 0 {
+			o := p.nodeData[next]
+			cmp = p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key)
+		}
+		if cmp < 0 {
+			// Keep searching in this list
+			node = next
+		} else {
+			if prev {
+				p.prevNode[h] = node
+			} else if cmp == 0 {
+				return next, true
+			}
+			if h == 0 {
+				return next, cmp == 0
+			}
+			h--
+		}
+	}
+}
+
+func (p *DB) findLT(key []byte) int {
+	node := 0
+	h := p.maxHeight - 1
+	for {
+		next := p.nodeData[node+nNext+h]
+		o := p.nodeData[next]
+		if next == 0 || p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key) >= 0 {
+			if h == 0 {
+				break
+			}
+			h--
+		} else {
+			node = next
+		}
+	}
+	return node
+}
+
+func (p *DB) findLast() int {
+	node := 0
+	h := p.maxHeight - 1
+	for {
+		next := p.nodeData[node+nNext+h]
+		if next == 0 {
+			if h == 0 {
+				break
+			}
+			h--
+		} else {
+			node = next
+		}
+	}
+	return node
+}
+
+// Put sets the value for the given key. It overwrites any previous value
+// for that key; a DB is not a multi-map.
+//
+// It is safe to modify the contents of the arguments after Put returns.
+func (p *DB) Put(key []byte, value []byte) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if node, exact := p.findGE(key, true); exact {
+		kvOffset := len(p.kvData)
+		p.kvData = append(p.kvData, key...)
+		p.kvData = append(p.kvData, value...)
+		p.nodeData[node] = kvOffset
+		m := p.nodeData[node+nVal]
+		p.nodeData[node+nVal] = len(value)
+		p.kvSize += len(value) - m
+		return nil
+	}
+
+	h := p.randHeight()
+	if h > p.maxHeight {
+		for i := p.maxHeight; i < h; i++ {
+			p.prevNode[i] = 0
+		}
+		p.maxHeight = h
+	}
+
+	kvOffset := len(p.kvData)
+	p.kvData = append(p.kvData, key...)
+	p.kvData = append(p.kvData, value...)
+	// Node
+	node := len(p.nodeData)
+	p.nodeData = append(p.nodeData, kvOffset, len(key), len(value), h)
+	for i, n := range p.prevNode[:h] {
+		m := n + nNext + i
+		p.nodeData = append(p.nodeData, p.nodeData[m])
+		p.nodeData[m] = node
+	}
+
+	p.kvSize += len(key) + len(value)
+	p.n++
+	return nil
+}
+
+// Delete deletes the value for the given key. It returns ErrNotFound if
+// the DB does not contain the key.
+//
+// It is safe to modify the contents of the arguments after Delete returns.
+func (p *DB) Delete(key []byte) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	node, exact := p.findGE(key, true)
+	if !exact {
+		return ErrNotFound
+	}
+
+	h := p.nodeData[node+nHeight]
+	for i, n := range p.prevNode[:h] {
+		m := n + 4 + i
+		p.nodeData[m] = p.nodeData[p.nodeData[m]+nNext+i]
+	}
+
+	p.kvSize -= p.nodeData[node+nKey] + p.nodeData[node+nVal]
+	p.n--
+	return nil
+}
+
+// Contains returns true if the given key are in the DB.
+//
+// It is safe to modify the contents of the arguments after Contains returns.
+func (p *DB) Contains(key []byte) bool {
+	p.mu.RLock()
+	_, exact := p.findGE(key, false)
+	p.mu.RUnlock()
+	return exact
+}
+
+// Get gets the value for the given key. It returns error.ErrNotFound if the
+// DB does not contain the key.
+//
+// The caller should not modify the contents of the returned slice, but
+// it is safe to modify the contents of the argument after Get returns.
+func (p *DB) Get(key []byte) (value []byte, err error) {
+	p.mu.RLock()
+	if node, exact := p.findGE(key, false); exact {
+		o := p.nodeData[node] + p.nodeData[node+nKey]
+		value = p.kvData[o : o+p.nodeData[node+nVal]]
+	} else {
+		err = ErrNotFound
+	}
+	p.mu.RUnlock()
+	return
+}
+
+// Find finds key/value pair whose key is greater than or equal to the
+// given key. It returns ErrNotFound if the table doesn't contain
+// such pair.
+//
+// The caller should not modify the contents of the returned slice, but
+// it is safe to modify the contents of the argument after Find returns.
+func (p *DB) Find(key []byte) (rkey, value []byte, err error) {
+	p.mu.RLock()
+	if node, _ := p.findGE(key, false); node != 0 {
+		n := p.nodeData[node]
+		m := n + p.nodeData[node+nKey]
+		rkey = p.kvData[n:m]
+		value = p.kvData[m : m+p.nodeData[node+nVal]]
+	} else {
+		err = ErrNotFound
+	}
+	p.mu.RUnlock()
+	return
+}
+
+// NewIterator returns an iterator of the DB.
+// The returned iterator is not goroutine-safe, but it is safe to use
+// multiple iterators concurrently, with each in a dedicated goroutine.
+// It is also safe to use an iterator concurrently with modifying its
+// underlying DB. However, the resultant key/value pairs are not guaranteed
+// to be a consistent snapshot of the DB at a particular point in time.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// DB. And a nil Range.Limit is treated as a key after all keys in
+// the DB.
+//
+// The iterator must be released after use, by calling Release method.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (p *DB) NewIterator(slice *util.Range) iterator.Iterator {
+	return &dbIter{p: p, slice: slice}
+}
+
+// Capacity returns keys/values buffer capacity.
+func (p *DB) Capacity() int {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return cap(p.kvData)
+}
+
+// Size returns sum of keys and values length. Note that deleted
+// key/value will not be accouted for, but it will still consume
+// the buffer, since the buffer is append only.
+func (p *DB) Size() int {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return p.kvSize
+}
+
+// Free returns keys/values free buffer before need to grow.
+func (p *DB) Free() int {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return cap(p.kvData) - len(p.kvData)
+}
+
+// Len returns the number of entries in the DB.
+func (p *DB) Len() int {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return p.n
+}
+
+// Reset resets the DB to initial empty state. Allows reuse the buffer.
+func (p *DB) Reset() {
+	p.mu.Lock()
+	p.rnd = rand.New(rand.NewSource(0xdeadbeef))
+	p.maxHeight = 1
+	p.n = 0
+	p.kvSize = 0
+	p.kvData = p.kvData[:0]
+	p.nodeData = p.nodeData[:nNext+tMaxHeight]
+	p.nodeData[nKV] = 0
+	p.nodeData[nKey] = 0
+	p.nodeData[nVal] = 0
+	p.nodeData[nHeight] = tMaxHeight
+	for n := 0; n < tMaxHeight; n++ {
+		p.nodeData[nNext+n] = 0
+		p.prevNode[n] = 0
+	}
+	p.mu.Unlock()
+}
+
+// New creates a new initalized in-memory key/value DB. The capacity
+// is the initial key/value buffer capacity. The capacity is advisory,
+// not enforced.
+//
+// The returned DB instance is goroutine-safe.
+func New(cmp comparer.BasicComparer, capacity int) *DB {
+	p := &DB{
+		cmp:       cmp,
+		rnd:       rand.New(rand.NewSource(0xdeadbeef)),
+		maxHeight: 1,
+		kvData:    make([]byte, 0, capacity),
+		nodeData:  make([]int, 4+tMaxHeight),
+	}
+	p.nodeData[nHeight] = tMaxHeight
+	return p
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/opt/options.go b/vendor/github.com/syndtr/goleveldb/leveldb/opt/options.go
new file mode 100644
index 00000000..f9a309da
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/opt/options.go
@@ -0,0 +1,670 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package opt provides sets of options used by LevelDB.
+package opt
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/cache"
+	"github.com/syndtr/goleveldb/leveldb/comparer"
+	"github.com/syndtr/goleveldb/leveldb/filter"
+	"math"
+)
+
+const (
+	KiB = 1024
+	MiB = KiB * 1024
+	GiB = MiB * 1024
+)
+
+var (
+	DefaultBlockCacher                   = LRUCacher
+	DefaultBlockCacheCapacity            = 8 * MiB
+	DefaultBlockRestartInterval          = 16
+	DefaultBlockSize                     = 4 * KiB
+	DefaultCompactionExpandLimitFactor   = 25
+	DefaultCompactionGPOverlapsFactor    = 10
+	DefaultCompactionL0Trigger           = 4
+	DefaultCompactionSourceLimitFactor   = 1
+	DefaultCompactionTableSize           = 2 * MiB
+	DefaultCompactionTableSizeMultiplier = 1.0
+	DefaultCompactionTotalSize           = 10 * MiB
+	DefaultCompactionTotalSizeMultiplier = 10.0
+	DefaultCompressionType               = SnappyCompression
+	DefaultIteratorSamplingRate          = 1 * MiB
+	DefaultMaxMemCompationLevel          = 2
+	DefaultNumLevel                      = 7
+	DefaultOpenFilesCacher               = LRUCacher
+	DefaultOpenFilesCacheCapacity        = 500
+	DefaultWriteBuffer                   = 4 * MiB
+	DefaultWriteL0PauseTrigger           = 12
+	DefaultWriteL0SlowdownTrigger        = 8
+)
+
+// Cacher is a caching algorithm.
+type Cacher interface {
+	New(capacity int) cache.Cacher
+}
+
+type CacherFunc struct {
+	NewFunc func(capacity int) cache.Cacher
+}
+
+func (f *CacherFunc) New(capacity int) cache.Cacher {
+	if f.NewFunc != nil {
+		return f.NewFunc(capacity)
+	}
+	return nil
+}
+
+func noCacher(int) cache.Cacher { return nil }
+
+var (
+	// LRUCacher is the LRU-cache algorithm.
+	LRUCacher = &CacherFunc{cache.NewLRU}
+
+	// NoCacher is the value to disable caching algorithm.
+	NoCacher = &CacherFunc{}
+)
+
+// Compression is the 'sorted table' block compression algorithm to use.
+type Compression uint
+
+func (c Compression) String() string {
+	switch c {
+	case DefaultCompression:
+		return "default"
+	case NoCompression:
+		return "none"
+	case SnappyCompression:
+		return "snappy"
+	}
+	return "invalid"
+}
+
+const (
+	DefaultCompression Compression = iota
+	NoCompression
+	SnappyCompression
+	nCompression
+)
+
+// Strict is the DB 'strict level'.
+type Strict uint
+
+const (
+	// If present then a corrupted or invalid chunk or block in manifest
+	// journal will cause an error instead of being dropped.
+	// This will prevent database with corrupted manifest to be opened.
+	StrictManifest Strict = 1 << iota
+
+	// If present then journal chunk checksum will be verified.
+	StrictJournalChecksum
+
+	// If present then a corrupted or invalid chunk or block in journal
+	// will cause an error instead of being dropped.
+	// This will prevent database with corrupted journal to be opened.
+	StrictJournal
+
+	// If present then 'sorted table' block checksum will be verified.
+	// This has effect on both 'read operation' and compaction.
+	StrictBlockChecksum
+
+	// If present then a corrupted 'sorted table' will fails compaction.
+	// The database will enter read-only mode.
+	StrictCompaction
+
+	// If present then a corrupted 'sorted table' will halts 'read operation'.
+	StrictReader
+
+	// If present then leveldb.Recover will drop corrupted 'sorted table'.
+	StrictRecovery
+
+	// This only applicable for ReadOptions, if present then this ReadOptions
+	// 'strict level' will override global ones.
+	StrictOverride
+
+	// StrictAll enables all strict flags.
+	StrictAll = StrictManifest | StrictJournalChecksum | StrictJournal | StrictBlockChecksum | StrictCompaction | StrictReader | StrictRecovery
+
+	// DefaultStrict is the default strict flags. Specify any strict flags
+	// will override default strict flags as whole (i.e. not OR'ed).
+	DefaultStrict = StrictJournalChecksum | StrictBlockChecksum | StrictCompaction | StrictReader
+
+	// NoStrict disables all strict flags. Override default strict flags.
+	NoStrict = ^StrictAll
+)
+
+// Options holds the optional parameters for the DB at large.
+type Options struct {
+	// AltFilters defines one or more 'alternative filters'.
+	// 'alternative filters' will be used during reads if a filter block
+	// does not match with the 'effective filter'.
+	//
+	// The default value is nil
+	AltFilters []filter.Filter
+
+	// BlockCacher provides cache algorithm for LevelDB 'sorted table' block caching.
+	// Specify NoCacher to disable caching algorithm.
+	//
+	// The default value is LRUCacher.
+	BlockCacher Cacher
+
+	// BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
+	// Use -1 for zero, this has same effect as specifying NoCacher to BlockCacher.
+	//
+	// The default value is 8MiB.
+	BlockCacheCapacity int
+
+	// BlockRestartInterval is the number of keys between restart points for
+	// delta encoding of keys.
+	//
+	// The default value is 16.
+	BlockRestartInterval int
+
+	// BlockSize is the minimum uncompressed size in bytes of each 'sorted table'
+	// block.
+	//
+	// The default value is 4KiB.
+	BlockSize int
+
+	// CompactionExpandLimitFactor limits compaction size after expanded.
+	// This will be multiplied by table size limit at compaction target level.
+	//
+	// The default value is 25.
+	CompactionExpandLimitFactor int
+
+	// CompactionGPOverlapsFactor limits overlaps in grandparent (Level + 2) that a
+	// single 'sorted table' generates.
+	// This will be multiplied by table size limit at grandparent level.
+	//
+	// The default value is 10.
+	CompactionGPOverlapsFactor int
+
+	// CompactionL0Trigger defines number of 'sorted table' at level-0 that will
+	// trigger compaction.
+	//
+	// The default value is 4.
+	CompactionL0Trigger int
+
+	// CompactionSourceLimitFactor limits compaction source size. This doesn't apply to
+	// level-0.
+	// This will be multiplied by table size limit at compaction target level.
+	//
+	// The default value is 1.
+	CompactionSourceLimitFactor int
+
+	// CompactionTableSize limits size of 'sorted table' that compaction generates.
+	// The limits for each level will be calculated as:
+	//   CompactionTableSize * (CompactionTableSizeMultiplier ^ Level)
+	// The multiplier for each level can also fine-tuned using CompactionTableSizeMultiplierPerLevel.
+	//
+	// The default value is 2MiB.
+	CompactionTableSize int
+
+	// CompactionTableSizeMultiplier defines multiplier for CompactionTableSize.
+	//
+	// The default value is 1.
+	CompactionTableSizeMultiplier float64
+
+	// CompactionTableSizeMultiplierPerLevel defines per-level multiplier for
+	// CompactionTableSize.
+	// Use zero to skip a level.
+	//
+	// The default value is nil.
+	CompactionTableSizeMultiplierPerLevel []float64
+
+	// CompactionTotalSize limits total size of 'sorted table' for each level.
+	// The limits for each level will be calculated as:
+	//   CompactionTotalSize * (CompactionTotalSizeMultiplier ^ Level)
+	// The multiplier for each level can also fine-tuned using
+	// CompactionTotalSizeMultiplierPerLevel.
+	//
+	// The default value is 10MiB.
+	CompactionTotalSize int
+
+	// CompactionTotalSizeMultiplier defines multiplier for CompactionTotalSize.
+	//
+	// The default value is 10.
+	CompactionTotalSizeMultiplier float64
+
+	// CompactionTotalSizeMultiplierPerLevel defines per-level multiplier for
+	// CompactionTotalSize.
+	// Use zero to skip a level.
+	//
+	// The default value is nil.
+	CompactionTotalSizeMultiplierPerLevel []float64
+
+	// Comparer defines a total ordering over the space of []byte keys: a 'less
+	// than' relationship. The same comparison algorithm must be used for reads
+	// and writes over the lifetime of the DB.
+	//
+	// The default value uses the same ordering as bytes.Compare.
+	Comparer comparer.Comparer
+
+	// Compression defines the 'sorted table' block compression to use.
+	//
+	// The default value (DefaultCompression) uses snappy compression.
+	Compression Compression
+
+	// DisableBufferPool allows disable use of util.BufferPool functionality.
+	//
+	// The default value is false.
+	DisableBufferPool bool
+
+	// DisableBlockCache allows disable use of cache.Cache functionality on
+	// 'sorted table' block.
+	//
+	// The default value is false.
+	DisableBlockCache bool
+
+	// DisableCompactionBackoff allows disable compaction retry backoff.
+	//
+	// The default value is false.
+	DisableCompactionBackoff bool
+
+	// ErrorIfExist defines whether an error should returned if the DB already
+	// exist.
+	//
+	// The default value is false.
+	ErrorIfExist bool
+
+	// ErrorIfMissing defines whether an error should returned if the DB is
+	// missing. If false then the database will be created if missing, otherwise
+	// an error will be returned.
+	//
+	// The default value is false.
+	ErrorIfMissing bool
+
+	// Filter defines an 'effective filter' to use. An 'effective filter'
+	// if defined will be used to generate per-table filter block.
+	// The filter name will be stored on disk.
+	// During reads LevelDB will try to find matching filter from
+	// 'effective filter' and 'alternative filters'.
+	//
+	// Filter can be changed after a DB has been created. It is recommended
+	// to put old filter to the 'alternative filters' to mitigate lack of
+	// filter during transition period.
+	//
+	// A filter is used to reduce disk reads when looking for a specific key.
+	//
+	// The default value is nil.
+	Filter filter.Filter
+
+	// IteratorSamplingRate defines approximate gap (in bytes) between read
+	// sampling of an iterator. The samples will be used to determine when
+	// compaction should be triggered.
+	//
+	// The default is 1MiB.
+	IteratorSamplingRate int
+
+	// MaxMemCompationLevel defines maximum level a newly compacted 'memdb'
+	// will be pushed into if doesn't creates overlap. This should less than
+	// NumLevel. Use -1 for level-0.
+	//
+	// The default is 2.
+	MaxMemCompationLevel int
+
+	// NumLevel defines number of database level. The level shouldn't changed
+	// between opens, or the database will panic.
+	//
+	// The default is 7.
+	NumLevel int
+
+	// OpenFilesCacher provides cache algorithm for open files caching.
+	// Specify NoCacher to disable caching algorithm.
+	//
+	// The default value is LRUCacher.
+	OpenFilesCacher Cacher
+
+	// OpenFilesCacheCapacity defines the capacity of the open files caching.
+	// Use -1 for zero, this has same effect as specifying NoCacher to OpenFilesCacher.
+	//
+	// The default value is 500.
+	OpenFilesCacheCapacity int
+
+	// If true then opens DB in read-only mode.
+	//
+	// The default value is false.
+	ReadOnly bool
+
+	// Strict defines the DB strict level.
+	Strict Strict
+
+	// WriteBuffer defines maximum size of a 'memdb' before flushed to
+	// 'sorted table'. 'memdb' is an in-memory DB backed by an on-disk
+	// unsorted journal.
+	//
+	// LevelDB may held up to two 'memdb' at the same time.
+	//
+	// The default value is 4MiB.
+	WriteBuffer int
+
+	// WriteL0StopTrigger defines number of 'sorted table' at level-0 that will
+	// pause write.
+	//
+	// The default value is 12.
+	WriteL0PauseTrigger int
+
+	// WriteL0SlowdownTrigger defines number of 'sorted table' at level-0 that
+	// will trigger write slowdown.
+	//
+	// The default value is 8.
+	WriteL0SlowdownTrigger int
+}
+
+func (o *Options) GetAltFilters() []filter.Filter {
+	if o == nil {
+		return nil
+	}
+	return o.AltFilters
+}
+
+func (o *Options) GetBlockCacher() Cacher {
+	if o == nil || o.BlockCacher == nil {
+		return DefaultBlockCacher
+	} else if o.BlockCacher == NoCacher {
+		return nil
+	}
+	return o.BlockCacher
+}
+
+func (o *Options) GetBlockCacheCapacity() int {
+	if o == nil || o.BlockCacheCapacity == 0 {
+		return DefaultBlockCacheCapacity
+	} else if o.BlockCacheCapacity < 0 {
+		return 0
+	}
+	return o.BlockCacheCapacity
+}
+
+func (o *Options) GetBlockRestartInterval() int {
+	if o == nil || o.BlockRestartInterval <= 0 {
+		return DefaultBlockRestartInterval
+	}
+	return o.BlockRestartInterval
+}
+
+func (o *Options) GetBlockSize() int {
+	if o == nil || o.BlockSize <= 0 {
+		return DefaultBlockSize
+	}
+	return o.BlockSize
+}
+
+func (o *Options) GetCompactionExpandLimit(level int) int {
+	factor := DefaultCompactionExpandLimitFactor
+	if o != nil && o.CompactionExpandLimitFactor > 0 {
+		factor = o.CompactionExpandLimitFactor
+	}
+	return o.GetCompactionTableSize(level+1) * factor
+}
+
+func (o *Options) GetCompactionGPOverlaps(level int) int {
+	factor := DefaultCompactionGPOverlapsFactor
+	if o != nil && o.CompactionGPOverlapsFactor > 0 {
+		factor = o.CompactionGPOverlapsFactor
+	}
+	return o.GetCompactionTableSize(level+2) * factor
+}
+
+func (o *Options) GetCompactionL0Trigger() int {
+	if o == nil || o.CompactionL0Trigger == 0 {
+		return DefaultCompactionL0Trigger
+	}
+	return o.CompactionL0Trigger
+}
+
+func (o *Options) GetCompactionSourceLimit(level int) int {
+	factor := DefaultCompactionSourceLimitFactor
+	if o != nil && o.CompactionSourceLimitFactor > 0 {
+		factor = o.CompactionSourceLimitFactor
+	}
+	return o.GetCompactionTableSize(level+1) * factor
+}
+
+func (o *Options) GetCompactionTableSize(level int) int {
+	var (
+		base = DefaultCompactionTableSize
+		mult float64
+	)
+	if o != nil {
+		if o.CompactionTableSize > 0 {
+			base = o.CompactionTableSize
+		}
+		if len(o.CompactionTableSizeMultiplierPerLevel) > level && o.CompactionTableSizeMultiplierPerLevel[level] > 0 {
+			mult = o.CompactionTableSizeMultiplierPerLevel[level]
+		} else if o.CompactionTableSizeMultiplier > 0 {
+			mult = math.Pow(o.CompactionTableSizeMultiplier, float64(level))
+		}
+	}
+	if mult == 0 {
+		mult = math.Pow(DefaultCompactionTableSizeMultiplier, float64(level))
+	}
+	return int(float64(base) * mult)
+}
+
+func (o *Options) GetCompactionTotalSize(level int) int64 {
+	var (
+		base = DefaultCompactionTotalSize
+		mult float64
+	)
+	if o != nil {
+		if o.CompactionTotalSize > 0 {
+			base = o.CompactionTotalSize
+		}
+		if len(o.CompactionTotalSizeMultiplierPerLevel) > level && o.CompactionTotalSizeMultiplierPerLevel[level] > 0 {
+			mult = o.CompactionTotalSizeMultiplierPerLevel[level]
+		} else if o.CompactionTotalSizeMultiplier > 0 {
+			mult = math.Pow(o.CompactionTotalSizeMultiplier, float64(level))
+		}
+	}
+	if mult == 0 {
+		mult = math.Pow(DefaultCompactionTotalSizeMultiplier, float64(level))
+	}
+	return int64(float64(base) * mult)
+}
+
+func (o *Options) GetComparer() comparer.Comparer {
+	if o == nil || o.Comparer == nil {
+		return comparer.DefaultComparer
+	}
+	return o.Comparer
+}
+
+func (o *Options) GetCompression() Compression {
+	if o == nil || o.Compression <= DefaultCompression || o.Compression >= nCompression {
+		return DefaultCompressionType
+	}
+	return o.Compression
+}
+
+func (o *Options) GetDisableBufferPool() bool {
+	if o == nil {
+		return false
+	}
+	return o.DisableBufferPool
+}
+
+func (o *Options) GetDisableBlockCache() bool {
+	if o == nil {
+		return false
+	}
+	return o.DisableBlockCache
+}
+
+func (o *Options) GetDisableCompactionBackoff() bool {
+	if o == nil {
+		return false
+	}
+	return o.DisableCompactionBackoff
+}
+
+func (o *Options) GetErrorIfExist() bool {
+	if o == nil {
+		return false
+	}
+	return o.ErrorIfExist
+}
+
+func (o *Options) GetErrorIfMissing() bool {
+	if o == nil {
+		return false
+	}
+	return o.ErrorIfMissing
+}
+
+func (o *Options) GetFilter() filter.Filter {
+	if o == nil {
+		return nil
+	}
+	return o.Filter
+}
+
+func (o *Options) GetIteratorSamplingRate() int {
+	if o == nil || o.IteratorSamplingRate <= 0 {
+		return DefaultIteratorSamplingRate
+	}
+	return o.IteratorSamplingRate
+}
+
+func (o *Options) GetMaxMemCompationLevel() int {
+	level := DefaultMaxMemCompationLevel
+	if o != nil {
+		if o.MaxMemCompationLevel > 0 {
+			level = o.MaxMemCompationLevel
+		} else if o.MaxMemCompationLevel < 0 {
+			level = 0
+		}
+	}
+	if level >= o.GetNumLevel() {
+		return o.GetNumLevel() - 1
+	}
+	return level
+}
+
+func (o *Options) GetNumLevel() int {
+	if o == nil || o.NumLevel <= 0 {
+		return DefaultNumLevel
+	}
+	return o.NumLevel
+}
+
+func (o *Options) GetOpenFilesCacher() Cacher {
+	if o == nil || o.OpenFilesCacher == nil {
+		return DefaultOpenFilesCacher
+	}
+	if o.OpenFilesCacher == NoCacher {
+		return nil
+	}
+	return o.OpenFilesCacher
+}
+
+func (o *Options) GetOpenFilesCacheCapacity() int {
+	if o == nil || o.OpenFilesCacheCapacity == 0 {
+		return DefaultOpenFilesCacheCapacity
+	} else if o.OpenFilesCacheCapacity < 0 {
+		return 0
+	}
+	return o.OpenFilesCacheCapacity
+}
+
+func (o *Options) GetReadOnly() bool {
+	if o == nil {
+		return false
+	}
+	return o.ReadOnly
+}
+
+func (o *Options) GetStrict(strict Strict) bool {
+	if o == nil || o.Strict == 0 {
+		return DefaultStrict&strict != 0
+	}
+	return o.Strict&strict != 0
+}
+
+func (o *Options) GetWriteBuffer() int {
+	if o == nil || o.WriteBuffer <= 0 {
+		return DefaultWriteBuffer
+	}
+	return o.WriteBuffer
+}
+
+func (o *Options) GetWriteL0PauseTrigger() int {
+	if o == nil || o.WriteL0PauseTrigger == 0 {
+		return DefaultWriteL0PauseTrigger
+	}
+	return o.WriteL0PauseTrigger
+}
+
+func (o *Options) GetWriteL0SlowdownTrigger() int {
+	if o == nil || o.WriteL0SlowdownTrigger == 0 {
+		return DefaultWriteL0SlowdownTrigger
+	}
+	return o.WriteL0SlowdownTrigger
+}
+
+// ReadOptions holds the optional parameters for 'read operation'. The
+// 'read operation' includes Get, Find and NewIterator.
+type ReadOptions struct {
+	// DontFillCache defines whether block reads for this 'read operation'
+	// should be cached. If false then the block will be cached. This does
+	// not affects already cached block.
+	//
+	// The default value is false.
+	DontFillCache bool
+
+	// Strict will be OR'ed with global DB 'strict level' unless StrictOverride
+	// is present. Currently only StrictReader that has effect here.
+	Strict Strict
+}
+
+func (ro *ReadOptions) GetDontFillCache() bool {
+	if ro == nil {
+		return false
+	}
+	return ro.DontFillCache
+}
+
+func (ro *ReadOptions) GetStrict(strict Strict) bool {
+	if ro == nil {
+		return false
+	}
+	return ro.Strict&strict != 0
+}
+
+// WriteOptions holds the optional parameters for 'write operation'. The
+// 'write operation' includes Write, Put and Delete.
+type WriteOptions struct {
+	// Sync is whether to sync underlying writes from the OS buffer cache
+	// through to actual disk, if applicable. Setting Sync can result in
+	// slower writes.
+	//
+	// If false, and the machine crashes, then some recent writes may be lost.
+	// Note that if it is just the process that crashes (and the machine does
+	// not) then no writes will be lost.
+	//
+	// In other words, Sync being false has the same semantics as a write
+	// system call. Sync being true means write followed by fsync.
+	//
+	// The default value is false.
+	Sync bool
+}
+
+func (wo *WriteOptions) GetSync() bool {
+	if wo == nil {
+		return false
+	}
+	return wo.Sync
+}
+
+func GetStrict(o *Options, ro *ReadOptions, strict Strict) bool {
+	if ro.GetStrict(StrictOverride) {
+		return ro.GetStrict(strict)
+	} else {
+		return o.GetStrict(strict) || ro.GetStrict(strict)
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/options.go b/vendor/github.com/syndtr/goleveldb/leveldb/options.go
new file mode 100644
index 00000000..a3d84ef6
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/options.go
@@ -0,0 +1,92 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/filter"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+func dupOptions(o *opt.Options) *opt.Options {
+	newo := &opt.Options{}
+	if o != nil {
+		*newo = *o
+	}
+	if newo.Strict == 0 {
+		newo.Strict = opt.DefaultStrict
+	}
+	return newo
+}
+
+func (s *session) setOptions(o *opt.Options) {
+	no := dupOptions(o)
+	// Alternative filters.
+	if filters := o.GetAltFilters(); len(filters) > 0 {
+		no.AltFilters = make([]filter.Filter, len(filters))
+		for i, filter := range filters {
+			no.AltFilters[i] = &iFilter{filter}
+		}
+	}
+	// Comparer.
+	s.icmp = &iComparer{o.GetComparer()}
+	no.Comparer = s.icmp
+	// Filter.
+	if filter := o.GetFilter(); filter != nil {
+		no.Filter = &iFilter{filter}
+	}
+
+	s.o = &cachedOptions{Options: no}
+	s.o.cache()
+}
+
+type cachedOptions struct {
+	*opt.Options
+
+	compactionExpandLimit []int
+	compactionGPOverlaps  []int
+	compactionSourceLimit []int
+	compactionTableSize   []int
+	compactionTotalSize   []int64
+}
+
+func (co *cachedOptions) cache() {
+	numLevel := co.Options.GetNumLevel()
+
+	co.compactionExpandLimit = make([]int, numLevel)
+	co.compactionGPOverlaps = make([]int, numLevel)
+	co.compactionSourceLimit = make([]int, numLevel)
+	co.compactionTableSize = make([]int, numLevel)
+	co.compactionTotalSize = make([]int64, numLevel)
+
+	for level := 0; level < numLevel; level++ {
+		co.compactionExpandLimit[level] = co.Options.GetCompactionExpandLimit(level)
+		co.compactionGPOverlaps[level] = co.Options.GetCompactionGPOverlaps(level)
+		co.compactionSourceLimit[level] = co.Options.GetCompactionSourceLimit(level)
+		co.compactionTableSize[level] = co.Options.GetCompactionTableSize(level)
+		co.compactionTotalSize[level] = co.Options.GetCompactionTotalSize(level)
+	}
+}
+
+func (co *cachedOptions) GetCompactionExpandLimit(level int) int {
+	return co.compactionExpandLimit[level]
+}
+
+func (co *cachedOptions) GetCompactionGPOverlaps(level int) int {
+	return co.compactionGPOverlaps[level]
+}
+
+func (co *cachedOptions) GetCompactionSourceLimit(level int) int {
+	return co.compactionSourceLimit[level]
+}
+
+func (co *cachedOptions) GetCompactionTableSize(level int) int {
+	return co.compactionTableSize[level]
+}
+
+func (co *cachedOptions) GetCompactionTotalSize(level int) int64 {
+	return co.compactionTotalSize[level]
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/session.go b/vendor/github.com/syndtr/goleveldb/leveldb/session.go
new file mode 100644
index 00000000..f0bba460
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/session.go
@@ -0,0 +1,211 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sync"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/journal"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type ErrManifestCorrupted struct {
+	Field  string
+	Reason string
+}
+
+func (e *ErrManifestCorrupted) Error() string {
+	return fmt.Sprintf("leveldb: manifest corrupted (field '%s'): %s", e.Field, e.Reason)
+}
+
+func newErrManifestCorrupted(f storage.File, field, reason string) error {
+	return errors.NewErrCorrupted(f, &ErrManifestCorrupted{field, reason})
+}
+
+// session represent a persistent database session.
+type session struct {
+	// Need 64-bit alignment.
+	stNextFileNum    uint64 // current unused file number
+	stJournalNum     uint64 // current journal file number; need external synchronization
+	stPrevJournalNum uint64 // prev journal file number; no longer used; for compatibility with older version of leveldb
+	stSeqNum         uint64 // last mem compacted seq; need external synchronization
+	stTempFileNum    uint64
+
+	stor     storage.Storage
+	storLock util.Releaser
+	o        *cachedOptions
+	icmp     *iComparer
+	tops     *tOps
+
+	manifest       *journal.Writer
+	manifestWriter storage.Writer
+	manifestFile   storage.File
+
+	stCompPtrs []iKey   // compaction pointers; need external synchronization
+	stVersion  *version // current version
+	vmu        sync.Mutex
+}
+
+// Creates new initialized session instance.
+func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
+	if stor == nil {
+		return nil, os.ErrInvalid
+	}
+	storLock, err := stor.Lock()
+	if err != nil {
+		return
+	}
+	s = &session{
+		stor:       stor,
+		storLock:   storLock,
+		stCompPtrs: make([]iKey, o.GetNumLevel()),
+	}
+	s.setOptions(o)
+	s.tops = newTableOps(s)
+	s.setVersion(newVersion(s))
+	s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed")
+	return
+}
+
+// Close session.
+func (s *session) close() {
+	s.tops.close()
+	if s.manifest != nil {
+		s.manifest.Close()
+	}
+	if s.manifestWriter != nil {
+		s.manifestWriter.Close()
+	}
+	s.manifest = nil
+	s.manifestWriter = nil
+	s.manifestFile = nil
+	s.stVersion = nil
+}
+
+// Release session lock.
+func (s *session) release() {
+	s.storLock.Release()
+}
+
+// Create a new database session; need external synchronization.
+func (s *session) create() error {
+	// create manifest
+	return s.newManifest(nil, nil)
+}
+
+// Recover a database session; need external synchronization.
+func (s *session) recover() (err error) {
+	defer func() {
+		if os.IsNotExist(err) {
+			// Don't return os.ErrNotExist if the underlying storage contains
+			// other files that belong to LevelDB. So the DB won't get trashed.
+			if files, _ := s.stor.GetFiles(storage.TypeAll); len(files) > 0 {
+				err = &errors.ErrCorrupted{File: &storage.FileInfo{Type: storage.TypeManifest}, Err: &errors.ErrMissingFiles{}}
+			}
+		}
+	}()
+
+	m, err := s.stor.GetManifest()
+	if err != nil {
+		return
+	}
+
+	reader, err := m.Open()
+	if err != nil {
+		return
+	}
+	defer reader.Close()
+
+	var (
+		// Options.
+		numLevel = s.o.GetNumLevel()
+		strict   = s.o.GetStrict(opt.StrictManifest)
+
+		jr      = journal.NewReader(reader, dropper{s, m}, strict, true)
+		rec     = &sessionRecord{}
+		staging = s.stVersion.newStaging()
+	)
+	for {
+		var r io.Reader
+		r, err = jr.Next()
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+				break
+			}
+			return errors.SetFile(err, m)
+		}
+
+		err = rec.decode(r, numLevel)
+		if err == nil {
+			// save compact pointers
+			for _, r := range rec.compPtrs {
+				s.stCompPtrs[r.level] = iKey(r.ikey)
+			}
+			// commit record to version staging
+			staging.commit(rec)
+		} else {
+			err = errors.SetFile(err, m)
+			if strict || !errors.IsCorrupted(err) {
+				return
+			} else {
+				s.logf("manifest error: %v (skipped)", errors.SetFile(err, m))
+			}
+		}
+		rec.resetCompPtrs()
+		rec.resetAddedTables()
+		rec.resetDeletedTables()
+	}
+
+	switch {
+	case !rec.has(recComparer):
+		return newErrManifestCorrupted(m, "comparer", "missing")
+	case rec.comparer != s.icmp.uName():
+		return newErrManifestCorrupted(m, "comparer", fmt.Sprintf("mismatch: want '%s', got '%s'", s.icmp.uName(), rec.comparer))
+	case !rec.has(recNextFileNum):
+		return newErrManifestCorrupted(m, "next-file-num", "missing")
+	case !rec.has(recJournalNum):
+		return newErrManifestCorrupted(m, "journal-file-num", "missing")
+	case !rec.has(recSeqNum):
+		return newErrManifestCorrupted(m, "seq-num", "missing")
+	}
+
+	s.manifestFile = m
+	s.setVersion(staging.finish())
+	s.setNextFileNum(rec.nextFileNum)
+	s.recordCommited(rec)
+	return nil
+}
+
+// Commit session; need external synchronization.
+func (s *session) commit(r *sessionRecord) (err error) {
+	v := s.version()
+	defer v.release()
+
+	// spawn new version based on current version
+	nv := v.spawn(r)
+
+	if s.manifest == nil {
+		// manifest journal writer not yet created, create one
+		err = s.newManifest(r, nv)
+	} else {
+		err = s.flushManifest(r)
+	}
+
+	// finally, apply new version if no error rise
+	if err == nil {
+		s.setVersion(nv)
+	}
+
+	return
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/session_compaction.go b/vendor/github.com/syndtr/goleveldb/leveldb/session_compaction.go
new file mode 100644
index 00000000..7c5a7941
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/session_compaction.go
@@ -0,0 +1,287 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"sync/atomic"
+
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/memdb"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+func (s *session) pickMemdbLevel(umin, umax []byte) int {
+	v := s.version()
+	defer v.release()
+	return v.pickMemdbLevel(umin, umax)
+}
+
+func (s *session) flushMemdb(rec *sessionRecord, mdb *memdb.DB, level int) (level_ int, err error) {
+	// Create sorted table.
+	iter := mdb.NewIterator(nil)
+	defer iter.Release()
+	t, n, err := s.tops.createFrom(iter)
+	if err != nil {
+		return level, err
+	}
+
+	// Pick level and add to record.
+	if level < 0 {
+		level = s.pickMemdbLevel(t.imin.ukey(), t.imax.ukey())
+	}
+	rec.addTableFile(level, t)
+
+	s.logf("memdb@flush created L%d@%d N·%d S·%s %q:%q", level, t.file.Num(), n, shortenb(int(t.size)), t.imin, t.imax)
+	return level, nil
+}
+
+// Pick a compaction based on current state; need external synchronization.
+func (s *session) pickCompaction() *compaction {
+	v := s.version()
+
+	var level int
+	var t0 tFiles
+	if v.cScore >= 1 {
+		level = v.cLevel
+		cptr := s.stCompPtrs[level]
+		tables := v.tables[level]
+		for _, t := range tables {
+			if cptr == nil || s.icmp.Compare(t.imax, cptr) > 0 {
+				t0 = append(t0, t)
+				break
+			}
+		}
+		if len(t0) == 0 {
+			t0 = append(t0, tables[0])
+		}
+	} else {
+		if p := atomic.LoadPointer(&v.cSeek); p != nil {
+			ts := (*tSet)(p)
+			level = ts.level
+			t0 = append(t0, ts.table)
+		} else {
+			v.release()
+			return nil
+		}
+	}
+
+	return newCompaction(s, v, level, t0)
+}
+
+// Create compaction from given level and range; need external synchronization.
+func (s *session) getCompactionRange(level int, umin, umax []byte) *compaction {
+	v := s.version()
+
+	t0 := v.tables[level].getOverlaps(nil, s.icmp, umin, umax, level == 0)
+	if len(t0) == 0 {
+		v.release()
+		return nil
+	}
+
+	// Avoid compacting too much in one shot in case the range is large.
+	// But we cannot do this for level-0 since level-0 files can overlap
+	// and we must not pick one file and drop another older file if the
+	// two files overlap.
+	if level > 0 {
+		limit := uint64(v.s.o.GetCompactionSourceLimit(level))
+		total := uint64(0)
+		for i, t := range t0 {
+			total += t.size
+			if total >= limit {
+				s.logf("table@compaction limiting F·%d -> F·%d", len(t0), i+1)
+				t0 = t0[:i+1]
+				break
+			}
+		}
+	}
+
+	return newCompaction(s, v, level, t0)
+}
+
+func newCompaction(s *session, v *version, level int, t0 tFiles) *compaction {
+	c := &compaction{
+		s:             s,
+		v:             v,
+		level:         level,
+		tables:        [2]tFiles{t0, nil},
+		maxGPOverlaps: uint64(s.o.GetCompactionGPOverlaps(level)),
+		tPtrs:         make([]int, s.o.GetNumLevel()),
+	}
+	c.expand()
+	c.save()
+	return c
+}
+
+// compaction represent a compaction state.
+type compaction struct {
+	s *session
+	v *version
+
+	level         int
+	tables        [2]tFiles
+	maxGPOverlaps uint64
+
+	gp                tFiles
+	gpi               int
+	seenKey           bool
+	gpOverlappedBytes uint64
+	imin, imax        iKey
+	tPtrs             []int
+	released          bool
+
+	snapGPI               int
+	snapSeenKey           bool
+	snapGPOverlappedBytes uint64
+	snapTPtrs             []int
+}
+
+func (c *compaction) save() {
+	c.snapGPI = c.gpi
+	c.snapSeenKey = c.seenKey
+	c.snapGPOverlappedBytes = c.gpOverlappedBytes
+	c.snapTPtrs = append(c.snapTPtrs[:0], c.tPtrs...)
+}
+
+func (c *compaction) restore() {
+	c.gpi = c.snapGPI
+	c.seenKey = c.snapSeenKey
+	c.gpOverlappedBytes = c.snapGPOverlappedBytes
+	c.tPtrs = append(c.tPtrs[:0], c.snapTPtrs...)
+}
+
+func (c *compaction) release() {
+	if !c.released {
+		c.released = true
+		c.v.release()
+	}
+}
+
+// Expand compacted tables; need external synchronization.
+func (c *compaction) expand() {
+	limit := uint64(c.s.o.GetCompactionExpandLimit(c.level))
+	vt0, vt1 := c.v.tables[c.level], c.v.tables[c.level+1]
+
+	t0, t1 := c.tables[0], c.tables[1]
+	imin, imax := t0.getRange(c.s.icmp)
+	// We expand t0 here just incase ukey hop across tables.
+	t0 = vt0.getOverlaps(t0, c.s.icmp, imin.ukey(), imax.ukey(), c.level == 0)
+	if len(t0) != len(c.tables[0]) {
+		imin, imax = t0.getRange(c.s.icmp)
+	}
+	t1 = vt1.getOverlaps(t1, c.s.icmp, imin.ukey(), imax.ukey(), false)
+	// Get entire range covered by compaction.
+	amin, amax := append(t0, t1...).getRange(c.s.icmp)
+
+	// See if we can grow the number of inputs in "level" without
+	// changing the number of "level+1" files we pick up.
+	if len(t1) > 0 {
+		exp0 := vt0.getOverlaps(nil, c.s.icmp, amin.ukey(), amax.ukey(), c.level == 0)
+		if len(exp0) > len(t0) && t1.size()+exp0.size() < limit {
+			xmin, xmax := exp0.getRange(c.s.icmp)
+			exp1 := vt1.getOverlaps(nil, c.s.icmp, xmin.ukey(), xmax.ukey(), false)
+			if len(exp1) == len(t1) {
+				c.s.logf("table@compaction expanding L%d+L%d (F·%d S·%s)+(F·%d S·%s) -> (F·%d S·%s)+(F·%d S·%s)",
+					c.level, c.level+1, len(t0), shortenb(int(t0.size())), len(t1), shortenb(int(t1.size())),
+					len(exp0), shortenb(int(exp0.size())), len(exp1), shortenb(int(exp1.size())))
+				imin, imax = xmin, xmax
+				t0, t1 = exp0, exp1
+				amin, amax = append(t0, t1...).getRange(c.s.icmp)
+			}
+		}
+	}
+
+	// Compute the set of grandparent files that overlap this compaction
+	// (parent == level+1; grandparent == level+2)
+	if c.level+2 < c.s.o.GetNumLevel() {
+		c.gp = c.v.tables[c.level+2].getOverlaps(c.gp, c.s.icmp, amin.ukey(), amax.ukey(), false)
+	}
+
+	c.tables[0], c.tables[1] = t0, t1
+	c.imin, c.imax = imin, imax
+}
+
+// Check whether compaction is trivial.
+func (c *compaction) trivial() bool {
+	return len(c.tables[0]) == 1 && len(c.tables[1]) == 0 && c.gp.size() <= c.maxGPOverlaps
+}
+
+func (c *compaction) baseLevelForKey(ukey []byte) bool {
+	for level, tables := range c.v.tables[c.level+2:] {
+		for c.tPtrs[level] < len(tables) {
+			t := tables[c.tPtrs[level]]
+			if c.s.icmp.uCompare(ukey, t.imax.ukey()) <= 0 {
+				// We've advanced far enough.
+				if c.s.icmp.uCompare(ukey, t.imin.ukey()) >= 0 {
+					// Key falls in this file's range, so definitely not base level.
+					return false
+				}
+				break
+			}
+			c.tPtrs[level]++
+		}
+	}
+	return true
+}
+
+func (c *compaction) shouldStopBefore(ikey iKey) bool {
+	for ; c.gpi < len(c.gp); c.gpi++ {
+		gp := c.gp[c.gpi]
+		if c.s.icmp.Compare(ikey, gp.imax) <= 0 {
+			break
+		}
+		if c.seenKey {
+			c.gpOverlappedBytes += gp.size
+		}
+	}
+	c.seenKey = true
+
+	if c.gpOverlappedBytes > c.maxGPOverlaps {
+		// Too much overlap for current output; start new output.
+		c.gpOverlappedBytes = 0
+		return true
+	}
+	return false
+}
+
+// Creates an iterator.
+func (c *compaction) newIterator() iterator.Iterator {
+	// Creates iterator slice.
+	icap := len(c.tables)
+	if c.level == 0 {
+		// Special case for level-0.
+		icap = len(c.tables[0]) + 1
+	}
+	its := make([]iterator.Iterator, 0, icap)
+
+	// Options.
+	ro := &opt.ReadOptions{
+		DontFillCache: true,
+		Strict:        opt.StrictOverride,
+	}
+	strict := c.s.o.GetStrict(opt.StrictCompaction)
+	if strict {
+		ro.Strict |= opt.StrictReader
+	}
+
+	for i, tables := range c.tables {
+		if len(tables) == 0 {
+			continue
+		}
+
+		// Level-0 is not sorted and may overlaps each other.
+		if c.level+i == 0 {
+			for _, t := range tables {
+				its = append(its, c.s.tops.newIterator(t, nil, ro))
+			}
+		} else {
+			it := iterator.NewIndexedIterator(tables.newIndexIterator(c.s.tops, c.s.icmp, nil, ro), strict)
+			its = append(its, it)
+		}
+	}
+
+	return iterator.NewMergedIterator(its, c.s.icmp, strict)
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/session_record.go b/vendor/github.com/syndtr/goleveldb/leveldb/session_record.go
new file mode 100644
index 00000000..405e07be
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/session_record.go
@@ -0,0 +1,311 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"bufio"
+	"encoding/binary"
+	"io"
+	"strings"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+)
+
+type byteReader interface {
+	io.Reader
+	io.ByteReader
+}
+
+// These numbers are written to disk and should not be changed.
+const (
+	recComparer    = 1
+	recJournalNum  = 2
+	recNextFileNum = 3
+	recSeqNum      = 4
+	recCompPtr     = 5
+	recDelTable    = 6
+	recAddTable    = 7
+	// 8 was used for large value refs
+	recPrevJournalNum = 9
+)
+
+type cpRecord struct {
+	level int
+	ikey  iKey
+}
+
+type atRecord struct {
+	level int
+	num   uint64
+	size  uint64
+	imin  iKey
+	imax  iKey
+}
+
+type dtRecord struct {
+	level int
+	num   uint64
+}
+
+type sessionRecord struct {
+	hasRec         int
+	comparer       string
+	journalNum     uint64
+	prevJournalNum uint64
+	nextFileNum    uint64
+	seqNum         uint64
+	compPtrs       []cpRecord
+	addedTables    []atRecord
+	deletedTables  []dtRecord
+
+	scratch [binary.MaxVarintLen64]byte
+	err     error
+}
+
+func (p *sessionRecord) has(rec int) bool {
+	return p.hasRec&(1<<uint(rec)) != 0
+}
+
+func (p *sessionRecord) setComparer(name string) {
+	p.hasRec |= 1 << recComparer
+	p.comparer = name
+}
+
+func (p *sessionRecord) setJournalNum(num uint64) {
+	p.hasRec |= 1 << recJournalNum
+	p.journalNum = num
+}
+
+func (p *sessionRecord) setPrevJournalNum(num uint64) {
+	p.hasRec |= 1 << recPrevJournalNum
+	p.prevJournalNum = num
+}
+
+func (p *sessionRecord) setNextFileNum(num uint64) {
+	p.hasRec |= 1 << recNextFileNum
+	p.nextFileNum = num
+}
+
+func (p *sessionRecord) setSeqNum(num uint64) {
+	p.hasRec |= 1 << recSeqNum
+	p.seqNum = num
+}
+
+func (p *sessionRecord) addCompPtr(level int, ikey iKey) {
+	p.hasRec |= 1 << recCompPtr
+	p.compPtrs = append(p.compPtrs, cpRecord{level, ikey})
+}
+
+func (p *sessionRecord) resetCompPtrs() {
+	p.hasRec &= ^(1 << recCompPtr)
+	p.compPtrs = p.compPtrs[:0]
+}
+
+func (p *sessionRecord) addTable(level int, num, size uint64, imin, imax iKey) {
+	p.hasRec |= 1 << recAddTable
+	p.addedTables = append(p.addedTables, atRecord{level, num, size, imin, imax})
+}
+
+func (p *sessionRecord) addTableFile(level int, t *tFile) {
+	p.addTable(level, t.file.Num(), t.size, t.imin, t.imax)
+}
+
+func (p *sessionRecord) resetAddedTables() {
+	p.hasRec &= ^(1 << recAddTable)
+	p.addedTables = p.addedTables[:0]
+}
+
+func (p *sessionRecord) delTable(level int, num uint64) {
+	p.hasRec |= 1 << recDelTable
+	p.deletedTables = append(p.deletedTables, dtRecord{level, num})
+}
+
+func (p *sessionRecord) resetDeletedTables() {
+	p.hasRec &= ^(1 << recDelTable)
+	p.deletedTables = p.deletedTables[:0]
+}
+
+func (p *sessionRecord) putUvarint(w io.Writer, x uint64) {
+	if p.err != nil {
+		return
+	}
+	n := binary.PutUvarint(p.scratch[:], x)
+	_, p.err = w.Write(p.scratch[:n])
+}
+
+func (p *sessionRecord) putBytes(w io.Writer, x []byte) {
+	if p.err != nil {
+		return
+	}
+	p.putUvarint(w, uint64(len(x)))
+	if p.err != nil {
+		return
+	}
+	_, p.err = w.Write(x)
+}
+
+func (p *sessionRecord) encode(w io.Writer) error {
+	p.err = nil
+	if p.has(recComparer) {
+		p.putUvarint(w, recComparer)
+		p.putBytes(w, []byte(p.comparer))
+	}
+	if p.has(recJournalNum) {
+		p.putUvarint(w, recJournalNum)
+		p.putUvarint(w, p.journalNum)
+	}
+	if p.has(recNextFileNum) {
+		p.putUvarint(w, recNextFileNum)
+		p.putUvarint(w, p.nextFileNum)
+	}
+	if p.has(recSeqNum) {
+		p.putUvarint(w, recSeqNum)
+		p.putUvarint(w, p.seqNum)
+	}
+	for _, r := range p.compPtrs {
+		p.putUvarint(w, recCompPtr)
+		p.putUvarint(w, uint64(r.level))
+		p.putBytes(w, r.ikey)
+	}
+	for _, r := range p.deletedTables {
+		p.putUvarint(w, recDelTable)
+		p.putUvarint(w, uint64(r.level))
+		p.putUvarint(w, r.num)
+	}
+	for _, r := range p.addedTables {
+		p.putUvarint(w, recAddTable)
+		p.putUvarint(w, uint64(r.level))
+		p.putUvarint(w, r.num)
+		p.putUvarint(w, r.size)
+		p.putBytes(w, r.imin)
+		p.putBytes(w, r.imax)
+	}
+	return p.err
+}
+
+func (p *sessionRecord) readUvarintMayEOF(field string, r io.ByteReader, mayEOF bool) uint64 {
+	if p.err != nil {
+		return 0
+	}
+	x, err := binary.ReadUvarint(r)
+	if err != nil {
+		if err == io.ErrUnexpectedEOF || (mayEOF == false && err == io.EOF) {
+			p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, "short read"})
+		} else if strings.HasPrefix(err.Error(), "binary:") {
+			p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, err.Error()})
+		} else {
+			p.err = err
+		}
+		return 0
+	}
+	return x
+}
+
+func (p *sessionRecord) readUvarint(field string, r io.ByteReader) uint64 {
+	return p.readUvarintMayEOF(field, r, false)
+}
+
+func (p *sessionRecord) readBytes(field string, r byteReader) []byte {
+	if p.err != nil {
+		return nil
+	}
+	n := p.readUvarint(field, r)
+	if p.err != nil {
+		return nil
+	}
+	x := make([]byte, n)
+	_, p.err = io.ReadFull(r, x)
+	if p.err != nil {
+		if p.err == io.ErrUnexpectedEOF {
+			p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, "short read"})
+		}
+		return nil
+	}
+	return x
+}
+
+func (p *sessionRecord) readLevel(field string, r io.ByteReader, numLevel int) int {
+	if p.err != nil {
+		return 0
+	}
+	x := p.readUvarint(field, r)
+	if p.err != nil {
+		return 0
+	}
+	if x >= uint64(numLevel) {
+		p.err = errors.NewErrCorrupted(nil, &ErrManifestCorrupted{field, "invalid level number"})
+		return 0
+	}
+	return int(x)
+}
+
+func (p *sessionRecord) decode(r io.Reader, numLevel int) error {
+	br, ok := r.(byteReader)
+	if !ok {
+		br = bufio.NewReader(r)
+	}
+	p.err = nil
+	for p.err == nil {
+		rec := p.readUvarintMayEOF("field-header", br, true)
+		if p.err != nil {
+			if p.err == io.EOF {
+				return nil
+			}
+			return p.err
+		}
+		switch rec {
+		case recComparer:
+			x := p.readBytes("comparer", br)
+			if p.err == nil {
+				p.setComparer(string(x))
+			}
+		case recJournalNum:
+			x := p.readUvarint("journal-num", br)
+			if p.err == nil {
+				p.setJournalNum(x)
+			}
+		case recPrevJournalNum:
+			x := p.readUvarint("prev-journal-num", br)
+			if p.err == nil {
+				p.setPrevJournalNum(x)
+			}
+		case recNextFileNum:
+			x := p.readUvarint("next-file-num", br)
+			if p.err == nil {
+				p.setNextFileNum(x)
+			}
+		case recSeqNum:
+			x := p.readUvarint("seq-num", br)
+			if p.err == nil {
+				p.setSeqNum(x)
+			}
+		case recCompPtr:
+			level := p.readLevel("comp-ptr.level", br, numLevel)
+			ikey := p.readBytes("comp-ptr.ikey", br)
+			if p.err == nil {
+				p.addCompPtr(level, iKey(ikey))
+			}
+		case recAddTable:
+			level := p.readLevel("add-table.level", br, numLevel)
+			num := p.readUvarint("add-table.num", br)
+			size := p.readUvarint("add-table.size", br)
+			imin := p.readBytes("add-table.imin", br)
+			imax := p.readBytes("add-table.imax", br)
+			if p.err == nil {
+				p.addTable(level, num, size, imin, imax)
+			}
+		case recDelTable:
+			level := p.readLevel("del-table.level", br, numLevel)
+			num := p.readUvarint("del-table.num", br)
+			if p.err == nil {
+				p.delTable(level, num)
+			}
+		}
+	}
+
+	return p.err
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/session_util.go b/vendor/github.com/syndtr/goleveldb/leveldb/session_util.go
new file mode 100644
index 00000000..399a788b
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/session_util.go
@@ -0,0 +1,249 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"fmt"
+	"sync/atomic"
+
+	"github.com/syndtr/goleveldb/leveldb/journal"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+)
+
+// Logging.
+
+type dropper struct {
+	s    *session
+	file storage.File
+}
+
+func (d dropper) Drop(err error) {
+	if e, ok := err.(*journal.ErrCorrupted); ok {
+		d.s.logf("journal@drop %s-%d S·%s %q", d.file.Type(), d.file.Num(), shortenb(e.Size), e.Reason)
+	} else {
+		d.s.logf("journal@drop %s-%d %q", d.file.Type(), d.file.Num(), err)
+	}
+}
+
+func (s *session) log(v ...interface{})                 { s.stor.Log(fmt.Sprint(v...)) }
+func (s *session) logf(format string, v ...interface{}) { s.stor.Log(fmt.Sprintf(format, v...)) }
+
+// File utils.
+
+func (s *session) getJournalFile(num uint64) storage.File {
+	return s.stor.GetFile(num, storage.TypeJournal)
+}
+
+func (s *session) getTableFile(num uint64) storage.File {
+	return s.stor.GetFile(num, storage.TypeTable)
+}
+
+func (s *session) getFiles(t storage.FileType) ([]storage.File, error) {
+	return s.stor.GetFiles(t)
+}
+
+func (s *session) newTemp() storage.File {
+	num := atomic.AddUint64(&s.stTempFileNum, 1) - 1
+	return s.stor.GetFile(num, storage.TypeTemp)
+}
+
+func (s *session) tableFileFromRecord(r atRecord) *tFile {
+	return newTableFile(s.getTableFile(r.num), r.size, r.imin, r.imax)
+}
+
+// Session state.
+
+// Get current version. This will incr version ref, must call
+// version.release (exactly once) after use.
+func (s *session) version() *version {
+	s.vmu.Lock()
+	defer s.vmu.Unlock()
+	s.stVersion.ref++
+	return s.stVersion
+}
+
+// Set current version to v.
+func (s *session) setVersion(v *version) {
+	s.vmu.Lock()
+	v.ref = 1 // Holds by session.
+	if old := s.stVersion; old != nil {
+		v.ref++ // Holds by old version.
+		old.next = v
+		old.releaseNB()
+	}
+	s.stVersion = v
+	s.vmu.Unlock()
+}
+
+// Get current unused file number.
+func (s *session) nextFileNum() uint64 {
+	return atomic.LoadUint64(&s.stNextFileNum)
+}
+
+// Set current unused file number to num.
+func (s *session) setNextFileNum(num uint64) {
+	atomic.StoreUint64(&s.stNextFileNum, num)
+}
+
+// Mark file number as used.
+func (s *session) markFileNum(num uint64) {
+	nextFileNum := num + 1
+	for {
+		old, x := s.stNextFileNum, nextFileNum
+		if old > x {
+			x = old
+		}
+		if atomic.CompareAndSwapUint64(&s.stNextFileNum, old, x) {
+			break
+		}
+	}
+}
+
+// Allocate a file number.
+func (s *session) allocFileNum() uint64 {
+	return atomic.AddUint64(&s.stNextFileNum, 1) - 1
+}
+
+// Reuse given file number.
+func (s *session) reuseFileNum(num uint64) {
+	for {
+		old, x := s.stNextFileNum, num
+		if old != x+1 {
+			x = old
+		}
+		if atomic.CompareAndSwapUint64(&s.stNextFileNum, old, x) {
+			break
+		}
+	}
+}
+
+// Manifest related utils.
+
+// Fill given session record obj with current states; need external
+// synchronization.
+func (s *session) fillRecord(r *sessionRecord, snapshot bool) {
+	r.setNextFileNum(s.nextFileNum())
+
+	if snapshot {
+		if !r.has(recJournalNum) {
+			r.setJournalNum(s.stJournalNum)
+		}
+
+		if !r.has(recSeqNum) {
+			r.setSeqNum(s.stSeqNum)
+		}
+
+		for level, ik := range s.stCompPtrs {
+			if ik != nil {
+				r.addCompPtr(level, ik)
+			}
+		}
+
+		r.setComparer(s.icmp.uName())
+	}
+}
+
+// Mark if record has been committed, this will update session state;
+// need external synchronization.
+func (s *session) recordCommited(r *sessionRecord) {
+	if r.has(recJournalNum) {
+		s.stJournalNum = r.journalNum
+	}
+
+	if r.has(recPrevJournalNum) {
+		s.stPrevJournalNum = r.prevJournalNum
+	}
+
+	if r.has(recSeqNum) {
+		s.stSeqNum = r.seqNum
+	}
+
+	for _, p := range r.compPtrs {
+		s.stCompPtrs[p.level] = iKey(p.ikey)
+	}
+}
+
+// Create a new manifest file; need external synchronization.
+func (s *session) newManifest(rec *sessionRecord, v *version) (err error) {
+	num := s.allocFileNum()
+	file := s.stor.GetFile(num, storage.TypeManifest)
+	writer, err := file.Create()
+	if err != nil {
+		return
+	}
+	jw := journal.NewWriter(writer)
+
+	if v == nil {
+		v = s.version()
+		defer v.release()
+	}
+	if rec == nil {
+		rec = &sessionRecord{}
+	}
+	s.fillRecord(rec, true)
+	v.fillRecord(rec)
+
+	defer func() {
+		if err == nil {
+			s.recordCommited(rec)
+			if s.manifest != nil {
+				s.manifest.Close()
+			}
+			if s.manifestWriter != nil {
+				s.manifestWriter.Close()
+			}
+			if s.manifestFile != nil {
+				s.manifestFile.Remove()
+			}
+			s.manifestFile = file
+			s.manifestWriter = writer
+			s.manifest = jw
+		} else {
+			writer.Close()
+			file.Remove()
+			s.reuseFileNum(num)
+		}
+	}()
+
+	w, err := jw.Next()
+	if err != nil {
+		return
+	}
+	err = rec.encode(w)
+	if err != nil {
+		return
+	}
+	err = jw.Flush()
+	if err != nil {
+		return
+	}
+	err = s.stor.SetManifest(file)
+	return
+}
+
+// Flush record to disk.
+func (s *session) flushManifest(rec *sessionRecord) (err error) {
+	s.fillRecord(rec, false)
+	w, err := s.manifest.Next()
+	if err != nil {
+		return
+	}
+	err = rec.encode(w)
+	if err != nil {
+		return
+	}
+	err = s.manifest.Flush()
+	if err != nil {
+		return
+	}
+	err = s.manifestWriter.Sync()
+	if err != nil {
+		return
+	}
+	s.recordCommited(rec)
+	return
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go
new file mode 100644
index 00000000..46cc9d07
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go
@@ -0,0 +1,534 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reservefs.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var errFileOpen = errors.New("leveldb/storage: file still open")
+
+type fileLock interface {
+	release() error
+}
+
+type fileStorageLock struct {
+	fs *fileStorage
+}
+
+func (lock *fileStorageLock) Release() {
+	fs := lock.fs
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.slock == lock {
+		fs.slock = nil
+	}
+	return
+}
+
+// fileStorage is a file-system backed storage.
+type fileStorage struct {
+	path string
+
+	mu    sync.Mutex
+	flock fileLock
+	slock *fileStorageLock
+	logw  *os.File
+	buf   []byte
+	// Opened file counter; if open < 0 means closed.
+	open int
+	day  int
+}
+
+// OpenFile returns a new filesytem-backed storage implementation with the given
+// path. This also hold a file lock, so any subsequent attempt to open the same
+// path will fail.
+//
+// The storage must be closed after use, by calling Close method.
+func OpenFile(path string) (Storage, error) {
+	if err := os.MkdirAll(path, 0755); err != nil {
+		return nil, err
+	}
+
+	flock, err := newFileLock(filepath.Join(path, "LOCK"))
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		if err != nil {
+			flock.release()
+		}
+	}()
+
+	rename(filepath.Join(path, "LOG"), filepath.Join(path, "LOG.old"))
+	logw, err := os.OpenFile(filepath.Join(path, "LOG"), os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return nil, err
+	}
+
+	fs := &fileStorage{path: path, flock: flock, logw: logw}
+	runtime.SetFinalizer(fs, (*fileStorage).Close)
+	return fs, nil
+}
+
+func (fs *fileStorage) Lock() (util.Releaser, error) {
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.open < 0 {
+		return nil, ErrClosed
+	}
+	if fs.slock != nil {
+		return nil, ErrLocked
+	}
+	fs.slock = &fileStorageLock{fs: fs}
+	return fs.slock, nil
+}
+
+func itoa(buf []byte, i int, wid int) []byte {
+	var u uint = uint(i)
+	if u == 0 && wid <= 1 {
+		return append(buf, '0')
+	}
+
+	// Assemble decimal in reverse order.
+	var b [32]byte
+	bp := len(b)
+	for ; u > 0 || wid > 0; u /= 10 {
+		bp--
+		wid--
+		b[bp] = byte(u%10) + '0'
+	}
+	return append(buf, b[bp:]...)
+}
+
+func (fs *fileStorage) printDay(t time.Time) {
+	if fs.day == t.Day() {
+		return
+	}
+	fs.day = t.Day()
+	fs.logw.Write([]byte("=============== " + t.Format("Jan 2, 2006 (MST)") + " ===============\n"))
+}
+
+func (fs *fileStorage) doLog(t time.Time, str string) {
+	fs.printDay(t)
+	hour, min, sec := t.Clock()
+	msec := t.Nanosecond() / 1e3
+	// time
+	fs.buf = itoa(fs.buf[:0], hour, 2)
+	fs.buf = append(fs.buf, ':')
+	fs.buf = itoa(fs.buf, min, 2)
+	fs.buf = append(fs.buf, ':')
+	fs.buf = itoa(fs.buf, sec, 2)
+	fs.buf = append(fs.buf, '.')
+	fs.buf = itoa(fs.buf, msec, 6)
+	fs.buf = append(fs.buf, ' ')
+	// write
+	fs.buf = append(fs.buf, []byte(str)...)
+	fs.buf = append(fs.buf, '\n')
+	fs.logw.Write(fs.buf)
+}
+
+func (fs *fileStorage) Log(str string) {
+	t := time.Now()
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.open < 0 {
+		return
+	}
+	fs.doLog(t, str)
+}
+
+func (fs *fileStorage) log(str string) {
+	fs.doLog(time.Now(), str)
+}
+
+func (fs *fileStorage) GetFile(num uint64, t FileType) File {
+	return &file{fs: fs, num: num, t: t}
+}
+
+func (fs *fileStorage) GetFiles(t FileType) (ff []File, err error) {
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.open < 0 {
+		return nil, ErrClosed
+	}
+	dir, err := os.Open(fs.path)
+	if err != nil {
+		return
+	}
+	fnn, err := dir.Readdirnames(0)
+	// Close the dir first before checking for Readdirnames error.
+	if err := dir.Close(); err != nil {
+		fs.log(fmt.Sprintf("close dir: %v", err))
+	}
+	if err != nil {
+		return
+	}
+	f := &file{fs: fs}
+	for _, fn := range fnn {
+		if f.parse(fn) && (f.t&t) != 0 {
+			ff = append(ff, f)
+			f = &file{fs: fs}
+		}
+	}
+	return
+}
+
+func (fs *fileStorage) GetManifest() (f File, err error) {
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.open < 0 {
+		return nil, ErrClosed
+	}
+	dir, err := os.Open(fs.path)
+	if err != nil {
+		return
+	}
+	fnn, err := dir.Readdirnames(0)
+	// Close the dir first before checking for Readdirnames error.
+	if err := dir.Close(); err != nil {
+		fs.log(fmt.Sprintf("close dir: %v", err))
+	}
+	if err != nil {
+		return
+	}
+	// Find latest CURRENT file.
+	var rem []string
+	var pend bool
+	var cerr error
+	for _, fn := range fnn {
+		if strings.HasPrefix(fn, "CURRENT") {
+			pend1 := len(fn) > 7
+			// Make sure it is valid name for a CURRENT file, otherwise skip it.
+			if pend1 {
+				if fn[7] != '.' || len(fn) < 9 {
+					fs.log(fmt.Sprintf("skipping %s: invalid file name", fn))
+					continue
+				}
+				if _, e1 := strconv.ParseUint(fn[8:], 10, 0); e1 != nil {
+					fs.log(fmt.Sprintf("skipping %s: invalid file num: %v", fn, e1))
+					continue
+				}
+			}
+			path := filepath.Join(fs.path, fn)
+			r, e1 := os.OpenFile(path, os.O_RDONLY, 0)
+			if e1 != nil {
+				return nil, e1
+			}
+			b, e1 := ioutil.ReadAll(r)
+			if e1 != nil {
+				r.Close()
+				return nil, e1
+			}
+			f1 := &file{fs: fs}
+			if len(b) < 1 || b[len(b)-1] != '\n' || !f1.parse(string(b[:len(b)-1])) {
+				fs.log(fmt.Sprintf("skipping %s: corrupted or incomplete", fn))
+				if pend1 {
+					rem = append(rem, fn)
+				}
+				if !pend1 || cerr == nil {
+					cerr = fmt.Errorf("leveldb/storage: corrupted or incomplete %s file", fn)
+				}
+			} else if f != nil && f1.Num() < f.Num() {
+				fs.log(fmt.Sprintf("skipping %s: obsolete", fn))
+				if pend1 {
+					rem = append(rem, fn)
+				}
+			} else {
+				f = f1
+				pend = pend1
+			}
+			if err := r.Close(); err != nil {
+				fs.log(fmt.Sprintf("close %s: %v", fn, err))
+			}
+		}
+	}
+	// Don't remove any files if there is no valid CURRENT file.
+	if f == nil {
+		if cerr != nil {
+			err = cerr
+		} else {
+			err = os.ErrNotExist
+		}
+		return
+	}
+	// Rename pending CURRENT file to an effective CURRENT.
+	if pend {
+		path := fmt.Sprintf("%s.%d", filepath.Join(fs.path, "CURRENT"), f.Num())
+		if err := rename(path, filepath.Join(fs.path, "CURRENT")); err != nil {
+			fs.log(fmt.Sprintf("CURRENT.%d -> CURRENT: %v", f.Num(), err))
+		}
+	}
+	// Remove obsolete or incomplete pending CURRENT files.
+	for _, fn := range rem {
+		path := filepath.Join(fs.path, fn)
+		if err := os.Remove(path); err != nil {
+			fs.log(fmt.Sprintf("remove %s: %v", fn, err))
+		}
+	}
+	return
+}
+
+func (fs *fileStorage) SetManifest(f File) (err error) {
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.open < 0 {
+		return ErrClosed
+	}
+	f2, ok := f.(*file)
+	if !ok || f2.t != TypeManifest {
+		return ErrInvalidFile
+	}
+	defer func() {
+		if err != nil {
+			fs.log(fmt.Sprintf("CURRENT: %v", err))
+		}
+	}()
+	path := fmt.Sprintf("%s.%d", filepath.Join(fs.path, "CURRENT"), f2.Num())
+	w, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(w, f2.name())
+	// Close the file first.
+	if err := w.Close(); err != nil {
+		fs.log(fmt.Sprintf("close CURRENT.%d: %v", f2.num, err))
+	}
+	if err != nil {
+		return err
+	}
+	return rename(path, filepath.Join(fs.path, "CURRENT"))
+}
+
+func (fs *fileStorage) Close() error {
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	if fs.open < 0 {
+		return ErrClosed
+	}
+	// Clear the finalizer.
+	runtime.SetFinalizer(fs, nil)
+
+	if fs.open > 0 {
+		fs.log(fmt.Sprintf("refuse to close, %d files still open", fs.open))
+		return fmt.Errorf("leveldb/storage: cannot close, %d files still open", fs.open)
+	}
+	fs.open = -1
+	e1 := fs.logw.Close()
+	err := fs.flock.release()
+	if err == nil {
+		err = e1
+	}
+	return err
+}
+
+type fileWrap struct {
+	*os.File
+	f *file
+}
+
+func (fw fileWrap) Sync() error {
+	if err := fw.File.Sync(); err != nil {
+		return err
+	}
+	if fw.f.Type() == TypeManifest {
+		// Also sync parent directory if file type is manifest.
+		// See: https://code.google.com/p/leveldb/issues/detail?id=190.
+		if err := syncDir(fw.f.fs.path); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (fw fileWrap) Close() error {
+	f := fw.f
+	f.fs.mu.Lock()
+	defer f.fs.mu.Unlock()
+	if !f.open {
+		return ErrClosed
+	}
+	f.open = false
+	f.fs.open--
+	err := fw.File.Close()
+	if err != nil {
+		f.fs.log(fmt.Sprintf("close %s.%d: %v", f.Type(), f.Num(), err))
+	}
+	return err
+}
+
+type file struct {
+	fs   *fileStorage
+	num  uint64
+	t    FileType
+	open bool
+}
+
+func (f *file) Open() (Reader, error) {
+	f.fs.mu.Lock()
+	defer f.fs.mu.Unlock()
+	if f.fs.open < 0 {
+		return nil, ErrClosed
+	}
+	if f.open {
+		return nil, errFileOpen
+	}
+	of, err := os.OpenFile(f.path(), os.O_RDONLY, 0)
+	if err != nil {
+		if f.hasOldName() && os.IsNotExist(err) {
+			of, err = os.OpenFile(f.oldPath(), os.O_RDONLY, 0)
+			if err == nil {
+				goto ok
+			}
+		}
+		return nil, err
+	}
+ok:
+	f.open = true
+	f.fs.open++
+	return fileWrap{of, f}, nil
+}
+
+func (f *file) Create() (Writer, error) {
+	f.fs.mu.Lock()
+	defer f.fs.mu.Unlock()
+	if f.fs.open < 0 {
+		return nil, ErrClosed
+	}
+	if f.open {
+		return nil, errFileOpen
+	}
+	of, err := os.OpenFile(f.path(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return nil, err
+	}
+	f.open = true
+	f.fs.open++
+	return fileWrap{of, f}, nil
+}
+
+func (f *file) Replace(newfile File) error {
+	f.fs.mu.Lock()
+	defer f.fs.mu.Unlock()
+	if f.fs.open < 0 {
+		return ErrClosed
+	}
+	newfile2, ok := newfile.(*file)
+	if !ok {
+		return ErrInvalidFile
+	}
+	if f.open || newfile2.open {
+		return errFileOpen
+	}
+	return rename(newfile2.path(), f.path())
+}
+
+func (f *file) Type() FileType {
+	return f.t
+}
+
+func (f *file) Num() uint64 {
+	return f.num
+}
+
+func (f *file) Remove() error {
+	f.fs.mu.Lock()
+	defer f.fs.mu.Unlock()
+	if f.fs.open < 0 {
+		return ErrClosed
+	}
+	if f.open {
+		return errFileOpen
+	}
+	err := os.Remove(f.path())
+	if err != nil {
+		f.fs.log(fmt.Sprintf("remove %s.%d: %v", f.Type(), f.Num(), err))
+	}
+	// Also try remove file with old name, just in case.
+	if f.hasOldName() {
+		if e1 := os.Remove(f.oldPath()); !os.IsNotExist(e1) {
+			f.fs.log(fmt.Sprintf("remove %s.%d: %v (old name)", f.Type(), f.Num(), err))
+			err = e1
+		}
+	}
+	return err
+}
+
+func (f *file) hasOldName() bool {
+	return f.t == TypeTable
+}
+
+func (f *file) oldName() string {
+	switch f.t {
+	case TypeTable:
+		return fmt.Sprintf("%06d.sst", f.num)
+	}
+	return f.name()
+}
+
+func (f *file) oldPath() string {
+	return filepath.Join(f.fs.path, f.oldName())
+}
+
+func (f *file) name() string {
+	switch f.t {
+	case TypeManifest:
+		return fmt.Sprintf("MANIFEST-%06d", f.num)
+	case TypeJournal:
+		return fmt.Sprintf("%06d.log", f.num)
+	case TypeTable:
+		return fmt.Sprintf("%06d.ldb", f.num)
+	case TypeTemp:
+		return fmt.Sprintf("%06d.tmp", f.num)
+	default:
+		panic("invalid file type")
+	}
+}
+
+func (f *file) path() string {
+	return filepath.Join(f.fs.path, f.name())
+}
+
+func (f *file) parse(name string) bool {
+	var num uint64
+	var tail string
+	_, err := fmt.Sscanf(name, "%d.%s", &num, &tail)
+	if err == nil {
+		switch tail {
+		case "log":
+			f.t = TypeJournal
+		case "ldb", "sst":
+			f.t = TypeTable
+		case "tmp":
+			f.t = TypeTemp
+		default:
+			return false
+		}
+		f.num = num
+		return true
+	}
+	n, _ := fmt.Sscanf(name, "MANIFEST-%d%s", &num, &tail)
+	if n == 1 {
+		f.t = TypeManifest
+		f.num = num
+		return true
+	}
+
+	return false
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
new file mode 100644
index 00000000..42940d76
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
@@ -0,0 +1,52 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+	"os"
+	"path/filepath"
+)
+
+type plan9FileLock struct {
+	f *os.File
+}
+
+func (fl *plan9FileLock) release() error {
+	return fl.f.Close()
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, os.ModeExclusive|0644)
+	if err != nil {
+		return
+	}
+	fl = &plan9FileLock{f: f}
+	return
+}
+
+func rename(oldpath, newpath string) error {
+	if _, err := os.Stat(newpath); err == nil {
+		if err := os.Remove(newpath); err != nil {
+			return err
+		}
+	}
+
+	_, fname := filepath.Split(newpath)
+	return os.Rename(oldpath, fname)
+}
+
+func syncDir(name string) error {
+	f, err := os.Open(name)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	if err := f.Sync(); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_solaris.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_solaris.go
new file mode 100644
index 00000000..102031bf
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_solaris.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build solaris
+
+package storage
+
+import (
+	"os"
+	"syscall"
+)
+
+type unixFileLock struct {
+	f *os.File
+}
+
+func (fl *unixFileLock) release() error {
+	if err := setFileLock(fl.f, false); err != nil {
+		return err
+	}
+	return fl.f.Close()
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
+	if err != nil {
+		return
+	}
+	err = setFileLock(f, true)
+	if err != nil {
+		f.Close()
+		return
+	}
+	fl = &unixFileLock{f: f}
+	return
+}
+
+func setFileLock(f *os.File, lock bool) error {
+	flock := syscall.Flock_t{
+		Type:   syscall.F_UNLCK,
+		Start:  0,
+		Len:    0,
+		Whence: 1,
+	}
+	if lock {
+		flock.Type = syscall.F_WRLCK
+	}
+	return syscall.FcntlFlock(f.Fd(), syscall.F_SETLK, &flock)
+}
+
+func rename(oldpath, newpath string) error {
+	return os.Rename(oldpath, newpath)
+}
+
+func syncDir(name string) error {
+	f, err := os.Open(name)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	if err := f.Sync(); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_unix.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_unix.go
new file mode 100644
index 00000000..d0a604b7
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_unix.go
@@ -0,0 +1,63 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build darwin dragonfly freebsd linux netbsd openbsd
+
+package storage
+
+import (
+	"os"
+	"syscall"
+)
+
+type unixFileLock struct {
+	f *os.File
+}
+
+func (fl *unixFileLock) release() error {
+	if err := setFileLock(fl.f, false); err != nil {
+		return err
+	}
+	return fl.f.Close()
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
+	if err != nil {
+		return
+	}
+	err = setFileLock(f, true)
+	if err != nil {
+		f.Close()
+		return
+	}
+	fl = &unixFileLock{f: f}
+	return
+}
+
+func setFileLock(f *os.File, lock bool) error {
+	how := syscall.LOCK_UN
+	if lock {
+		how = syscall.LOCK_EX
+	}
+	return syscall.Flock(int(f.Fd()), how|syscall.LOCK_NB)
+}
+
+func rename(oldpath, newpath string) error {
+	return os.Rename(oldpath, newpath)
+}
+
+func syncDir(name string) error {
+	f, err := os.Open(name)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	if err := f.Sync(); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_windows.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_windows.go
new file mode 100644
index 00000000..50c3c454
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_windows.go
@@ -0,0 +1,69 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+	procMoveFileExW = modkernel32.NewProc("MoveFileExW")
+)
+
+const (
+	_MOVEFILE_REPLACE_EXISTING = 1
+)
+
+type windowsFileLock struct {
+	fd syscall.Handle
+}
+
+func (fl *windowsFileLock) release() error {
+	return syscall.Close(fl.fd)
+}
+
+func newFileLock(path string) (fl fileLock, err error) {
+	pathp, err := syscall.UTF16PtrFromString(path)
+	if err != nil {
+		return
+	}
+	fd, err := syscall.CreateFile(pathp, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.CREATE_ALWAYS, syscall.FILE_ATTRIBUTE_NORMAL, 0)
+	if err != nil {
+		return
+	}
+	fl = &windowsFileLock{fd: fd}
+	return
+}
+
+func moveFileEx(from *uint16, to *uint16, flags uint32) error {
+	r1, _, e1 := syscall.Syscall(procMoveFileExW.Addr(), 3, uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)), uintptr(flags))
+	if r1 == 0 {
+		if e1 != 0 {
+			return error(e1)
+		} else {
+			return syscall.EINVAL
+		}
+	}
+	return nil
+}
+
+func rename(oldpath, newpath string) error {
+	from, err := syscall.UTF16PtrFromString(oldpath)
+	if err != nil {
+		return err
+	}
+	to, err := syscall.UTF16PtrFromString(newpath)
+	if err != nil {
+		return err
+	}
+	return moveFileEx(from, to, _MOVEFILE_REPLACE_EXISTING)
+}
+
+func syncDir(name string) error { return nil }
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
new file mode 100644
index 00000000..fc1c8165
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
@@ -0,0 +1,203 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package storage
+
+import (
+	"bytes"
+	"os"
+	"sync"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+const typeShift = 3
+
+type memStorageLock struct {
+	ms *memStorage
+}
+
+func (lock *memStorageLock) Release() {
+	ms := lock.ms
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	if ms.slock == lock {
+		ms.slock = nil
+	}
+	return
+}
+
+// memStorage is a memory-backed storage.
+type memStorage struct {
+	mu       sync.Mutex
+	slock    *memStorageLock
+	files    map[uint64]*memFile
+	manifest *memFilePtr
+}
+
+// NewMemStorage returns a new memory-backed storage implementation.
+func NewMemStorage() Storage {
+	return &memStorage{
+		files: make(map[uint64]*memFile),
+	}
+}
+
+func (ms *memStorage) Lock() (util.Releaser, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	if ms.slock != nil {
+		return nil, ErrLocked
+	}
+	ms.slock = &memStorageLock{ms: ms}
+	return ms.slock, nil
+}
+
+func (*memStorage) Log(str string) {}
+
+func (ms *memStorage) GetFile(num uint64, t FileType) File {
+	return &memFilePtr{ms: ms, num: num, t: t}
+}
+
+func (ms *memStorage) GetFiles(t FileType) ([]File, error) {
+	ms.mu.Lock()
+	var ff []File
+	for x, _ := range ms.files {
+		num, mt := x>>typeShift, FileType(x)&TypeAll
+		if mt&t == 0 {
+			continue
+		}
+		ff = append(ff, &memFilePtr{ms: ms, num: num, t: mt})
+	}
+	ms.mu.Unlock()
+	return ff, nil
+}
+
+func (ms *memStorage) GetManifest() (File, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	if ms.manifest == nil {
+		return nil, os.ErrNotExist
+	}
+	return ms.manifest, nil
+}
+
+func (ms *memStorage) SetManifest(f File) error {
+	fm, ok := f.(*memFilePtr)
+	if !ok || fm.t != TypeManifest {
+		return ErrInvalidFile
+	}
+	ms.mu.Lock()
+	ms.manifest = fm
+	ms.mu.Unlock()
+	return nil
+}
+
+func (*memStorage) Close() error { return nil }
+
+type memReader struct {
+	*bytes.Reader
+	m *memFile
+}
+
+func (mr *memReader) Close() error {
+	return mr.m.Close()
+}
+
+type memFile struct {
+	bytes.Buffer
+	ms   *memStorage
+	open bool
+}
+
+func (*memFile) Sync() error { return nil }
+func (m *memFile) Close() error {
+	m.ms.mu.Lock()
+	m.open = false
+	m.ms.mu.Unlock()
+	return nil
+}
+
+type memFilePtr struct {
+	ms  *memStorage
+	num uint64
+	t   FileType
+}
+
+func (p *memFilePtr) x() uint64 {
+	return p.Num()<<typeShift | uint64(p.Type())
+}
+
+func (p *memFilePtr) Open() (Reader, error) {
+	ms := p.ms
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	if m, exist := ms.files[p.x()]; exist {
+		if m.open {
+			return nil, errFileOpen
+		}
+		m.open = true
+		return &memReader{Reader: bytes.NewReader(m.Bytes()), m: m}, nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (p *memFilePtr) Create() (Writer, error) {
+	ms := p.ms
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	m, exist := ms.files[p.x()]
+	if exist {
+		if m.open {
+			return nil, errFileOpen
+		}
+		m.Reset()
+	} else {
+		m = &memFile{ms: ms}
+		ms.files[p.x()] = m
+	}
+	m.open = true
+	return m, nil
+}
+
+func (p *memFilePtr) Replace(newfile File) error {
+	p1, ok := newfile.(*memFilePtr)
+	if !ok {
+		return ErrInvalidFile
+	}
+	ms := p.ms
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	m1, exist := ms.files[p1.x()]
+	if !exist {
+		return os.ErrNotExist
+	}
+	m0, exist := ms.files[p.x()]
+	if (exist && m0.open) || m1.open {
+		return errFileOpen
+	}
+	delete(ms.files, p1.x())
+	ms.files[p.x()] = m1
+	return nil
+}
+
+func (p *memFilePtr) Type() FileType {
+	return p.t
+}
+
+func (p *memFilePtr) Num() uint64 {
+	return p.num
+}
+
+func (p *memFilePtr) Remove() error {
+	ms := p.ms
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	if _, exist := ms.files[p.x()]; exist {
+		delete(ms.files, p.x())
+		return nil
+	}
+	return os.ErrNotExist
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/storage.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/storage.go
new file mode 100644
index 00000000..85dd70b0
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/storage.go
@@ -0,0 +1,157 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package storage provides storage abstraction for LevelDB.
+package storage
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type FileType uint32
+
+const (
+	TypeManifest FileType = 1 << iota
+	TypeJournal
+	TypeTable
+	TypeTemp
+
+	TypeAll = TypeManifest | TypeJournal | TypeTable | TypeTemp
+)
+
+func (t FileType) String() string {
+	switch t {
+	case TypeManifest:
+		return "manifest"
+	case TypeJournal:
+		return "journal"
+	case TypeTable:
+		return "table"
+	case TypeTemp:
+		return "temp"
+	}
+	return fmt.Sprintf("<unknown:%d>", t)
+}
+
+var (
+	ErrInvalidFile = errors.New("leveldb/storage: invalid file for argument")
+	ErrLocked      = errors.New("leveldb/storage: already locked")
+	ErrClosed      = errors.New("leveldb/storage: closed")
+)
+
+// Syncer is the interface that wraps basic Sync method.
+type Syncer interface {
+	// Sync commits the current contents of the file to stable storage.
+	Sync() error
+}
+
+// Reader is the interface that groups the basic Read, Seek, ReadAt and Close
+// methods.
+type Reader interface {
+	io.ReadSeeker
+	io.ReaderAt
+	io.Closer
+}
+
+// Writer is the interface that groups the basic Write, Sync and Close
+// methods.
+type Writer interface {
+	io.WriteCloser
+	Syncer
+}
+
+// File is the file. A file instance must be goroutine-safe.
+type File interface {
+	// Open opens the file for read. Returns os.ErrNotExist error
+	// if the file does not exist.
+	// Returns ErrClosed if the underlying storage is closed.
+	Open() (r Reader, err error)
+
+	// Create creates the file for writting. Truncate the file if
+	// already exist.
+	// Returns ErrClosed if the underlying storage is closed.
+	Create() (w Writer, err error)
+
+	// Replace replaces file with newfile.
+	// Returns ErrClosed if the underlying storage is closed.
+	Replace(newfile File) error
+
+	// Type returns the file type
+	Type() FileType
+
+	// Num returns the file number.
+	Num() uint64
+
+	// Remove removes the file.
+	// Returns ErrClosed if the underlying storage is closed.
+	Remove() error
+}
+
+// Storage is the storage. A storage instance must be goroutine-safe.
+type Storage interface {
+	// Lock locks the storage. Any subsequent attempt to call Lock will fail
+	// until the last lock released.
+	// After use the caller should call the Release method.
+	Lock() (l util.Releaser, err error)
+
+	// Log logs a string. This is used for logging. An implementation
+	// may write to a file, stdout or simply do nothing.
+	Log(str string)
+
+	// GetFile returns a file for the given number and type. GetFile will never
+	// returns nil, even if the underlying storage is closed.
+	GetFile(num uint64, t FileType) File
+
+	// GetFiles returns a slice of files that match the given file types.
+	// The file types may be OR'ed together.
+	GetFiles(t FileType) ([]File, error)
+
+	// GetManifest returns a manifest file. Returns os.ErrNotExist if manifest
+	// file does not exist.
+	GetManifest() (File, error)
+
+	// SetManifest sets the given file as manifest file. The given file should
+	// be a manifest file type or error will be returned.
+	SetManifest(f File) error
+
+	// Close closes the storage. It is valid to call Close multiple times.
+	// Other methods should not be called after the storage has been closed.
+	Close() error
+}
+
+// FileInfo wraps basic file info.
+type FileInfo struct {
+	Type FileType
+	Num  uint64
+}
+
+func (fi FileInfo) String() string {
+	switch fi.Type {
+	case TypeManifest:
+		return fmt.Sprintf("MANIFEST-%06d", fi.Num)
+	case TypeJournal:
+		return fmt.Sprintf("%06d.log", fi.Num)
+	case TypeTable:
+		return fmt.Sprintf("%06d.ldb", fi.Num)
+	case TypeTemp:
+		return fmt.Sprintf("%06d.tmp", fi.Num)
+	default:
+		return fmt.Sprintf("%#x-%d", fi.Type, fi.Num)
+	}
+}
+
+// NewFileInfo creates new FileInfo from the given File. It will returns nil
+// if File is nil.
+func NewFileInfo(f File) *FileInfo {
+	if f == nil {
+		return nil
+	}
+	return &FileInfo{f.Type(), f.Num()}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/table.go b/vendor/github.com/syndtr/goleveldb/leveldb/table.go
new file mode 100644
index 00000000..db386f3b
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/table.go
@@ -0,0 +1,525 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"fmt"
+	"sort"
+	"sync/atomic"
+
+	"github.com/syndtr/goleveldb/leveldb/cache"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/table"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// tFile holds basic information about a table.
+type tFile struct {
+	file       storage.File
+	seekLeft   int32
+	size       uint64
+	imin, imax iKey
+}
+
+// Returns true if given key is after largest key of this table.
+func (t *tFile) after(icmp *iComparer, ukey []byte) bool {
+	return ukey != nil && icmp.uCompare(ukey, t.imax.ukey()) > 0
+}
+
+// Returns true if given key is before smallest key of this table.
+func (t *tFile) before(icmp *iComparer, ukey []byte) bool {
+	return ukey != nil && icmp.uCompare(ukey, t.imin.ukey()) < 0
+}
+
+// Returns true if given key range overlaps with this table key range.
+func (t *tFile) overlaps(icmp *iComparer, umin, umax []byte) bool {
+	return !t.after(icmp, umin) && !t.before(icmp, umax)
+}
+
+// Cosumes one seek and return current seeks left.
+func (t *tFile) consumeSeek() int32 {
+	return atomic.AddInt32(&t.seekLeft, -1)
+}
+
+// Creates new tFile.
+func newTableFile(file storage.File, size uint64, imin, imax iKey) *tFile {
+	f := &tFile{
+		file: file,
+		size: size,
+		imin: imin,
+		imax: imax,
+	}
+
+	// We arrange to automatically compact this file after
+	// a certain number of seeks.  Let's assume:
+	//   (1) One seek costs 10ms
+	//   (2) Writing or reading 1MB costs 10ms (100MB/s)
+	//   (3) A compaction of 1MB does 25MB of IO:
+	//         1MB read from this level
+	//         10-12MB read from next level (boundaries may be misaligned)
+	//         10-12MB written to next level
+	// This implies that 25 seeks cost the same as the compaction
+	// of 1MB of data.  I.e., one seek costs approximately the
+	// same as the compaction of 40KB of data.  We are a little
+	// conservative and allow approximately one seek for every 16KB
+	// of data before triggering a compaction.
+	f.seekLeft = int32(size / 16384)
+	if f.seekLeft < 100 {
+		f.seekLeft = 100
+	}
+
+	return f
+}
+
+// tFiles hold multiple tFile.
+type tFiles []*tFile
+
+func (tf tFiles) Len() int      { return len(tf) }
+func (tf tFiles) Swap(i, j int) { tf[i], tf[j] = tf[j], tf[i] }
+
+func (tf tFiles) nums() string {
+	x := "[ "
+	for i, f := range tf {
+		if i != 0 {
+			x += ", "
+		}
+		x += fmt.Sprint(f.file.Num())
+	}
+	x += " ]"
+	return x
+}
+
+// Returns true if i smallest key is less than j.
+// This used for sort by key in ascending order.
+func (tf tFiles) lessByKey(icmp *iComparer, i, j int) bool {
+	a, b := tf[i], tf[j]
+	n := icmp.Compare(a.imin, b.imin)
+	if n == 0 {
+		return a.file.Num() < b.file.Num()
+	}
+	return n < 0
+}
+
+// Returns true if i file number is greater than j.
+// This used for sort by file number in descending order.
+func (tf tFiles) lessByNum(i, j int) bool {
+	return tf[i].file.Num() > tf[j].file.Num()
+}
+
+// Sorts tables by key in ascending order.
+func (tf tFiles) sortByKey(icmp *iComparer) {
+	sort.Sort(&tFilesSortByKey{tFiles: tf, icmp: icmp})
+}
+
+// Sorts tables by file number in descending order.
+func (tf tFiles) sortByNum() {
+	sort.Sort(&tFilesSortByNum{tFiles: tf})
+}
+
+// Returns sum of all tables size.
+func (tf tFiles) size() (sum uint64) {
+	for _, t := range tf {
+		sum += t.size
+	}
+	return sum
+}
+
+// Searches smallest index of tables whose its smallest
+// key is after or equal with given key.
+func (tf tFiles) searchMin(icmp *iComparer, ikey iKey) int {
+	return sort.Search(len(tf), func(i int) bool {
+		return icmp.Compare(tf[i].imin, ikey) >= 0
+	})
+}
+
+// Searches smallest index of tables whose its largest
+// key is after or equal with given key.
+func (tf tFiles) searchMax(icmp *iComparer, ikey iKey) int {
+	return sort.Search(len(tf), func(i int) bool {
+		return icmp.Compare(tf[i].imax, ikey) >= 0
+	})
+}
+
+// Returns true if given key range overlaps with one or more
+// tables key range. If unsorted is true then binary search will not be used.
+func (tf tFiles) overlaps(icmp *iComparer, umin, umax []byte, unsorted bool) bool {
+	if unsorted {
+		// Check against all files.
+		for _, t := range tf {
+			if t.overlaps(icmp, umin, umax) {
+				return true
+			}
+		}
+		return false
+	}
+
+	i := 0
+	if len(umin) > 0 {
+		// Find the earliest possible internal key for min.
+		i = tf.searchMax(icmp, newIkey(umin, kMaxSeq, ktSeek))
+	}
+	if i >= len(tf) {
+		// Beginning of range is after all files, so no overlap.
+		return false
+	}
+	return !tf[i].before(icmp, umax)
+}
+
+// Returns tables whose its key range overlaps with given key range.
+// Range will be expanded if ukey found hop across tables.
+// If overlapped is true then the search will be restarted if umax
+// expanded.
+// The dst content will be overwritten.
+func (tf tFiles) getOverlaps(dst tFiles, icmp *iComparer, umin, umax []byte, overlapped bool) tFiles {
+	dst = dst[:0]
+	for i := 0; i < len(tf); {
+		t := tf[i]
+		if t.overlaps(icmp, umin, umax) {
+			if umin != nil && icmp.uCompare(t.imin.ukey(), umin) < 0 {
+				umin = t.imin.ukey()
+				dst = dst[:0]
+				i = 0
+				continue
+			} else if umax != nil && icmp.uCompare(t.imax.ukey(), umax) > 0 {
+				umax = t.imax.ukey()
+				// Restart search if it is overlapped.
+				if overlapped {
+					dst = dst[:0]
+					i = 0
+					continue
+				}
+			}
+
+			dst = append(dst, t)
+		}
+		i++
+	}
+
+	return dst
+}
+
+// Returns tables key range.
+func (tf tFiles) getRange(icmp *iComparer) (imin, imax iKey) {
+	for i, t := range tf {
+		if i == 0 {
+			imin, imax = t.imin, t.imax
+			continue
+		}
+		if icmp.Compare(t.imin, imin) < 0 {
+			imin = t.imin
+		}
+		if icmp.Compare(t.imax, imax) > 0 {
+			imax = t.imax
+		}
+	}
+
+	return
+}
+
+// Creates iterator index from tables.
+func (tf tFiles) newIndexIterator(tops *tOps, icmp *iComparer, slice *util.Range, ro *opt.ReadOptions) iterator.IteratorIndexer {
+	if slice != nil {
+		var start, limit int
+		if slice.Start != nil {
+			start = tf.searchMax(icmp, iKey(slice.Start))
+		}
+		if slice.Limit != nil {
+			limit = tf.searchMin(icmp, iKey(slice.Limit))
+		} else {
+			limit = tf.Len()
+		}
+		tf = tf[start:limit]
+	}
+	return iterator.NewArrayIndexer(&tFilesArrayIndexer{
+		tFiles: tf,
+		tops:   tops,
+		icmp:   icmp,
+		slice:  slice,
+		ro:     ro,
+	})
+}
+
+// Tables iterator index.
+type tFilesArrayIndexer struct {
+	tFiles
+	tops  *tOps
+	icmp  *iComparer
+	slice *util.Range
+	ro    *opt.ReadOptions
+}
+
+func (a *tFilesArrayIndexer) Search(key []byte) int {
+	return a.searchMax(a.icmp, iKey(key))
+}
+
+func (a *tFilesArrayIndexer) Get(i int) iterator.Iterator {
+	if i == 0 || i == a.Len()-1 {
+		return a.tops.newIterator(a.tFiles[i], a.slice, a.ro)
+	}
+	return a.tops.newIterator(a.tFiles[i], nil, a.ro)
+}
+
+// Helper type for sortByKey.
+type tFilesSortByKey struct {
+	tFiles
+	icmp *iComparer
+}
+
+func (x *tFilesSortByKey) Less(i, j int) bool {
+	return x.lessByKey(x.icmp, i, j)
+}
+
+// Helper type for sortByNum.
+type tFilesSortByNum struct {
+	tFiles
+}
+
+func (x *tFilesSortByNum) Less(i, j int) bool {
+	return x.lessByNum(i, j)
+}
+
+// Table operations.
+type tOps struct {
+	s      *session
+	cache  *cache.Cache
+	bcache *cache.Cache
+	bpool  *util.BufferPool
+}
+
+// Creates an empty table and returns table writer.
+func (t *tOps) create() (*tWriter, error) {
+	file := t.s.getTableFile(t.s.allocFileNum())
+	fw, err := file.Create()
+	if err != nil {
+		return nil, err
+	}
+	return &tWriter{
+		t:    t,
+		file: file,
+		w:    fw,
+		tw:   table.NewWriter(fw, t.s.o.Options),
+	}, nil
+}
+
+// Builds table from src iterator.
+func (t *tOps) createFrom(src iterator.Iterator) (f *tFile, n int, err error) {
+	w, err := t.create()
+	if err != nil {
+		return
+	}
+
+	defer func() {
+		if err != nil {
+			w.drop()
+		}
+	}()
+
+	for src.Next() {
+		err = w.append(src.Key(), src.Value())
+		if err != nil {
+			return
+		}
+	}
+	err = src.Error()
+	if err != nil {
+		return
+	}
+
+	n = w.tw.EntriesLen()
+	f, err = w.finish()
+	return
+}
+
+// Opens table. It returns a cache handle, which should
+// be released after use.
+func (t *tOps) open(f *tFile) (ch *cache.Handle, err error) {
+	num := f.file.Num()
+	ch = t.cache.Get(0, num, func() (size int, value cache.Value) {
+		var r storage.Reader
+		r, err = f.file.Open()
+		if err != nil {
+			return 0, nil
+		}
+
+		var bcache *cache.CacheGetter
+		if t.bcache != nil {
+			bcache = &cache.CacheGetter{Cache: t.bcache, NS: num}
+		}
+
+		var tr *table.Reader
+		tr, err = table.NewReader(r, int64(f.size), storage.NewFileInfo(f.file), bcache, t.bpool, t.s.o.Options)
+		if err != nil {
+			r.Close()
+			return 0, nil
+		}
+		return 1, tr
+
+	})
+	if ch == nil && err == nil {
+		err = ErrClosed
+	}
+	return
+}
+
+// Finds key/value pair whose key is greater than or equal to the
+// given key.
+func (t *tOps) find(f *tFile, key []byte, ro *opt.ReadOptions) (rkey, rvalue []byte, err error) {
+	ch, err := t.open(f)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer ch.Release()
+	return ch.Value().(*table.Reader).Find(key, true, ro)
+}
+
+// Finds key that is greater than or equal to the given key.
+func (t *tOps) findKey(f *tFile, key []byte, ro *opt.ReadOptions) (rkey []byte, err error) {
+	ch, err := t.open(f)
+	if err != nil {
+		return nil, err
+	}
+	defer ch.Release()
+	return ch.Value().(*table.Reader).FindKey(key, true, ro)
+}
+
+// Returns approximate offset of the given key.
+func (t *tOps) offsetOf(f *tFile, key []byte) (offset uint64, err error) {
+	ch, err := t.open(f)
+	if err != nil {
+		return
+	}
+	defer ch.Release()
+	offset_, err := ch.Value().(*table.Reader).OffsetOf(key)
+	return uint64(offset_), err
+}
+
+// Creates an iterator from the given table.
+func (t *tOps) newIterator(f *tFile, slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+	ch, err := t.open(f)
+	if err != nil {
+		return iterator.NewEmptyIterator(err)
+	}
+	iter := ch.Value().(*table.Reader).NewIterator(slice, ro)
+	iter.SetReleaser(ch)
+	return iter
+}
+
+// Removes table from persistent storage. It waits until
+// no one use the the table.
+func (t *tOps) remove(f *tFile) {
+	num := f.file.Num()
+	t.cache.Delete(0, num, func() {
+		if err := f.file.Remove(); err != nil {
+			t.s.logf("table@remove removing @%d %q", num, err)
+		} else {
+			t.s.logf("table@remove removed @%d", num)
+		}
+		if t.bcache != nil {
+			t.bcache.EvictNS(num)
+		}
+	})
+}
+
+// Closes the table ops instance. It will close all tables,
+// regadless still used or not.
+func (t *tOps) close() {
+	t.bpool.Close()
+	t.cache.Close()
+	if t.bcache != nil {
+		t.bcache.Close()
+	}
+}
+
+// Creates new initialized table ops instance.
+func newTableOps(s *session) *tOps {
+	var (
+		cacher cache.Cacher
+		bcache *cache.Cache
+		bpool  *util.BufferPool
+	)
+	if s.o.GetOpenFilesCacheCapacity() > 0 {
+		cacher = cache.NewLRU(s.o.GetOpenFilesCacheCapacity())
+	}
+	if !s.o.GetDisableBlockCache() {
+		var bcacher cache.Cacher
+		if s.o.GetBlockCacheCapacity() > 0 {
+			bcacher = cache.NewLRU(s.o.GetBlockCacheCapacity())
+		}
+		bcache = cache.NewCache(bcacher)
+	}
+	if !s.o.GetDisableBufferPool() {
+		bpool = util.NewBufferPool(s.o.GetBlockSize() + 5)
+	}
+	return &tOps{
+		s:      s,
+		cache:  cache.NewCache(cacher),
+		bcache: bcache,
+		bpool:  bpool,
+	}
+}
+
+// tWriter wraps the table writer. It keep track of file descriptor
+// and added key range.
+type tWriter struct {
+	t *tOps
+
+	file storage.File
+	w    storage.Writer
+	tw   *table.Writer
+
+	first, last []byte
+}
+
+// Append key/value pair to the table.
+func (w *tWriter) append(key, value []byte) error {
+	if w.first == nil {
+		w.first = append([]byte{}, key...)
+	}
+	w.last = append(w.last[:0], key...)
+	return w.tw.Append(key, value)
+}
+
+// Returns true if the table is empty.
+func (w *tWriter) empty() bool {
+	return w.first == nil
+}
+
+// Closes the storage.Writer.
+func (w *tWriter) close() {
+	if w.w != nil {
+		w.w.Close()
+		w.w = nil
+	}
+}
+
+// Finalizes the table and returns table file.
+func (w *tWriter) finish() (f *tFile, err error) {
+	defer w.close()
+	err = w.tw.Close()
+	if err != nil {
+		return
+	}
+	err = w.w.Sync()
+	if err != nil {
+		return
+	}
+	f = newTableFile(w.file, uint64(w.tw.BytesLen()), iKey(w.first), iKey(w.last))
+	return
+}
+
+// Drops the table.
+func (w *tWriter) drop() {
+	w.close()
+	w.file.Remove()
+	w.t.s.reuseFileNum(w.file.Num())
+	w.file = nil
+	w.tw = nil
+	w.first = nil
+	w.last = nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/table/reader.go b/vendor/github.com/syndtr/goleveldb/leveldb/table/reader.go
new file mode 100644
index 00000000..6f38e84b
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/table/reader.go
@@ -0,0 +1,1107 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package table
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/syndtr/gosnappy/snappy"
+
+	"github.com/syndtr/goleveldb/leveldb/cache"
+	"github.com/syndtr/goleveldb/leveldb/comparer"
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/filter"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+	ErrNotFound       = errors.ErrNotFound
+	ErrReaderReleased = errors.New("leveldb/table: reader released")
+	ErrIterReleased   = errors.New("leveldb/table: iterator released")
+)
+
+type ErrCorrupted struct {
+	Pos    int64
+	Size   int64
+	Kind   string
+	Reason string
+}
+
+func (e *ErrCorrupted) Error() string {
+	return fmt.Sprintf("leveldb/table: corruption on %s (pos=%d): %s", e.Kind, e.Pos, e.Reason)
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+type block struct {
+	bpool          *util.BufferPool
+	bh             blockHandle
+	data           []byte
+	restartsLen    int
+	restartsOffset int
+}
+
+func (b *block) seek(cmp comparer.Comparer, rstart, rlimit int, key []byte) (index, offset int, err error) {
+	index = sort.Search(b.restartsLen-rstart-(b.restartsLen-rlimit), func(i int) bool {
+		offset := int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*(rstart+i):]))
+		offset += 1                                 // shared always zero, since this is a restart point
+		v1, n1 := binary.Uvarint(b.data[offset:])   // key length
+		_, n2 := binary.Uvarint(b.data[offset+n1:]) // value length
+		m := offset + n1 + n2
+		return cmp.Compare(b.data[m:m+int(v1)], key) > 0
+	}) + rstart - 1
+	if index < rstart {
+		// The smallest key is greater-than key sought.
+		index = rstart
+	}
+	offset = int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*index:]))
+	return
+}
+
+func (b *block) restartIndex(rstart, rlimit, offset int) int {
+	return sort.Search(b.restartsLen-rstart-(b.restartsLen-rlimit), func(i int) bool {
+		return int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*(rstart+i):])) > offset
+	}) + rstart - 1
+}
+
+func (b *block) restartOffset(index int) int {
+	return int(binary.LittleEndian.Uint32(b.data[b.restartsOffset+4*index:]))
+}
+
+func (b *block) entry(offset int) (key, value []byte, nShared, n int, err error) {
+	if offset >= b.restartsOffset {
+		if offset != b.restartsOffset {
+			err = &ErrCorrupted{Reason: "entries offset not aligned"}
+		}
+		return
+	}
+	v0, n0 := binary.Uvarint(b.data[offset:])       // Shared prefix length
+	v1, n1 := binary.Uvarint(b.data[offset+n0:])    // Key length
+	v2, n2 := binary.Uvarint(b.data[offset+n0+n1:]) // Value length
+	m := n0 + n1 + n2
+	n = m + int(v1) + int(v2)
+	if n0 <= 0 || n1 <= 0 || n2 <= 0 || offset+n > b.restartsOffset {
+		err = &ErrCorrupted{Reason: "entries corrupted"}
+		return
+	}
+	key = b.data[offset+m : offset+m+int(v1)]
+	value = b.data[offset+m+int(v1) : offset+n]
+	nShared = int(v0)
+	return
+}
+
+func (b *block) Release() {
+	b.bpool.Put(b.data)
+	b.bpool = nil
+	b.data = nil
+}
+
+type dir int
+
+const (
+	dirReleased dir = iota - 1
+	dirSOI
+	dirEOI
+	dirBackward
+	dirForward
+)
+
+type blockIter struct {
+	tr            *Reader
+	block         *block
+	blockReleaser util.Releaser
+	releaser      util.Releaser
+	key, value    []byte
+	offset        int
+	// Previous offset, only filled by Next.
+	prevOffset   int
+	prevNode     []int
+	prevKeys     []byte
+	restartIndex int
+	// Iterator direction.
+	dir dir
+	// Restart index slice range.
+	riStart int
+	riLimit int
+	// Offset slice range.
+	offsetStart     int
+	offsetRealStart int
+	offsetLimit     int
+	// Error.
+	err error
+}
+
+func (i *blockIter) sErr(err error) {
+	i.err = err
+	i.key = nil
+	i.value = nil
+	i.prevNode = nil
+	i.prevKeys = nil
+}
+
+func (i *blockIter) reset() {
+	if i.dir == dirBackward {
+		i.prevNode = i.prevNode[:0]
+		i.prevKeys = i.prevKeys[:0]
+	}
+	i.restartIndex = i.riStart
+	i.offset = i.offsetStart
+	i.dir = dirSOI
+	i.key = i.key[:0]
+	i.value = nil
+}
+
+func (i *blockIter) isFirst() bool {
+	switch i.dir {
+	case dirForward:
+		return i.prevOffset == i.offsetRealStart
+	case dirBackward:
+		return len(i.prevNode) == 1 && i.restartIndex == i.riStart
+	}
+	return false
+}
+
+func (i *blockIter) isLast() bool {
+	switch i.dir {
+	case dirForward, dirBackward:
+		return i.offset == i.offsetLimit
+	}
+	return false
+}
+
+func (i *blockIter) First() bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.dir == dirBackward {
+		i.prevNode = i.prevNode[:0]
+		i.prevKeys = i.prevKeys[:0]
+	}
+	i.dir = dirSOI
+	return i.Next()
+}
+
+func (i *blockIter) Last() bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.dir == dirBackward {
+		i.prevNode = i.prevNode[:0]
+		i.prevKeys = i.prevKeys[:0]
+	}
+	i.dir = dirEOI
+	return i.Prev()
+}
+
+func (i *blockIter) Seek(key []byte) bool {
+	if i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	ri, offset, err := i.block.seek(i.tr.cmp, i.riStart, i.riLimit, key)
+	if err != nil {
+		i.sErr(err)
+		return false
+	}
+	i.restartIndex = ri
+	i.offset = max(i.offsetStart, offset)
+	if i.dir == dirSOI || i.dir == dirEOI {
+		i.dir = dirForward
+	}
+	for i.Next() {
+		if i.tr.cmp.Compare(i.key, key) >= 0 {
+			return true
+		}
+	}
+	return false
+}
+
+func (i *blockIter) Next() bool {
+	if i.dir == dirEOI || i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	if i.dir == dirSOI {
+		i.restartIndex = i.riStart
+		i.offset = i.offsetStart
+	} else if i.dir == dirBackward {
+		i.prevNode = i.prevNode[:0]
+		i.prevKeys = i.prevKeys[:0]
+	}
+	for i.offset < i.offsetRealStart {
+		key, value, nShared, n, err := i.block.entry(i.offset)
+		if err != nil {
+			i.sErr(i.tr.fixErrCorruptedBH(i.block.bh, err))
+			return false
+		}
+		if n == 0 {
+			i.dir = dirEOI
+			return false
+		}
+		i.key = append(i.key[:nShared], key...)
+		i.value = value
+		i.offset += n
+	}
+	if i.offset >= i.offsetLimit {
+		i.dir = dirEOI
+		if i.offset != i.offsetLimit {
+			i.sErr(i.tr.newErrCorruptedBH(i.block.bh, "entries offset not aligned"))
+		}
+		return false
+	}
+	key, value, nShared, n, err := i.block.entry(i.offset)
+	if err != nil {
+		i.sErr(i.tr.fixErrCorruptedBH(i.block.bh, err))
+		return false
+	}
+	if n == 0 {
+		i.dir = dirEOI
+		return false
+	}
+	i.key = append(i.key[:nShared], key...)
+	i.value = value
+	i.prevOffset = i.offset
+	i.offset += n
+	i.dir = dirForward
+	return true
+}
+
+func (i *blockIter) Prev() bool {
+	if i.dir == dirSOI || i.err != nil {
+		return false
+	} else if i.dir == dirReleased {
+		i.err = ErrIterReleased
+		return false
+	}
+
+	var ri int
+	if i.dir == dirForward {
+		// Change direction.
+		i.offset = i.prevOffset
+		if i.offset == i.offsetRealStart {
+			i.dir = dirSOI
+			return false
+		}
+		ri = i.block.restartIndex(i.restartIndex, i.riLimit, i.offset)
+		i.dir = dirBackward
+	} else if i.dir == dirEOI {
+		// At the end of iterator.
+		i.restartIndex = i.riLimit
+		i.offset = i.offsetLimit
+		if i.offset == i.offsetRealStart {
+			i.dir = dirSOI
+			return false
+		}
+		ri = i.riLimit - 1
+		i.dir = dirBackward
+	} else if len(i.prevNode) == 1 {
+		// This is the end of a restart range.
+		i.offset = i.prevNode[0]
+		i.prevNode = i.prevNode[:0]
+		if i.restartIndex == i.riStart {
+			i.dir = dirSOI
+			return false
+		}
+		i.restartIndex--
+		ri = i.restartIndex
+	} else {
+		// In the middle of restart range, get from cache.
+		n := len(i.prevNode) - 3
+		node := i.prevNode[n:]
+		i.prevNode = i.prevNode[:n]
+		// Get the key.
+		ko := node[0]
+		i.key = append(i.key[:0], i.prevKeys[ko:]...)
+		i.prevKeys = i.prevKeys[:ko]
+		// Get the value.
+		vo := node[1]
+		vl := vo + node[2]
+		i.value = i.block.data[vo:vl]
+		i.offset = vl
+		return true
+	}
+	// Build entries cache.
+	i.key = i.key[:0]
+	i.value = nil
+	offset := i.block.restartOffset(ri)
+	if offset == i.offset {
+		ri -= 1
+		if ri < 0 {
+			i.dir = dirSOI
+			return false
+		}
+		offset = i.block.restartOffset(ri)
+	}
+	i.prevNode = append(i.prevNode, offset)
+	for {
+		key, value, nShared, n, err := i.block.entry(offset)
+		if err != nil {
+			i.sErr(i.tr.fixErrCorruptedBH(i.block.bh, err))
+			return false
+		}
+		if offset >= i.offsetRealStart {
+			if i.value != nil {
+				// Appends 3 variables:
+				// 1. Previous keys offset
+				// 2. Value offset in the data block
+				// 3. Value length
+				i.prevNode = append(i.prevNode, len(i.prevKeys), offset-len(i.value), len(i.value))
+				i.prevKeys = append(i.prevKeys, i.key...)
+			}
+			i.value = value
+		}
+		i.key = append(i.key[:nShared], key...)
+		offset += n
+		// Stop if target offset reached.
+		if offset >= i.offset {
+			if offset != i.offset {
+				i.sErr(i.tr.newErrCorruptedBH(i.block.bh, "entries offset not aligned"))
+				return false
+			}
+
+			break
+		}
+	}
+	i.restartIndex = ri
+	i.offset = offset
+	return true
+}
+
+func (i *blockIter) Key() []byte {
+	if i.err != nil || i.dir <= dirEOI {
+		return nil
+	}
+	return i.key
+}
+
+func (i *blockIter) Value() []byte {
+	if i.err != nil || i.dir <= dirEOI {
+		return nil
+	}
+	return i.value
+}
+
+func (i *blockIter) Release() {
+	if i.dir != dirReleased {
+		i.tr = nil
+		i.block = nil
+		i.prevNode = nil
+		i.prevKeys = nil
+		i.key = nil
+		i.value = nil
+		i.dir = dirReleased
+		if i.blockReleaser != nil {
+			i.blockReleaser.Release()
+			i.blockReleaser = nil
+		}
+		if i.releaser != nil {
+			i.releaser.Release()
+			i.releaser = nil
+		}
+	}
+}
+
+func (i *blockIter) SetReleaser(releaser util.Releaser) {
+	if i.dir == dirReleased {
+		panic(util.ErrReleased)
+	}
+	if i.releaser != nil && releaser != nil {
+		panic(util.ErrHasReleaser)
+	}
+	i.releaser = releaser
+}
+
+func (i *blockIter) Valid() bool {
+	return i.err == nil && (i.dir == dirBackward || i.dir == dirForward)
+}
+
+func (i *blockIter) Error() error {
+	return i.err
+}
+
+type filterBlock struct {
+	bpool      *util.BufferPool
+	data       []byte
+	oOffset    int
+	baseLg     uint
+	filtersNum int
+}
+
+func (b *filterBlock) contains(filter filter.Filter, offset uint64, key []byte) bool {
+	i := int(offset >> b.baseLg)
+	if i < b.filtersNum {
+		o := b.data[b.oOffset+i*4:]
+		n := int(binary.LittleEndian.Uint32(o))
+		m := int(binary.LittleEndian.Uint32(o[4:]))
+		if n < m && m <= b.oOffset {
+			return filter.Contains(b.data[n:m], key)
+		} else if n == m {
+			return false
+		}
+	}
+	return true
+}
+
+func (b *filterBlock) Release() {
+	b.bpool.Put(b.data)
+	b.bpool = nil
+	b.data = nil
+}
+
+type indexIter struct {
+	*blockIter
+	tr    *Reader
+	slice *util.Range
+	// Options
+	fillCache bool
+}
+
+func (i *indexIter) Get() iterator.Iterator {
+	value := i.Value()
+	if value == nil {
+		return nil
+	}
+	dataBH, n := decodeBlockHandle(value)
+	if n == 0 {
+		return iterator.NewEmptyIterator(i.tr.newErrCorruptedBH(i.tr.indexBH, "bad data block handle"))
+	}
+
+	var slice *util.Range
+	if i.slice != nil && (i.blockIter.isFirst() || i.blockIter.isLast()) {
+		slice = i.slice
+	}
+	return i.tr.getDataIterErr(dataBH, slice, i.tr.verifyChecksum, i.fillCache)
+}
+
+// Reader is a table reader.
+type Reader struct {
+	mu     sync.RWMutex
+	fi     *storage.FileInfo
+	reader io.ReaderAt
+	cache  *cache.CacheGetter
+	err    error
+	bpool  *util.BufferPool
+	// Options
+	o              *opt.Options
+	cmp            comparer.Comparer
+	filter         filter.Filter
+	verifyChecksum bool
+
+	dataEnd                   int64
+	metaBH, indexBH, filterBH blockHandle
+	indexBlock                *block
+	filterBlock               *filterBlock
+}
+
+func (r *Reader) blockKind(bh blockHandle) string {
+	switch bh.offset {
+	case r.metaBH.offset:
+		return "meta-block"
+	case r.indexBH.offset:
+		return "index-block"
+	case r.filterBH.offset:
+		if r.filterBH.length > 0 {
+			return "filter-block"
+		}
+	}
+	return "data-block"
+}
+
+func (r *Reader) newErrCorrupted(pos, size int64, kind, reason string) error {
+	return &errors.ErrCorrupted{File: r.fi, Err: &ErrCorrupted{Pos: pos, Size: size, Kind: kind, Reason: reason}}
+}
+
+func (r *Reader) newErrCorruptedBH(bh blockHandle, reason string) error {
+	return r.newErrCorrupted(int64(bh.offset), int64(bh.length), r.blockKind(bh), reason)
+}
+
+func (r *Reader) fixErrCorruptedBH(bh blockHandle, err error) error {
+	if cerr, ok := err.(*ErrCorrupted); ok {
+		cerr.Pos = int64(bh.offset)
+		cerr.Size = int64(bh.length)
+		cerr.Kind = r.blockKind(bh)
+		return &errors.ErrCorrupted{File: r.fi, Err: cerr}
+	}
+	return err
+}
+
+func (r *Reader) readRawBlock(bh blockHandle, verifyChecksum bool) ([]byte, error) {
+	data := r.bpool.Get(int(bh.length + blockTrailerLen))
+	if _, err := r.reader.ReadAt(data, int64(bh.offset)); err != nil && err != io.EOF {
+		return nil, err
+	}
+
+	if verifyChecksum {
+		n := bh.length + 1
+		checksum0 := binary.LittleEndian.Uint32(data[n:])
+		checksum1 := util.NewCRC(data[:n]).Value()
+		if checksum0 != checksum1 {
+			r.bpool.Put(data)
+			return nil, r.newErrCorruptedBH(bh, fmt.Sprintf("checksum mismatch, want=%#x got=%#x", checksum0, checksum1))
+		}
+	}
+
+	switch data[bh.length] {
+	case blockTypeNoCompression:
+		data = data[:bh.length]
+	case blockTypeSnappyCompression:
+		decLen, err := snappy.DecodedLen(data[:bh.length])
+		if err != nil {
+			return nil, r.newErrCorruptedBH(bh, err.Error())
+		}
+		decData := r.bpool.Get(decLen)
+		decData, err = snappy.Decode(decData, data[:bh.length])
+		r.bpool.Put(data)
+		if err != nil {
+			r.bpool.Put(decData)
+			return nil, r.newErrCorruptedBH(bh, err.Error())
+		}
+		data = decData
+	default:
+		r.bpool.Put(data)
+		return nil, r.newErrCorruptedBH(bh, fmt.Sprintf("unknown compression type %#x", data[bh.length]))
+	}
+	return data, nil
+}
+
+func (r *Reader) readBlock(bh blockHandle, verifyChecksum bool) (*block, error) {
+	data, err := r.readRawBlock(bh, verifyChecksum)
+	if err != nil {
+		return nil, err
+	}
+	restartsLen := int(binary.LittleEndian.Uint32(data[len(data)-4:]))
+	b := &block{
+		bpool:          r.bpool,
+		bh:             bh,
+		data:           data,
+		restartsLen:    restartsLen,
+		restartsOffset: len(data) - (restartsLen+1)*4,
+	}
+	return b, nil
+}
+
+func (r *Reader) readBlockCached(bh blockHandle, verifyChecksum, fillCache bool) (*block, util.Releaser, error) {
+	if r.cache != nil {
+		var (
+			err error
+			ch  *cache.Handle
+		)
+		if fillCache {
+			ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+				var b *block
+				b, err = r.readBlock(bh, verifyChecksum)
+				if err != nil {
+					return 0, nil
+				}
+				return cap(b.data), b
+			})
+		} else {
+			ch = r.cache.Get(bh.offset, nil)
+		}
+		if ch != nil {
+			b, ok := ch.Value().(*block)
+			if !ok {
+				ch.Release()
+				return nil, nil, errors.New("leveldb/table: inconsistent block type")
+			}
+			return b, ch, err
+		} else if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	b, err := r.readBlock(bh, verifyChecksum)
+	return b, b, err
+}
+
+func (r *Reader) readFilterBlock(bh blockHandle) (*filterBlock, error) {
+	data, err := r.readRawBlock(bh, true)
+	if err != nil {
+		return nil, err
+	}
+	n := len(data)
+	if n < 5 {
+		return nil, r.newErrCorruptedBH(bh, "too short")
+	}
+	m := n - 5
+	oOffset := int(binary.LittleEndian.Uint32(data[m:]))
+	if oOffset > m {
+		return nil, r.newErrCorruptedBH(bh, "invalid data-offsets offset")
+	}
+	b := &filterBlock{
+		bpool:      r.bpool,
+		data:       data,
+		oOffset:    oOffset,
+		baseLg:     uint(data[n-1]),
+		filtersNum: (m - oOffset) / 4,
+	}
+	return b, nil
+}
+
+func (r *Reader) readFilterBlockCached(bh blockHandle, fillCache bool) (*filterBlock, util.Releaser, error) {
+	if r.cache != nil {
+		var (
+			err error
+			ch  *cache.Handle
+		)
+		if fillCache {
+			ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+				var b *filterBlock
+				b, err = r.readFilterBlock(bh)
+				if err != nil {
+					return 0, nil
+				}
+				return cap(b.data), b
+			})
+		} else {
+			ch = r.cache.Get(bh.offset, nil)
+		}
+		if ch != nil {
+			b, ok := ch.Value().(*filterBlock)
+			if !ok {
+				ch.Release()
+				return nil, nil, errors.New("leveldb/table: inconsistent block type")
+			}
+			return b, ch, err
+		} else if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	b, err := r.readFilterBlock(bh)
+	return b, b, err
+}
+
+func (r *Reader) getIndexBlock(fillCache bool) (b *block, rel util.Releaser, err error) {
+	if r.indexBlock == nil {
+		return r.readBlockCached(r.indexBH, true, fillCache)
+	}
+	return r.indexBlock, util.NoopReleaser{}, nil
+}
+
+func (r *Reader) getFilterBlock(fillCache bool) (*filterBlock, util.Releaser, error) {
+	if r.filterBlock == nil {
+		return r.readFilterBlockCached(r.filterBH, fillCache)
+	}
+	return r.filterBlock, util.NoopReleaser{}, nil
+}
+
+func (r *Reader) newBlockIter(b *block, bReleaser util.Releaser, slice *util.Range, inclLimit bool) *blockIter {
+	bi := &blockIter{
+		tr:            r,
+		block:         b,
+		blockReleaser: bReleaser,
+		// Valid key should never be nil.
+		key:             make([]byte, 0),
+		dir:             dirSOI,
+		riStart:         0,
+		riLimit:         b.restartsLen,
+		offsetStart:     0,
+		offsetRealStart: 0,
+		offsetLimit:     b.restartsOffset,
+	}
+	if slice != nil {
+		if slice.Start != nil {
+			if bi.Seek(slice.Start) {
+				bi.riStart = b.restartIndex(bi.restartIndex, b.restartsLen, bi.prevOffset)
+				bi.offsetStart = b.restartOffset(bi.riStart)
+				bi.offsetRealStart = bi.prevOffset
+			} else {
+				bi.riStart = b.restartsLen
+				bi.offsetStart = b.restartsOffset
+				bi.offsetRealStart = b.restartsOffset
+			}
+		}
+		if slice.Limit != nil {
+			if bi.Seek(slice.Limit) && (!inclLimit || bi.Next()) {
+				bi.offsetLimit = bi.prevOffset
+				bi.riLimit = bi.restartIndex + 1
+			}
+		}
+		bi.reset()
+		if bi.offsetStart > bi.offsetLimit {
+			bi.sErr(errors.New("leveldb/table: invalid slice range"))
+		}
+	}
+	return bi
+}
+
+func (r *Reader) getDataIter(dataBH blockHandle, slice *util.Range, verifyChecksum, fillCache bool) iterator.Iterator {
+	b, rel, err := r.readBlockCached(dataBH, verifyChecksum, fillCache)
+	if err != nil {
+		return iterator.NewEmptyIterator(err)
+	}
+	return r.newBlockIter(b, rel, slice, false)
+}
+
+func (r *Reader) getDataIterErr(dataBH blockHandle, slice *util.Range, verifyChecksum, fillCache bool) iterator.Iterator {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if r.err != nil {
+		return iterator.NewEmptyIterator(r.err)
+	}
+
+	return r.getDataIter(dataBH, slice, verifyChecksum, fillCache)
+}
+
+// NewIterator creates an iterator from the table.
+//
+// Slice allows slicing the iterator to only contains keys in the given
+// range. A nil Range.Start is treated as a key before all keys in the
+// table. And a nil Range.Limit is treated as a key after all keys in
+// the table.
+//
+// The returned iterator is not goroutine-safe and should be released
+// when not used.
+//
+// Also read Iterator documentation of the leveldb/iterator package.
+func (r *Reader) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if r.err != nil {
+		return iterator.NewEmptyIterator(r.err)
+	}
+
+	fillCache := !ro.GetDontFillCache()
+	indexBlock, rel, err := r.getIndexBlock(fillCache)
+	if err != nil {
+		return iterator.NewEmptyIterator(err)
+	}
+	index := &indexIter{
+		blockIter: r.newBlockIter(indexBlock, rel, slice, true),
+		tr:        r,
+		slice:     slice,
+		fillCache: !ro.GetDontFillCache(),
+	}
+	return iterator.NewIndexedIterator(index, opt.GetStrict(r.o, ro, opt.StrictReader))
+}
+
+func (r *Reader) find(key []byte, filtered bool, ro *opt.ReadOptions, noValue bool) (rkey, value []byte, err error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if r.err != nil {
+		err = r.err
+		return
+	}
+
+	indexBlock, rel, err := r.getIndexBlock(true)
+	if err != nil {
+		return
+	}
+	defer rel.Release()
+
+	index := r.newBlockIter(indexBlock, nil, nil, true)
+	defer index.Release()
+	if !index.Seek(key) {
+		err = index.Error()
+		if err == nil {
+			err = ErrNotFound
+		}
+		return
+	}
+	dataBH, n := decodeBlockHandle(index.Value())
+	if n == 0 {
+		r.err = r.newErrCorruptedBH(r.indexBH, "bad data block handle")
+		return
+	}
+	if filtered && r.filter != nil {
+		filterBlock, frel, ferr := r.getFilterBlock(true)
+		if ferr == nil {
+			if !filterBlock.contains(r.filter, dataBH.offset, key) {
+				frel.Release()
+				return nil, nil, ErrNotFound
+			}
+			frel.Release()
+		} else if !errors.IsCorrupted(ferr) {
+			err = ferr
+			return
+		}
+	}
+	data := r.getDataIter(dataBH, nil, r.verifyChecksum, !ro.GetDontFillCache())
+	defer data.Release()
+	if !data.Seek(key) {
+		err = data.Error()
+		if err == nil {
+			err = ErrNotFound
+		}
+		return
+	}
+	// Don't use block buffer, no need to copy the buffer.
+	rkey = data.Key()
+	if !noValue {
+		if r.bpool == nil {
+			value = data.Value()
+		} else {
+			// Use block buffer, and since the buffer will be recycled, the buffer
+			// need to be copied.
+			value = append([]byte{}, data.Value()...)
+		}
+	}
+	return
+}
+
+// Find finds key/value pair whose key is greater than or equal to the
+// given key. It returns ErrNotFound if the table doesn't contain
+// such pair.
+// If filtered is true then the nearest 'block' will be checked against
+// 'filter data' (if present) and will immediately return ErrNotFound if
+// 'filter data' indicates that such pair doesn't exist.
+//
+// The caller may modify the contents of the returned slice as it is its
+// own copy.
+// It is safe to modify the contents of the argument after Find returns.
+func (r *Reader) Find(key []byte, filtered bool, ro *opt.ReadOptions) (rkey, value []byte, err error) {
+	return r.find(key, filtered, ro, false)
+}
+
+// Find finds key that is greater than or equal to the given key.
+// It returns ErrNotFound if the table doesn't contain such key.
+// If filtered is true then the nearest 'block' will be checked against
+// 'filter data' (if present) and will immediately return ErrNotFound if
+// 'filter data' indicates that such key doesn't exist.
+//
+// The caller may modify the contents of the returned slice as it is its
+// own copy.
+// It is safe to modify the contents of the argument after Find returns.
+func (r *Reader) FindKey(key []byte, filtered bool, ro *opt.ReadOptions) (rkey []byte, err error) {
+	rkey, _, err = r.find(key, filtered, ro, true)
+	return
+}
+
+// Get gets the value for the given key. It returns errors.ErrNotFound
+// if the table does not contain the key.
+//
+// The caller may modify the contents of the returned slice as it is its
+// own copy.
+// It is safe to modify the contents of the argument after Find returns.
+func (r *Reader) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if r.err != nil {
+		err = r.err
+		return
+	}
+
+	rkey, value, err := r.find(key, false, ro, false)
+	if err == nil && r.cmp.Compare(rkey, key) != 0 {
+		value = nil
+		err = ErrNotFound
+	}
+	return
+}
+
+// OffsetOf returns approximate offset for the given key.
+//
+// It is safe to modify the contents of the argument after Get returns.
+func (r *Reader) OffsetOf(key []byte) (offset int64, err error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if r.err != nil {
+		err = r.err
+		return
+	}
+
+	indexBlock, rel, err := r.readBlockCached(r.indexBH, true, true)
+	if err != nil {
+		return
+	}
+	defer rel.Release()
+
+	index := r.newBlockIter(indexBlock, nil, nil, true)
+	defer index.Release()
+	if index.Seek(key) {
+		dataBH, n := decodeBlockHandle(index.Value())
+		if n == 0 {
+			r.err = r.newErrCorruptedBH(r.indexBH, "bad data block handle")
+			return
+		}
+		offset = int64(dataBH.offset)
+		return
+	}
+	err = index.Error()
+	if err == nil {
+		offset = r.dataEnd
+	}
+	return
+}
+
+// Release implements util.Releaser.
+// It also close the file if it is an io.Closer.
+func (r *Reader) Release() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if closer, ok := r.reader.(io.Closer); ok {
+		closer.Close()
+	}
+	if r.indexBlock != nil {
+		r.indexBlock.Release()
+		r.indexBlock = nil
+	}
+	if r.filterBlock != nil {
+		r.filterBlock.Release()
+		r.filterBlock = nil
+	}
+	r.reader = nil
+	r.cache = nil
+	r.bpool = nil
+	r.err = ErrReaderReleased
+}
+
+// NewReader creates a new initialized table reader for the file.
+// The fi, cache and bpool is optional and can be nil.
+//
+// The returned table reader instance is goroutine-safe.
+func NewReader(f io.ReaderAt, size int64, fi *storage.FileInfo, cache *cache.CacheGetter, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
+	if f == nil {
+		return nil, errors.New("leveldb/table: nil file")
+	}
+
+	r := &Reader{
+		fi:             fi,
+		reader:         f,
+		cache:          cache,
+		bpool:          bpool,
+		o:              o,
+		cmp:            o.GetComparer(),
+		verifyChecksum: o.GetStrict(opt.StrictBlockChecksum),
+	}
+
+	if size < footerLen {
+		r.err = r.newErrCorrupted(0, size, "table", "too small")
+		return r, nil
+	}
+
+	footerPos := size - footerLen
+	var footer [footerLen]byte
+	if _, err := r.reader.ReadAt(footer[:], footerPos); err != nil && err != io.EOF {
+		return nil, err
+	}
+	if string(footer[footerLen-len(magic):footerLen]) != magic {
+		r.err = r.newErrCorrupted(footerPos, footerLen, "table-footer", "bad magic number")
+		return r, nil
+	}
+
+	var n int
+	// Decode the metaindex block handle.
+	r.metaBH, n = decodeBlockHandle(footer[:])
+	if n == 0 {
+		r.err = r.newErrCorrupted(footerPos, footerLen, "table-footer", "bad metaindex block handle")
+		return r, nil
+	}
+
+	// Decode the index block handle.
+	r.indexBH, n = decodeBlockHandle(footer[n:])
+	if n == 0 {
+		r.err = r.newErrCorrupted(footerPos, footerLen, "table-footer", "bad index block handle")
+		return r, nil
+	}
+
+	// Read metaindex block.
+	metaBlock, err := r.readBlock(r.metaBH, true)
+	if err != nil {
+		if errors.IsCorrupted(err) {
+			r.err = err
+			return r, nil
+		} else {
+			return nil, err
+		}
+	}
+
+	// Set data end.
+	r.dataEnd = int64(r.metaBH.offset)
+
+	// Read metaindex.
+	metaIter := r.newBlockIter(metaBlock, nil, nil, true)
+	for metaIter.Next() {
+		key := string(metaIter.Key())
+		if !strings.HasPrefix(key, "filter.") {
+			continue
+		}
+		fn := key[7:]
+		if f0 := o.GetFilter(); f0 != nil && f0.Name() == fn {
+			r.filter = f0
+		} else {
+			for _, f0 := range o.GetAltFilters() {
+				if f0.Name() == fn {
+					r.filter = f0
+					break
+				}
+			}
+		}
+		if r.filter != nil {
+			filterBH, n := decodeBlockHandle(metaIter.Value())
+			if n == 0 {
+				continue
+			}
+			r.filterBH = filterBH
+			// Update data end.
+			r.dataEnd = int64(filterBH.offset)
+			break
+		}
+	}
+	metaIter.Release()
+	metaBlock.Release()
+
+	// Cache index and filter block locally, since we don't have global cache.
+	if cache == nil {
+		r.indexBlock, err = r.readBlock(r.indexBH, true)
+		if err != nil {
+			if errors.IsCorrupted(err) {
+				r.err = err
+				return r, nil
+			} else {
+				return nil, err
+			}
+		}
+		if r.filter != nil {
+			r.filterBlock, err = r.readFilterBlock(r.filterBH)
+			if err != nil {
+				if !errors.IsCorrupted(err) {
+					return nil, err
+				}
+
+				// Don't use filter then.
+				r.filter = nil
+			}
+		}
+	}
+
+	return r, nil
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/table/table.go b/vendor/github.com/syndtr/goleveldb/leveldb/table/table.go
new file mode 100644
index 00000000..beacdc1f
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/table/table.go
@@ -0,0 +1,177 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package table allows read and write sorted key/value.
+package table
+
+import (
+	"encoding/binary"
+)
+
+/*
+Table:
+
+Table is consist of one or more data blocks, an optional filter block
+a metaindex block, an index block and a table footer. Metaindex block
+is a special block used to keep parameters of the table, such as filter
+block name and its block handle. Index block is a special block used to
+keep record of data blocks offset and length, index block use one as
+restart interval. The key used by index block are the last key of preceding
+block, shorter separator of adjacent blocks or shorter successor of the
+last key of the last block. Filter block is an optional block contains
+sequence of filter data generated by a filter generator.
+
+Table data structure:
+                                                         + optional
+                                                        /
+    +--------------+--------------+--------------+------+-------+-----------------+-------------+--------+
+    | data block 1 |      ...     | data block n | filter block | metaindex block | index block | footer |
+    +--------------+--------------+--------------+--------------+-----------------+-------------+--------+
+
+    Each block followed by a 5-bytes trailer contains compression type and checksum.
+
+Table block trailer:
+
+    +---------------------------+-------------------+
+    | compression type (1-byte) | checksum (4-byte) |
+    +---------------------------+-------------------+
+
+    The checksum is a CRC-32 computed using Castagnoli's polynomial. Compression
+    type also included in the checksum.
+
+Table footer:
+
+      +------------------- 40-bytes -------------------+
+     /                                                  \
+    +------------------------+--------------------+------+-----------------+
+    | metaindex block handle / index block handle / ---- | magic (8-bytes) |
+    +------------------------+--------------------+------+-----------------+
+
+    The magic are first 64-bit of SHA-1 sum of "http://code.google.com/p/leveldb/".
+
+NOTE: All fixed-length integer are little-endian.
+*/
+
+/*
+Block:
+
+Block is consist of one or more key/value entries and a block trailer.
+Block entry shares key prefix with its preceding key until a restart
+point reached. A block should contains at least one restart point.
+First restart point are always zero.
+
+Block data structure:
+
+      + restart point                 + restart point (depends on restart interval)
+     /                               /
+    +---------------+---------------+---------------+---------------+---------+
+    | block entry 1 | block entry 2 |      ...      | block entry n | trailer |
+    +---------------+---------------+---------------+---------------+---------+
+
+Key/value entry:
+
+              +---- key len ----+
+             /                   \
+    +-------+---------+-----------+---------+--------------------+--------------+----------------+
+    | shared (varint) | not shared (varint) | value len (varint) | key (varlen) | value (varlen) |
+    +-----------------+---------------------+--------------------+--------------+----------------+
+
+    Block entry shares key prefix with its preceding key:
+    Conditions:
+        restart_interval=2
+        entry one  : key=deck,value=v1
+        entry two  : key=dock,value=v2
+        entry three: key=duck,value=v3
+    The entries will be encoded as follow:
+
+      + restart point (offset=0)                                                 + restart point (offset=16)
+     /                                                                          /
+    +-----+-----+-----+----------+--------+-----+-----+-----+---------+--------+-----+-----+-----+----------+--------+
+    |  0  |  4  |  2  |  "deck"  |  "v1"  |  1  |  3  |  2  |  "ock"  |  "v2"  |  0  |  4  |  2  |  "duck"  |  "v3"  |
+    +-----+-----+-----+----------+--------+-----+-----+-----+---------+--------+-----+-----+-----+----------+--------+
+     \                                   / \                                  / \                                   /
+      +----------- entry one -----------+   +----------- entry two ----------+   +---------- entry three ----------+
+
+    The block trailer will contains two restart points:
+
+    +------------+-----------+--------+
+    |     0      |    16     |   2    |
+    +------------+-----------+---+----+
+     \                      /     \
+      +-- restart points --+       + restart points length
+
+Block trailer:
+
+      +-- 4-bytes --+
+     /               \
+    +-----------------+-----------------+-----------------+------------------------------+
+    | restart point 1 |       ....      | restart point n | restart points len (4-bytes) |
+    +-----------------+-----------------+-----------------+------------------------------+
+
+
+NOTE: All fixed-length integer are little-endian.
+*/
+
+/*
+Filter block:
+
+Filter block consist of one or more filter data and a filter block trailer.
+The trailer contains filter data offsets, a trailer offset and a 1-byte base Lg.
+
+Filter block data structure:
+
+      + offset 1      + offset 2      + offset n      + trailer offset
+     /               /               /               /
+    +---------------+---------------+---------------+---------+
+    | filter data 1 |      ...      | filter data n | trailer |
+    +---------------+---------------+---------------+---------+
+
+Filter block trailer:
+
+      +- 4-bytes -+
+     /             \
+    +---------------+---------------+---------------+-------------------------------+------------------+
+    | data 1 offset |      ....     | data n offset | data-offsets offset (4-bytes) | base Lg (1-byte) |
+    +-------------- +---------------+---------------+-------------------------------+------------------+
+
+
+NOTE: All fixed-length integer are little-endian.
+*/
+
+const (
+	blockTrailerLen = 5
+	footerLen       = 48
+
+	magic = "\x57\xfb\x80\x8b\x24\x75\x47\xdb"
+
+	// The block type gives the per-block compression format.
+	// These constants are part of the file format and should not be changed.
+	blockTypeNoCompression     = 0
+	blockTypeSnappyCompression = 1
+
+	// Generate new filter every 2KB of data
+	filterBaseLg = 11
+	filterBase   = 1 << filterBaseLg
+)
+
+type blockHandle struct {
+	offset, length uint64
+}
+
+func decodeBlockHandle(src []byte) (blockHandle, int) {
+	offset, n := binary.Uvarint(src)
+	length, m := binary.Uvarint(src[n:])
+	if n == 0 || m == 0 {
+		return blockHandle{}, 0
+	}
+	return blockHandle{offset, length}, n + m
+}
+
+func encodeBlockHandle(dst []byte, b blockHandle) int {
+	n := binary.PutUvarint(dst, b.offset)
+	m := binary.PutUvarint(dst[n:], b.length)
+	return n + m
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/table/writer.go b/vendor/github.com/syndtr/goleveldb/leveldb/table/writer.go
new file mode 100644
index 00000000..274c95fa
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/table/writer.go
@@ -0,0 +1,379 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package table
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/syndtr/gosnappy/snappy"
+
+	"github.com/syndtr/goleveldb/leveldb/comparer"
+	"github.com/syndtr/goleveldb/leveldb/filter"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func sharedPrefixLen(a, b []byte) int {
+	i, n := 0, len(a)
+	if n > len(b) {
+		n = len(b)
+	}
+	for i < n && a[i] == b[i] {
+		i++
+	}
+	return i
+}
+
+type blockWriter struct {
+	restartInterval int
+	buf             util.Buffer
+	nEntries        int
+	prevKey         []byte
+	restarts        []uint32
+	scratch         []byte
+}
+
+func (w *blockWriter) append(key, value []byte) {
+	nShared := 0
+	if w.nEntries%w.restartInterval == 0 {
+		w.restarts = append(w.restarts, uint32(w.buf.Len()))
+	} else {
+		nShared = sharedPrefixLen(w.prevKey, key)
+	}
+	n := binary.PutUvarint(w.scratch[0:], uint64(nShared))
+	n += binary.PutUvarint(w.scratch[n:], uint64(len(key)-nShared))
+	n += binary.PutUvarint(w.scratch[n:], uint64(len(value)))
+	w.buf.Write(w.scratch[:n])
+	w.buf.Write(key[nShared:])
+	w.buf.Write(value)
+	w.prevKey = append(w.prevKey[:0], key...)
+	w.nEntries++
+}
+
+func (w *blockWriter) finish() {
+	// Write restarts entry.
+	if w.nEntries == 0 {
+		// Must have at least one restart entry.
+		w.restarts = append(w.restarts, 0)
+	}
+	w.restarts = append(w.restarts, uint32(len(w.restarts)))
+	for _, x := range w.restarts {
+		buf4 := w.buf.Alloc(4)
+		binary.LittleEndian.PutUint32(buf4, x)
+	}
+}
+
+func (w *blockWriter) reset() {
+	w.buf.Reset()
+	w.nEntries = 0
+	w.restarts = w.restarts[:0]
+}
+
+func (w *blockWriter) bytesLen() int {
+	restartsLen := len(w.restarts)
+	if restartsLen == 0 {
+		restartsLen = 1
+	}
+	return w.buf.Len() + 4*restartsLen + 4
+}
+
+type filterWriter struct {
+	generator filter.FilterGenerator
+	buf       util.Buffer
+	nKeys     int
+	offsets   []uint32
+}
+
+func (w *filterWriter) add(key []byte) {
+	if w.generator == nil {
+		return
+	}
+	w.generator.Add(key)
+	w.nKeys++
+}
+
+func (w *filterWriter) flush(offset uint64) {
+	if w.generator == nil {
+		return
+	}
+	for x := int(offset / filterBase); x > len(w.offsets); {
+		w.generate()
+	}
+}
+
+func (w *filterWriter) finish() {
+	if w.generator == nil {
+		return
+	}
+	// Generate last keys.
+
+	if w.nKeys > 0 {
+		w.generate()
+	}
+	w.offsets = append(w.offsets, uint32(w.buf.Len()))
+	for _, x := range w.offsets {
+		buf4 := w.buf.Alloc(4)
+		binary.LittleEndian.PutUint32(buf4, x)
+	}
+	w.buf.WriteByte(filterBaseLg)
+}
+
+func (w *filterWriter) generate() {
+	// Record offset.
+	w.offsets = append(w.offsets, uint32(w.buf.Len()))
+	// Generate filters.
+	if w.nKeys > 0 {
+		w.generator.Generate(&w.buf)
+		w.nKeys = 0
+	}
+}
+
+// Writer is a table writer.
+type Writer struct {
+	writer io.Writer
+	err    error
+	// Options
+	cmp         comparer.Comparer
+	filter      filter.Filter
+	compression opt.Compression
+	blockSize   int
+
+	dataBlock   blockWriter
+	indexBlock  blockWriter
+	filterBlock filterWriter
+	pendingBH   blockHandle
+	offset      uint64
+	nEntries    int
+	// Scratch allocated enough for 5 uvarint. Block writer should not use
+	// first 20-bytes since it will be used to encode block handle, which
+	// then passed to the block writer itself.
+	scratch            [50]byte
+	comparerScratch    []byte
+	compressionScratch []byte
+}
+
+func (w *Writer) writeBlock(buf *util.Buffer, compression opt.Compression) (bh blockHandle, err error) {
+	// Compress the buffer if necessary.
+	var b []byte
+	if compression == opt.SnappyCompression {
+		// Allocate scratch enough for compression and block trailer.
+		if n := snappy.MaxEncodedLen(buf.Len()) + blockTrailerLen; len(w.compressionScratch) < n {
+			w.compressionScratch = make([]byte, n)
+		}
+		var compressed []byte
+		compressed, err = snappy.Encode(w.compressionScratch, buf.Bytes())
+		if err != nil {
+			return
+		}
+		n := len(compressed)
+		b = compressed[:n+blockTrailerLen]
+		b[n] = blockTypeSnappyCompression
+	} else {
+		tmp := buf.Alloc(blockTrailerLen)
+		tmp[0] = blockTypeNoCompression
+		b = buf.Bytes()
+	}
+
+	// Calculate the checksum.
+	n := len(b) - 4
+	checksum := util.NewCRC(b[:n]).Value()
+	binary.LittleEndian.PutUint32(b[n:], checksum)
+
+	// Write the buffer to the file.
+	_, err = w.writer.Write(b)
+	if err != nil {
+		return
+	}
+	bh = blockHandle{w.offset, uint64(len(b) - blockTrailerLen)}
+	w.offset += uint64(len(b))
+	return
+}
+
+func (w *Writer) flushPendingBH(key []byte) {
+	if w.pendingBH.length == 0 {
+		return
+	}
+	var separator []byte
+	if len(key) == 0 {
+		separator = w.cmp.Successor(w.comparerScratch[:0], w.dataBlock.prevKey)
+	} else {
+		separator = w.cmp.Separator(w.comparerScratch[:0], w.dataBlock.prevKey, key)
+	}
+	if separator == nil {
+		separator = w.dataBlock.prevKey
+	} else {
+		w.comparerScratch = separator
+	}
+	n := encodeBlockHandle(w.scratch[:20], w.pendingBH)
+	// Append the block handle to the index block.
+	w.indexBlock.append(separator, w.scratch[:n])
+	// Reset prev key of the data block.
+	w.dataBlock.prevKey = w.dataBlock.prevKey[:0]
+	// Clear pending block handle.
+	w.pendingBH = blockHandle{}
+}
+
+func (w *Writer) finishBlock() error {
+	w.dataBlock.finish()
+	bh, err := w.writeBlock(&w.dataBlock.buf, w.compression)
+	if err != nil {
+		return err
+	}
+	w.pendingBH = bh
+	// Reset the data block.
+	w.dataBlock.reset()
+	// Flush the filter block.
+	w.filterBlock.flush(w.offset)
+	return nil
+}
+
+// Append appends key/value pair to the table. The keys passed must
+// be in increasing order.
+//
+// It is safe to modify the contents of the arguments after Append returns.
+func (w *Writer) Append(key, value []byte) error {
+	if w.err != nil {
+		return w.err
+	}
+	if w.nEntries > 0 && w.cmp.Compare(w.dataBlock.prevKey, key) >= 0 {
+		w.err = fmt.Errorf("leveldb/table: Writer: keys are not in increasing order: %q, %q", w.dataBlock.prevKey, key)
+		return w.err
+	}
+
+	w.flushPendingBH(key)
+	// Append key/value pair to the data block.
+	w.dataBlock.append(key, value)
+	// Add key to the filter block.
+	w.filterBlock.add(key)
+
+	// Finish the data block if block size target reached.
+	if w.dataBlock.bytesLen() >= w.blockSize {
+		if err := w.finishBlock(); err != nil {
+			w.err = err
+			return w.err
+		}
+	}
+	w.nEntries++
+	return nil
+}
+
+// BlocksLen returns number of blocks written so far.
+func (w *Writer) BlocksLen() int {
+	n := w.indexBlock.nEntries
+	if w.pendingBH.length > 0 {
+		// Includes the pending block.
+		n++
+	}
+	return n
+}
+
+// EntriesLen returns number of entries added so far.
+func (w *Writer) EntriesLen() int {
+	return w.nEntries
+}
+
+// BytesLen returns number of bytes written so far.
+func (w *Writer) BytesLen() int {
+	return int(w.offset)
+}
+
+// Close will finalize the table. Calling Append is not possible
+// after Close, but calling BlocksLen, EntriesLen and BytesLen
+// is still possible.
+func (w *Writer) Close() error {
+	if w.err != nil {
+		return w.err
+	}
+
+	// Write the last data block. Or empty data block if there
+	// aren't any data blocks at all.
+	if w.dataBlock.nEntries > 0 || w.nEntries == 0 {
+		if err := w.finishBlock(); err != nil {
+			w.err = err
+			return w.err
+		}
+	}
+	w.flushPendingBH(nil)
+
+	// Write the filter block.
+	var filterBH blockHandle
+	w.filterBlock.finish()
+	if buf := &w.filterBlock.buf; buf.Len() > 0 {
+		filterBH, w.err = w.writeBlock(buf, opt.NoCompression)
+		if w.err != nil {
+			return w.err
+		}
+	}
+
+	// Write the metaindex block.
+	if filterBH.length > 0 {
+		key := []byte("filter." + w.filter.Name())
+		n := encodeBlockHandle(w.scratch[:20], filterBH)
+		w.dataBlock.append(key, w.scratch[:n])
+	}
+	w.dataBlock.finish()
+	metaindexBH, err := w.writeBlock(&w.dataBlock.buf, w.compression)
+	if err != nil {
+		w.err = err
+		return w.err
+	}
+
+	// Write the index block.
+	w.indexBlock.finish()
+	indexBH, err := w.writeBlock(&w.indexBlock.buf, w.compression)
+	if err != nil {
+		w.err = err
+		return w.err
+	}
+
+	// Write the table footer.
+	footer := w.scratch[:footerLen]
+	for i := range footer {
+		footer[i] = 0
+	}
+	n := encodeBlockHandle(footer, metaindexBH)
+	encodeBlockHandle(footer[n:], indexBH)
+	copy(footer[footerLen-len(magic):], magic)
+	if _, err := w.writer.Write(footer); err != nil {
+		w.err = err
+		return w.err
+	}
+	w.offset += footerLen
+
+	w.err = errors.New("leveldb/table: writer is closed")
+	return nil
+}
+
+// NewWriter creates a new initialized table writer for the file.
+//
+// Table writer is not goroutine-safe.
+func NewWriter(f io.Writer, o *opt.Options) *Writer {
+	w := &Writer{
+		writer:          f,
+		cmp:             o.GetComparer(),
+		filter:          o.GetFilter(),
+		compression:     o.GetCompression(),
+		blockSize:       o.GetBlockSize(),
+		comparerScratch: make([]byte, 0),
+	}
+	// data block
+	w.dataBlock.restartInterval = o.GetBlockRestartInterval()
+	// The first 20-bytes are used for encoding block handle.
+	w.dataBlock.scratch = w.scratch[20:]
+	// index block
+	w.indexBlock.restartInterval = 1
+	w.indexBlock.scratch = w.scratch[20:]
+	// filter block
+	if w.filter != nil {
+		w.filterBlock.generator = w.filter.NewGenerator()
+		w.filterBlock.flush(0)
+	}
+	return w
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/db.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/db.go
new file mode 100644
index 00000000..ec3f177a
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/db.go
@@ -0,0 +1,222 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+	"fmt"
+	"math/rand"
+
+	. "github.com/onsi/gomega"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type DB interface{}
+
+type Put interface {
+	TestPut(key []byte, value []byte) error
+}
+
+type Delete interface {
+	TestDelete(key []byte) error
+}
+
+type Find interface {
+	TestFind(key []byte) (rkey, rvalue []byte, err error)
+}
+
+type Get interface {
+	TestGet(key []byte) (value []byte, err error)
+}
+
+type Has interface {
+	TestHas(key []byte) (ret bool, err error)
+}
+
+type NewIterator interface {
+	TestNewIterator(slice *util.Range) iterator.Iterator
+}
+
+type DBAct int
+
+func (a DBAct) String() string {
+	switch a {
+	case DBNone:
+		return "none"
+	case DBPut:
+		return "put"
+	case DBOverwrite:
+		return "overwrite"
+	case DBDelete:
+		return "delete"
+	case DBDeleteNA:
+		return "delete_na"
+	}
+	return "unknown"
+}
+
+const (
+	DBNone DBAct = iota
+	DBPut
+	DBOverwrite
+	DBDelete
+	DBDeleteNA
+)
+
+type DBTesting struct {
+	Rand *rand.Rand
+	DB   interface {
+		Get
+		Put
+		Delete
+	}
+	PostFn             func(t *DBTesting)
+	Deleted, Present   KeyValue
+	Act, LastAct       DBAct
+	ActKey, LastActKey []byte
+}
+
+func (t *DBTesting) post() {
+	if t.PostFn != nil {
+		t.PostFn(t)
+	}
+}
+
+func (t *DBTesting) setAct(act DBAct, key []byte) {
+	t.LastAct, t.Act = t.Act, act
+	t.LastActKey, t.ActKey = t.ActKey, key
+}
+
+func (t *DBTesting) text() string {
+	return fmt.Sprintf("last action was <%v> %q, <%v> %q", t.LastAct, t.LastActKey, t.Act, t.ActKey)
+}
+
+func (t *DBTesting) Text() string {
+	return "DBTesting " + t.text()
+}
+
+func (t *DBTesting) TestPresentKV(key, value []byte) {
+	rvalue, err := t.DB.TestGet(key)
+	Expect(err).ShouldNot(HaveOccurred(), "Get on key %q, %s", key, t.text())
+	Expect(rvalue).Should(Equal(value), "Value for key %q, %s", key, t.text())
+}
+
+func (t *DBTesting) TestAllPresent() {
+	t.Present.IterateShuffled(t.Rand, func(i int, key, value []byte) {
+		t.TestPresentKV(key, value)
+	})
+}
+
+func (t *DBTesting) TestDeletedKey(key []byte) {
+	_, err := t.DB.TestGet(key)
+	Expect(err).Should(Equal(errors.ErrNotFound), "Get on deleted key %q, %s", key, t.text())
+}
+
+func (t *DBTesting) TestAllDeleted() {
+	t.Deleted.IterateShuffled(t.Rand, func(i int, key, value []byte) {
+		t.TestDeletedKey(key)
+	})
+}
+
+func (t *DBTesting) TestAll() {
+	dn := t.Deleted.Len()
+	pn := t.Present.Len()
+	ShuffledIndex(t.Rand, dn+pn, 1, func(i int) {
+		if i >= dn {
+			key, value := t.Present.Index(i - dn)
+			t.TestPresentKV(key, value)
+		} else {
+			t.TestDeletedKey(t.Deleted.KeyAt(i))
+		}
+	})
+}
+
+func (t *DBTesting) Put(key, value []byte) {
+	if new := t.Present.PutU(key, value); new {
+		t.setAct(DBPut, key)
+	} else {
+		t.setAct(DBOverwrite, key)
+	}
+	t.Deleted.Delete(key)
+	err := t.DB.TestPut(key, value)
+	Expect(err).ShouldNot(HaveOccurred(), t.Text())
+	t.TestPresentKV(key, value)
+	t.post()
+}
+
+func (t *DBTesting) PutRandom() bool {
+	if t.Deleted.Len() > 0 {
+		i := t.Rand.Intn(t.Deleted.Len())
+		key, value := t.Deleted.Index(i)
+		t.Put(key, value)
+		return true
+	}
+	return false
+}
+
+func (t *DBTesting) Delete(key []byte) {
+	if exist, value := t.Present.Delete(key); exist {
+		t.setAct(DBDelete, key)
+		t.Deleted.PutU(key, value)
+	} else {
+		t.setAct(DBDeleteNA, key)
+	}
+	err := t.DB.TestDelete(key)
+	Expect(err).ShouldNot(HaveOccurred(), t.Text())
+	t.TestDeletedKey(key)
+	t.post()
+}
+
+func (t *DBTesting) DeleteRandom() bool {
+	if t.Present.Len() > 0 {
+		i := t.Rand.Intn(t.Present.Len())
+		t.Delete(t.Present.KeyAt(i))
+		return true
+	}
+	return false
+}
+
+func (t *DBTesting) RandomAct(round int) {
+	for i := 0; i < round; i++ {
+		if t.Rand.Int()%2 == 0 {
+			t.PutRandom()
+		} else {
+			t.DeleteRandom()
+		}
+	}
+}
+
+func DoDBTesting(t *DBTesting) {
+	if t.Rand == nil {
+		t.Rand = NewRand()
+	}
+
+	t.DeleteRandom()
+	t.PutRandom()
+	t.DeleteRandom()
+	t.DeleteRandom()
+	for i := t.Deleted.Len() / 2; i >= 0; i-- {
+		t.PutRandom()
+	}
+	t.RandomAct((t.Deleted.Len() + t.Present.Len()) * 10)
+
+	// Additional iterator testing
+	if db, ok := t.DB.(NewIterator); ok {
+		iter := db.TestNewIterator(nil)
+		Expect(iter.Error()).NotTo(HaveOccurred())
+
+		it := IteratorTesting{
+			KeyValue: t.Present,
+			Iter:     iter,
+		}
+
+		DoIteratorTesting(&it)
+		iter.Release()
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/ginkgo.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/ginkgo.go
new file mode 100644
index 00000000..82f3d0e8
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/ginkgo.go
@@ -0,0 +1,21 @@
+package testutil
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func RunSuite(t GinkgoTestingT, name string) {
+	RunDefer()
+
+	SynchronizedBeforeSuite(func() []byte {
+		RunDefer("setup")
+		return nil
+	}, func(data []byte) {})
+	SynchronizedAfterSuite(func() {
+		RunDefer("teardown")
+	}, func() {})
+
+	RegisterFailHandler(Fail)
+	RunSpecs(t, name)
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/iter.go
new file mode 100644
index 00000000..df6d9db6
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/iter.go
@@ -0,0 +1,327 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+	"fmt"
+	"math/rand"
+
+	. "github.com/onsi/gomega"
+
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+)
+
+type IterAct int
+
+func (a IterAct) String() string {
+	switch a {
+	case IterNone:
+		return "none"
+	case IterFirst:
+		return "first"
+	case IterLast:
+		return "last"
+	case IterPrev:
+		return "prev"
+	case IterNext:
+		return "next"
+	case IterSeek:
+		return "seek"
+	case IterSOI:
+		return "soi"
+	case IterEOI:
+		return "eoi"
+	}
+	return "unknown"
+}
+
+const (
+	IterNone IterAct = iota
+	IterFirst
+	IterLast
+	IterPrev
+	IterNext
+	IterSeek
+	IterSOI
+	IterEOI
+)
+
+type IteratorTesting struct {
+	KeyValue
+	Iter         iterator.Iterator
+	Rand         *rand.Rand
+	PostFn       func(t *IteratorTesting)
+	Pos          int
+	Act, LastAct IterAct
+
+	once bool
+}
+
+func (t *IteratorTesting) init() {
+	if !t.once {
+		t.Pos = -1
+		t.once = true
+	}
+}
+
+func (t *IteratorTesting) post() {
+	if t.PostFn != nil {
+		t.PostFn(t)
+	}
+}
+
+func (t *IteratorTesting) setAct(act IterAct) {
+	t.LastAct, t.Act = t.Act, act
+}
+
+func (t *IteratorTesting) text() string {
+	return fmt.Sprintf("at pos %d and last action was <%v> -> <%v>", t.Pos, t.LastAct, t.Act)
+}
+
+func (t *IteratorTesting) Text() string {
+	return "IteratorTesting is " + t.text()
+}
+
+func (t *IteratorTesting) IsFirst() bool {
+	t.init()
+	return t.Len() > 0 && t.Pos == 0
+}
+
+func (t *IteratorTesting) IsLast() bool {
+	t.init()
+	return t.Len() > 0 && t.Pos == t.Len()-1
+}
+
+func (t *IteratorTesting) TestKV() {
+	t.init()
+	key, value := t.Index(t.Pos)
+	Expect(t.Iter.Key()).NotTo(BeNil())
+	Expect(t.Iter.Key()).Should(Equal(key), "Key is invalid, %s", t.text())
+	Expect(t.Iter.Value()).Should(Equal(value), "Value for key %q, %s", key, t.text())
+}
+
+func (t *IteratorTesting) First() {
+	t.init()
+	t.setAct(IterFirst)
+
+	ok := t.Iter.First()
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	if t.Len() > 0 {
+		t.Pos = 0
+		Expect(ok).Should(BeTrue(), t.Text())
+		t.TestKV()
+	} else {
+		t.Pos = -1
+		Expect(ok).ShouldNot(BeTrue(), t.Text())
+	}
+	t.post()
+}
+
+func (t *IteratorTesting) Last() {
+	t.init()
+	t.setAct(IterLast)
+
+	ok := t.Iter.Last()
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	if t.Len() > 0 {
+		t.Pos = t.Len() - 1
+		Expect(ok).Should(BeTrue(), t.Text())
+		t.TestKV()
+	} else {
+		t.Pos = 0
+		Expect(ok).ShouldNot(BeTrue(), t.Text())
+	}
+	t.post()
+}
+
+func (t *IteratorTesting) Next() {
+	t.init()
+	t.setAct(IterNext)
+
+	ok := t.Iter.Next()
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	if t.Pos < t.Len()-1 {
+		t.Pos++
+		Expect(ok).Should(BeTrue(), t.Text())
+		t.TestKV()
+	} else {
+		t.Pos = t.Len()
+		Expect(ok).ShouldNot(BeTrue(), t.Text())
+	}
+	t.post()
+}
+
+func (t *IteratorTesting) Prev() {
+	t.init()
+	t.setAct(IterPrev)
+
+	ok := t.Iter.Prev()
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	if t.Pos > 0 {
+		t.Pos--
+		Expect(ok).Should(BeTrue(), t.Text())
+		t.TestKV()
+	} else {
+		t.Pos = -1
+		Expect(ok).ShouldNot(BeTrue(), t.Text())
+	}
+	t.post()
+}
+
+func (t *IteratorTesting) Seek(i int) {
+	t.init()
+	t.setAct(IterSeek)
+
+	key, _ := t.Index(i)
+	oldKey, _ := t.IndexOrNil(t.Pos)
+
+	ok := t.Iter.Seek(key)
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	Expect(ok).Should(BeTrue(), fmt.Sprintf("Seek from key %q to %q, to pos %d, %s", oldKey, key, i, t.text()))
+
+	t.Pos = i
+	t.TestKV()
+	t.post()
+}
+
+func (t *IteratorTesting) SeekInexact(i int) {
+	t.init()
+	t.setAct(IterSeek)
+	var key0 []byte
+	key1, _ := t.Index(i)
+	if i > 0 {
+		key0, _ = t.Index(i - 1)
+	}
+	key := BytesSeparator(key0, key1)
+	oldKey, _ := t.IndexOrNil(t.Pos)
+
+	ok := t.Iter.Seek(key)
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	Expect(ok).Should(BeTrue(), fmt.Sprintf("Seek from key %q to %q (%q), to pos %d, %s", oldKey, key, key1, i, t.text()))
+
+	t.Pos = i
+	t.TestKV()
+	t.post()
+}
+
+func (t *IteratorTesting) SeekKey(key []byte) {
+	t.init()
+	t.setAct(IterSeek)
+	oldKey, _ := t.IndexOrNil(t.Pos)
+	i := t.Search(key)
+
+	ok := t.Iter.Seek(key)
+	Expect(t.Iter.Error()).ShouldNot(HaveOccurred())
+	if i < t.Len() {
+		key_, _ := t.Index(i)
+		Expect(ok).Should(BeTrue(), fmt.Sprintf("Seek from key %q to %q (%q), to pos %d, %s", oldKey, key, key_, i, t.text()))
+		t.Pos = i
+		t.TestKV()
+	} else {
+		Expect(ok).ShouldNot(BeTrue(), fmt.Sprintf("Seek from key %q to %q, %s", oldKey, key, t.text()))
+	}
+
+	t.Pos = i
+	t.post()
+}
+
+func (t *IteratorTesting) SOI() {
+	t.init()
+	t.setAct(IterSOI)
+	Expect(t.Pos).Should(BeNumerically("<=", 0), t.Text())
+	for i := 0; i < 3; i++ {
+		t.Prev()
+	}
+	t.post()
+}
+
+func (t *IteratorTesting) EOI() {
+	t.init()
+	t.setAct(IterEOI)
+	Expect(t.Pos).Should(BeNumerically(">=", t.Len()-1), t.Text())
+	for i := 0; i < 3; i++ {
+		t.Next()
+	}
+	t.post()
+}
+
+func (t *IteratorTesting) WalkPrev(fn func(t *IteratorTesting)) {
+	t.init()
+	for old := t.Pos; t.Pos > 0; old = t.Pos {
+		fn(t)
+		Expect(t.Pos).Should(BeNumerically("<", old), t.Text())
+	}
+}
+
+func (t *IteratorTesting) WalkNext(fn func(t *IteratorTesting)) {
+	t.init()
+	for old := t.Pos; t.Pos < t.Len()-1; old = t.Pos {
+		fn(t)
+		Expect(t.Pos).Should(BeNumerically(">", old), t.Text())
+	}
+}
+
+func (t *IteratorTesting) PrevAll() {
+	t.WalkPrev(func(t *IteratorTesting) {
+		t.Prev()
+	})
+}
+
+func (t *IteratorTesting) NextAll() {
+	t.WalkNext(func(t *IteratorTesting) {
+		t.Next()
+	})
+}
+
+func DoIteratorTesting(t *IteratorTesting) {
+	if t.Rand == nil {
+		t.Rand = NewRand()
+	}
+	t.SOI()
+	t.NextAll()
+	t.First()
+	t.SOI()
+	t.NextAll()
+	t.EOI()
+	t.PrevAll()
+	t.Last()
+	t.EOI()
+	t.PrevAll()
+	t.SOI()
+
+	t.NextAll()
+	t.PrevAll()
+	t.NextAll()
+	t.Last()
+	t.PrevAll()
+	t.First()
+	t.NextAll()
+	t.EOI()
+
+	ShuffledIndex(t.Rand, t.Len(), 1, func(i int) {
+		t.Seek(i)
+	})
+
+	ShuffledIndex(t.Rand, t.Len(), 1, func(i int) {
+		t.SeekInexact(i)
+	})
+
+	ShuffledIndex(t.Rand, t.Len(), 1, func(i int) {
+		t.Seek(i)
+		if i%2 != 0 {
+			t.PrevAll()
+			t.SOI()
+		} else {
+			t.NextAll()
+			t.EOI()
+		}
+	})
+
+	for _, key := range []string{"", "foo", "bar", "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"} {
+		t.SeekKey([]byte(key))
+	}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/kv.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/kv.go
new file mode 100644
index 00000000..471d5708
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/kv.go
@@ -0,0 +1,352 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+	"fmt"
+	"math/rand"
+	"sort"
+	"strings"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type KeyValueEntry struct {
+	key, value []byte
+}
+
+type KeyValue struct {
+	entries []KeyValueEntry
+	nbytes  int
+}
+
+func (kv *KeyValue) Put(key, value []byte) {
+	if n := len(kv.entries); n > 0 && cmp.Compare(kv.entries[n-1].key, key) >= 0 {
+		panic(fmt.Sprintf("Put: keys are not in increasing order: %q, %q", kv.entries[n-1].key, key))
+	}
+	kv.entries = append(kv.entries, KeyValueEntry{key, value})
+	kv.nbytes += len(key) + len(value)
+}
+
+func (kv *KeyValue) PutString(key, value string) {
+	kv.Put([]byte(key), []byte(value))
+}
+
+func (kv *KeyValue) PutU(key, value []byte) bool {
+	if i, exist := kv.Get(key); !exist {
+		if i < kv.Len() {
+			kv.entries = append(kv.entries[:i+1], kv.entries[i:]...)
+			kv.entries[i] = KeyValueEntry{key, value}
+		} else {
+			kv.entries = append(kv.entries, KeyValueEntry{key, value})
+		}
+		kv.nbytes += len(key) + len(value)
+		return true
+	} else {
+		kv.nbytes += len(value) - len(kv.ValueAt(i))
+		kv.entries[i].value = value
+	}
+	return false
+}
+
+func (kv *KeyValue) PutUString(key, value string) bool {
+	return kv.PutU([]byte(key), []byte(value))
+}
+
+func (kv *KeyValue) Delete(key []byte) (exist bool, value []byte) {
+	i, exist := kv.Get(key)
+	if exist {
+		value = kv.entries[i].value
+		kv.DeleteIndex(i)
+	}
+	return
+}
+
+func (kv *KeyValue) DeleteIndex(i int) bool {
+	if i < kv.Len() {
+		kv.nbytes -= len(kv.KeyAt(i)) + len(kv.ValueAt(i))
+		kv.entries = append(kv.entries[:i], kv.entries[i+1:]...)
+		return true
+	}
+	return false
+}
+
+func (kv KeyValue) Len() int {
+	return len(kv.entries)
+}
+
+func (kv *KeyValue) Size() int {
+	return kv.nbytes
+}
+
+func (kv KeyValue) KeyAt(i int) []byte {
+	return kv.entries[i].key
+}
+
+func (kv KeyValue) ValueAt(i int) []byte {
+	return kv.entries[i].value
+}
+
+func (kv KeyValue) Index(i int) (key, value []byte) {
+	if i < 0 || i >= len(kv.entries) {
+		panic(fmt.Sprintf("Index #%d: out of range", i))
+	}
+	return kv.entries[i].key, kv.entries[i].value
+}
+
+func (kv KeyValue) IndexInexact(i int) (key_, key, value []byte) {
+	key, value = kv.Index(i)
+	var key0 []byte
+	var key1 = kv.KeyAt(i)
+	if i > 0 {
+		key0 = kv.KeyAt(i - 1)
+	}
+	key_ = BytesSeparator(key0, key1)
+	return
+}
+
+func (kv KeyValue) IndexOrNil(i int) (key, value []byte) {
+	if i >= 0 && i < len(kv.entries) {
+		return kv.entries[i].key, kv.entries[i].value
+	}
+	return nil, nil
+}
+
+func (kv KeyValue) IndexString(i int) (key, value string) {
+	key_, _value := kv.Index(i)
+	return string(key_), string(_value)
+}
+
+func (kv KeyValue) Search(key []byte) int {
+	return sort.Search(kv.Len(), func(i int) bool {
+		return cmp.Compare(kv.KeyAt(i), key) >= 0
+	})
+}
+
+func (kv KeyValue) SearchString(key string) int {
+	return kv.Search([]byte(key))
+}
+
+func (kv KeyValue) Get(key []byte) (i int, exist bool) {
+	i = kv.Search(key)
+	if i < kv.Len() && cmp.Compare(kv.KeyAt(i), key) == 0 {
+		exist = true
+	}
+	return
+}
+
+func (kv KeyValue) GetString(key string) (i int, exist bool) {
+	return kv.Get([]byte(key))
+}
+
+func (kv KeyValue) Iterate(fn func(i int, key, value []byte)) {
+	for i, x := range kv.entries {
+		fn(i, x.key, x.value)
+	}
+}
+
+func (kv KeyValue) IterateString(fn func(i int, key, value string)) {
+	kv.Iterate(func(i int, key, value []byte) {
+		fn(i, string(key), string(value))
+	})
+}
+
+func (kv KeyValue) IterateShuffled(rnd *rand.Rand, fn func(i int, key, value []byte)) {
+	ShuffledIndex(rnd, kv.Len(), 1, func(i int) {
+		fn(i, kv.entries[i].key, kv.entries[i].value)
+	})
+}
+
+func (kv KeyValue) IterateShuffledString(rnd *rand.Rand, fn func(i int, key, value string)) {
+	kv.IterateShuffled(rnd, func(i int, key, value []byte) {
+		fn(i, string(key), string(value))
+	})
+}
+
+func (kv KeyValue) IterateInexact(fn func(i int, key_, key, value []byte)) {
+	for i := range kv.entries {
+		key_, key, value := kv.IndexInexact(i)
+		fn(i, key_, key, value)
+	}
+}
+
+func (kv KeyValue) IterateInexactString(fn func(i int, key_, key, value string)) {
+	kv.IterateInexact(func(i int, key_, key, value []byte) {
+		fn(i, string(key_), string(key), string(value))
+	})
+}
+
+func (kv KeyValue) Clone() KeyValue {
+	return KeyValue{append([]KeyValueEntry{}, kv.entries...), kv.nbytes}
+}
+
+func (kv KeyValue) Slice(start, limit int) KeyValue {
+	if start < 0 || limit > kv.Len() {
+		panic(fmt.Sprintf("Slice %d .. %d: out of range", start, limit))
+	} else if limit < start {
+		panic(fmt.Sprintf("Slice %d .. %d: invalid range", start, limit))
+	}
+	return KeyValue{append([]KeyValueEntry{}, kv.entries[start:limit]...), kv.nbytes}
+}
+
+func (kv KeyValue) SliceKey(start, limit []byte) KeyValue {
+	start_ := 0
+	limit_ := kv.Len()
+	if start != nil {
+		start_ = kv.Search(start)
+	}
+	if limit != nil {
+		limit_ = kv.Search(limit)
+	}
+	return kv.Slice(start_, limit_)
+}
+
+func (kv KeyValue) SliceKeyString(start, limit string) KeyValue {
+	return kv.SliceKey([]byte(start), []byte(limit))
+}
+
+func (kv KeyValue) SliceRange(r *util.Range) KeyValue {
+	if r != nil {
+		return kv.SliceKey(r.Start, r.Limit)
+	}
+	return kv.Clone()
+}
+
+func (kv KeyValue) Range(start, limit int) (r util.Range) {
+	if kv.Len() > 0 {
+		if start == kv.Len() {
+			r.Start = BytesAfter(kv.KeyAt(start - 1))
+		} else {
+			r.Start = kv.KeyAt(start)
+		}
+	}
+	if limit < kv.Len() {
+		r.Limit = kv.KeyAt(limit)
+	}
+	return
+}
+
+func KeyValue_EmptyKey() *KeyValue {
+	kv := &KeyValue{}
+	kv.PutString("", "v")
+	return kv
+}
+
+func KeyValue_EmptyValue() *KeyValue {
+	kv := &KeyValue{}
+	kv.PutString("abc", "")
+	kv.PutString("abcd", "")
+	return kv
+}
+
+func KeyValue_OneKeyValue() *KeyValue {
+	kv := &KeyValue{}
+	kv.PutString("abc", "v")
+	return kv
+}
+
+func KeyValue_BigValue() *KeyValue {
+	kv := &KeyValue{}
+	kv.PutString("big1", strings.Repeat("1", 200000))
+	return kv
+}
+
+func KeyValue_SpecialKey() *KeyValue {
+	kv := &KeyValue{}
+	kv.PutString("\xff\xff", "v3")
+	return kv
+}
+
+func KeyValue_MultipleKeyValue() *KeyValue {
+	kv := &KeyValue{}
+	kv.PutString("a", "v")
+	kv.PutString("aa", "v1")
+	kv.PutString("aaa", "v2")
+	kv.PutString("aaacccccccccc", "v2")
+	kv.PutString("aaaccccccccccd", "v3")
+	kv.PutString("aaaccccccccccf", "v4")
+	kv.PutString("aaaccccccccccfg", "v5")
+	kv.PutString("ab", "v6")
+	kv.PutString("abc", "v7")
+	kv.PutString("abcd", "v8")
+	kv.PutString("accccccccccccccc", "v9")
+	kv.PutString("b", "v10")
+	kv.PutString("bb", "v11")
+	kv.PutString("bc", "v12")
+	kv.PutString("c", "v13")
+	kv.PutString("c1", "v13")
+	kv.PutString("czzzzzzzzzzzzzz", "v14")
+	kv.PutString("fffffffffffffff", "v15")
+	kv.PutString("g11", "v15")
+	kv.PutString("g111", "v15")
+	kv.PutString("g111\xff", "v15")
+	kv.PutString("zz", "v16")
+	kv.PutString("zzzzzzz", "v16")
+	kv.PutString("zzzzzzzzzzzzzzzz", "v16")
+	return kv
+}
+
+var keymap = []byte("012345678ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxy")
+
+func KeyValue_Generate(rnd *rand.Rand, n, minlen, maxlen, vminlen, vmaxlen int) *KeyValue {
+	if rnd == nil {
+		rnd = NewRand()
+	}
+	if maxlen < minlen {
+		panic("max len should >= min len")
+	}
+
+	rrand := func(min, max int) int {
+		if min == max {
+			return max
+		}
+		return rnd.Intn(max-min) + min
+	}
+
+	kv := &KeyValue{}
+	endC := byte(len(keymap) - 1)
+	gen := make([]byte, 0, maxlen)
+	for i := 0; i < n; i++ {
+		m := rrand(minlen, maxlen)
+		last := gen
+	retry:
+		gen = last[:m]
+		if k := len(last); m > k {
+			for j := k; j < m; j++ {
+				gen[j] = 0
+			}
+		} else {
+			for j := m - 1; j >= 0; j-- {
+				c := last[j]
+				if c == endC {
+					continue
+				}
+				gen[j] = c + 1
+				for j += 1; j < m; j++ {
+					gen[j] = 0
+				}
+				goto ok
+			}
+			if m < maxlen {
+				m++
+				goto retry
+			}
+			panic(fmt.Sprintf("only able to generate %d keys out of %d keys, try increasing max len", kv.Len(), n))
+		ok:
+		}
+		key := make([]byte, m)
+		for j := 0; j < m; j++ {
+			key[j] = keymap[gen[j]]
+		}
+		value := make([]byte, rrand(vminlen, vmaxlen))
+		for n := copy(value, []byte(fmt.Sprintf("v%d", i))); n < len(value); n++ {
+			value[n] = 'x'
+		}
+		kv.Put(key, value)
+	}
+	return kv
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
new file mode 100644
index 00000000..a0b58f0e
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
@@ -0,0 +1,187 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+	"fmt"
+	"math/rand"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB, teardown func(DB)) {
+	if rnd == nil {
+		rnd = NewRand()
+	}
+
+	if p == nil {
+		BeforeEach(func() {
+			p = setup(kv)
+		})
+		if teardown != nil {
+			AfterEach(func() {
+				teardown(p)
+			})
+		}
+	}
+
+	It("Should find all keys with Find", func() {
+		if db, ok := p.(Find); ok {
+			ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+				key_, key, value := kv.IndexInexact(i)
+
+				// Using exact key.
+				rkey, rvalue, err := db.TestFind(key)
+				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+				Expect(rkey).Should(Equal(key), "Key")
+				Expect(rvalue).Should(Equal(value), "Value for key %q", key)
+
+				// Using inexact key.
+				rkey, rvalue, err = db.TestFind(key_)
+				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q)", key_, key)
+				Expect(rkey).Should(Equal(key))
+				Expect(rvalue).Should(Equal(value), "Value for key %q (%q)", key_, key)
+			})
+		}
+	})
+
+	It("Should return error if the key is not present", func() {
+		if db, ok := p.(Find); ok {
+			var key []byte
+			if kv.Len() > 0 {
+				key_, _ := kv.Index(kv.Len() - 1)
+				key = BytesAfter(key_)
+			}
+			rkey, _, err := db.TestFind(key)
+			Expect(err).Should(HaveOccurred(), "Find for key %q yield key %q", key, rkey)
+			Expect(err).Should(Equal(errors.ErrNotFound))
+		}
+	})
+
+	It("Should only find exact key with Get", func() {
+		if db, ok := p.(Get); ok {
+			ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+				key_, key, value := kv.IndexInexact(i)
+
+				// Using exact key.
+				rvalue, err := db.TestGet(key)
+				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+				Expect(rvalue).Should(Equal(value), "Value for key %q", key)
+
+				// Using inexact key.
+				if len(key_) > 0 {
+					_, err = db.TestGet(key_)
+					Expect(err).Should(HaveOccurred(), "Error for key %q", key_)
+					Expect(err).Should(Equal(errors.ErrNotFound))
+				}
+			})
+		}
+	})
+
+	It("Should only find present key with Has", func() {
+		if db, ok := p.(Has); ok {
+			ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+				key_, key, _ := kv.IndexInexact(i)
+
+				// Using exact key.
+				ret, err := db.TestHas(key)
+				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+				Expect(ret).Should(BeTrue(), "False for key %q", key)
+
+				// Using inexact key.
+				if len(key_) > 0 {
+					ret, err = db.TestHas(key_)
+					Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key_)
+					Expect(ret).ShouldNot(BeTrue(), "True for key %q", key)
+				}
+			})
+		}
+	})
+
+	TestIter := func(r *util.Range, _kv KeyValue) {
+		if db, ok := p.(NewIterator); ok {
+			iter := db.TestNewIterator(r)
+			Expect(iter.Error()).ShouldNot(HaveOccurred())
+
+			t := IteratorTesting{
+				KeyValue: _kv,
+				Iter:     iter,
+			}
+
+			DoIteratorTesting(&t)
+			iter.Release()
+		}
+	}
+
+	It("Should iterates and seeks correctly", func(done Done) {
+		TestIter(nil, kv.Clone())
+		done <- true
+	}, 3.0)
+
+	RandomIndex(rnd, kv.Len(), Min(kv.Len(), 50), func(i int) {
+		type slice struct {
+			r            *util.Range
+			start, limit int
+		}
+
+		key_, _, _ := kv.IndexInexact(i)
+		for _, x := range []slice{
+			{&util.Range{Start: key_, Limit: nil}, i, kv.Len()},
+			{&util.Range{Start: nil, Limit: key_}, 0, i},
+		} {
+			It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", x.start, x.limit), func(done Done) {
+				TestIter(x.r, kv.Slice(x.start, x.limit))
+				done <- true
+			}, 3.0)
+		}
+	})
+
+	RandomRange(rnd, kv.Len(), Min(kv.Len(), 50), func(start, limit int) {
+		It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", start, limit), func(done Done) {
+			r := kv.Range(start, limit)
+			TestIter(&r, kv.Slice(start, limit))
+			done <- true
+		}, 3.0)
+	})
+}
+
+func AllKeyValueTesting(rnd *rand.Rand, body, setup func(KeyValue) DB, teardown func(DB)) {
+	Test := func(kv *KeyValue) func() {
+		return func() {
+			var p DB
+			if setup != nil {
+				Defer("setup", func() {
+					p = setup(*kv)
+				})
+			}
+			if teardown != nil {
+				Defer("teardown", func() {
+					teardown(p)
+				})
+			}
+			if body != nil {
+				p = body(*kv)
+			}
+			KeyValueTesting(rnd, *kv, p, func(KeyValue) DB {
+				return p
+			}, nil)
+		}
+	}
+
+	Describe("with no key/value (empty)", Test(&KeyValue{}))
+	Describe("with empty key", Test(KeyValue_EmptyKey()))
+	Describe("with empty value", Test(KeyValue_EmptyValue()))
+	Describe("with one key/value", Test(KeyValue_OneKeyValue()))
+	Describe("with big value", Test(KeyValue_BigValue()))
+	Describe("with special key", Test(KeyValue_SpecialKey()))
+	Describe("with multiple key/value", Test(KeyValue_MultipleKeyValue()))
+	Describe("with generated key/value", Test(KeyValue_Generate(nil, 120, 1, 50, 10, 120)))
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/storage.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/storage.go
new file mode 100644
index 00000000..59c496d5
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/storage.go
@@ -0,0 +1,586 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+
+	. "github.com/onsi/gomega"
+
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+var (
+	storageMu     sync.Mutex
+	storageUseFS  bool = true
+	storageKeepFS bool = false
+	storageNum    int
+)
+
+type StorageMode int
+
+const (
+	ModeOpen StorageMode = 1 << iota
+	ModeCreate
+	ModeRemove
+	ModeRead
+	ModeWrite
+	ModeSync
+	ModeClose
+)
+
+const (
+	modeOpen = iota
+	modeCreate
+	modeRemove
+	modeRead
+	modeWrite
+	modeSync
+	modeClose
+
+	modeCount
+)
+
+const (
+	typeManifest = iota
+	typeJournal
+	typeTable
+	typeTemp
+
+	typeCount
+)
+
+const flattenCount = modeCount * typeCount
+
+func flattenType(m StorageMode, t storage.FileType) int {
+	var x int
+	switch m {
+	case ModeOpen:
+		x = modeOpen
+	case ModeCreate:
+		x = modeCreate
+	case ModeRemove:
+		x = modeRemove
+	case ModeRead:
+		x = modeRead
+	case ModeWrite:
+		x = modeWrite
+	case ModeSync:
+		x = modeSync
+	case ModeClose:
+		x = modeClose
+	default:
+		panic("invalid storage mode")
+	}
+	x *= typeCount
+	switch t {
+	case storage.TypeManifest:
+		return x + typeManifest
+	case storage.TypeJournal:
+		return x + typeJournal
+	case storage.TypeTable:
+		return x + typeTable
+	case storage.TypeTemp:
+		return x + typeTemp
+	default:
+		panic("invalid file type")
+	}
+}
+
+func listFlattenType(m StorageMode, t storage.FileType) []int {
+	ret := make([]int, 0, flattenCount)
+	add := func(x int) {
+		x *= typeCount
+		switch {
+		case t&storage.TypeManifest != 0:
+			ret = append(ret, x+typeManifest)
+		case t&storage.TypeJournal != 0:
+			ret = append(ret, x+typeJournal)
+		case t&storage.TypeTable != 0:
+			ret = append(ret, x+typeTable)
+		case t&storage.TypeTemp != 0:
+			ret = append(ret, x+typeTemp)
+		}
+	}
+	switch {
+	case m&ModeOpen != 0:
+		add(modeOpen)
+	case m&ModeCreate != 0:
+		add(modeCreate)
+	case m&ModeRemove != 0:
+		add(modeRemove)
+	case m&ModeRead != 0:
+		add(modeRead)
+	case m&ModeWrite != 0:
+		add(modeWrite)
+	case m&ModeSync != 0:
+		add(modeSync)
+	case m&ModeClose != 0:
+		add(modeClose)
+	}
+	return ret
+}
+
+func packFile(num uint64, t storage.FileType) uint64 {
+	if num>>(64-typeCount) != 0 {
+		panic("overflow")
+	}
+	return num<<typeCount | uint64(t)
+}
+
+func unpackFile(x uint64) (uint64, storage.FileType) {
+	return x >> typeCount, storage.FileType(x) & storage.TypeAll
+}
+
+type emulatedError struct {
+	err error
+}
+
+func (err emulatedError) Error() string {
+	return fmt.Sprintf("emulated storage error: %v", err.err)
+}
+
+type storageLock struct {
+	s *Storage
+	r util.Releaser
+}
+
+func (l storageLock) Release() {
+	l.r.Release()
+	l.s.logI("storage lock released")
+}
+
+type reader struct {
+	f *file
+	storage.Reader
+}
+
+func (r *reader) Read(p []byte) (n int, err error) {
+	err = r.f.s.emulateError(ModeRead, r.f.Type())
+	if err == nil {
+		r.f.s.stall(ModeRead, r.f.Type())
+		n, err = r.Reader.Read(p)
+	}
+	r.f.s.count(ModeRead, r.f.Type(), n)
+	if err != nil && err != io.EOF {
+		r.f.s.logI("read error, num=%d type=%v n=%d err=%v", r.f.Num(), r.f.Type(), n, err)
+	}
+	return
+}
+
+func (r *reader) ReadAt(p []byte, off int64) (n int, err error) {
+	err = r.f.s.emulateError(ModeRead, r.f.Type())
+	if err == nil {
+		r.f.s.stall(ModeRead, r.f.Type())
+		n, err = r.Reader.ReadAt(p, off)
+	}
+	r.f.s.count(ModeRead, r.f.Type(), n)
+	if err != nil && err != io.EOF {
+		r.f.s.logI("readAt error, num=%d type=%v offset=%d n=%d err=%v", r.f.Num(), r.f.Type(), off, n, err)
+	}
+	return
+}
+
+func (r *reader) Close() (err error) {
+	return r.f.doClose(r.Reader)
+}
+
+type writer struct {
+	f *file
+	storage.Writer
+}
+
+func (w *writer) Write(p []byte) (n int, err error) {
+	err = w.f.s.emulateError(ModeWrite, w.f.Type())
+	if err == nil {
+		w.f.s.stall(ModeWrite, w.f.Type())
+		n, err = w.Writer.Write(p)
+	}
+	w.f.s.count(ModeWrite, w.f.Type(), n)
+	if err != nil && err != io.EOF {
+		w.f.s.logI("write error, num=%d type=%v n=%d err=%v", w.f.Num(), w.f.Type(), n, err)
+	}
+	return
+}
+
+func (w *writer) Sync() (err error) {
+	err = w.f.s.emulateError(ModeSync, w.f.Type())
+	if err == nil {
+		w.f.s.stall(ModeSync, w.f.Type())
+		err = w.Writer.Sync()
+	}
+	w.f.s.count(ModeSync, w.f.Type(), 0)
+	if err != nil {
+		w.f.s.logI("sync error, num=%d type=%v err=%v", w.f.Num(), w.f.Type(), err)
+	}
+	return
+}
+
+func (w *writer) Close() (err error) {
+	return w.f.doClose(w.Writer)
+}
+
+type file struct {
+	s *Storage
+	storage.File
+}
+
+func (f *file) pack() uint64 {
+	return packFile(f.Num(), f.Type())
+}
+
+func (f *file) assertOpen() {
+	ExpectWithOffset(2, f.s.opens).NotTo(HaveKey(f.pack()), "File open, num=%d type=%v writer=%v", f.Num(), f.Type(), f.s.opens[f.pack()])
+}
+
+func (f *file) doClose(closer io.Closer) (err error) {
+	err = f.s.emulateError(ModeClose, f.Type())
+	if err == nil {
+		f.s.stall(ModeClose, f.Type())
+	}
+	f.s.mu.Lock()
+	defer f.s.mu.Unlock()
+	if err == nil {
+		ExpectWithOffset(2, f.s.opens).To(HaveKey(f.pack()), "File closed, num=%d type=%v", f.Num(), f.Type())
+		err = closer.Close()
+	}
+	f.s.countNB(ModeClose, f.Type(), 0)
+	writer := f.s.opens[f.pack()]
+	if err != nil {
+		f.s.logISkip(1, "file close failed, num=%d type=%v writer=%v err=%v", f.Num(), f.Type(), writer, err)
+	} else {
+		f.s.logISkip(1, "file closed, num=%d type=%v writer=%v", f.Num(), f.Type(), writer)
+		delete(f.s.opens, f.pack())
+	}
+	return
+}
+
+func (f *file) Open() (r storage.Reader, err error) {
+	err = f.s.emulateError(ModeOpen, f.Type())
+	if err == nil {
+		f.s.stall(ModeOpen, f.Type())
+	}
+	f.s.mu.Lock()
+	defer f.s.mu.Unlock()
+	if err == nil {
+		f.assertOpen()
+		f.s.countNB(ModeOpen, f.Type(), 0)
+		r, err = f.File.Open()
+	}
+	if err != nil {
+		f.s.logI("file open failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
+	} else {
+		f.s.logI("file opened, num=%d type=%v", f.Num(), f.Type())
+		f.s.opens[f.pack()] = false
+		r = &reader{f, r}
+	}
+	return
+}
+
+func (f *file) Create() (w storage.Writer, err error) {
+	err = f.s.emulateError(ModeCreate, f.Type())
+	if err == nil {
+		f.s.stall(ModeCreate, f.Type())
+	}
+	f.s.mu.Lock()
+	defer f.s.mu.Unlock()
+	if err == nil {
+		f.assertOpen()
+		f.s.countNB(ModeCreate, f.Type(), 0)
+		w, err = f.File.Create()
+	}
+	if err != nil {
+		f.s.logI("file create failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
+	} else {
+		f.s.logI("file created, num=%d type=%v", f.Num(), f.Type())
+		f.s.opens[f.pack()] = true
+		w = &writer{f, w}
+	}
+	return
+}
+
+func (f *file) Remove() (err error) {
+	err = f.s.emulateError(ModeRemove, f.Type())
+	if err == nil {
+		f.s.stall(ModeRemove, f.Type())
+	}
+	f.s.mu.Lock()
+	defer f.s.mu.Unlock()
+	if err == nil {
+		f.assertOpen()
+		f.s.countNB(ModeRemove, f.Type(), 0)
+		err = f.File.Remove()
+	}
+	if err != nil {
+		f.s.logI("file remove failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
+	} else {
+		f.s.logI("file removed, num=%d type=%v", f.Num(), f.Type())
+	}
+	return
+}
+
+type Storage struct {
+	storage.Storage
+	closeFn func() error
+
+	lmu sync.Mutex
+	lb  bytes.Buffer
+
+	mu sync.Mutex
+	// Open files, true=writer, false=reader
+	opens         map[uint64]bool
+	counters      [flattenCount]int
+	bytesCounter  [flattenCount]int64
+	emulatedError [flattenCount]error
+	stallCond     sync.Cond
+	stalled       [flattenCount]bool
+}
+
+func (s *Storage) log(skip int, str string) {
+	s.lmu.Lock()
+	defer s.lmu.Unlock()
+	_, file, line, ok := runtime.Caller(skip + 2)
+	if ok {
+		// Truncate file name at last file name separator.
+		if index := strings.LastIndex(file, "/"); index >= 0 {
+			file = file[index+1:]
+		} else if index = strings.LastIndex(file, "\\"); index >= 0 {
+			file = file[index+1:]
+		}
+	} else {
+		file = "???"
+		line = 1
+	}
+	fmt.Fprintf(&s.lb, "%s:%d: ", file, line)
+	lines := strings.Split(str, "\n")
+	if l := len(lines); l > 1 && lines[l-1] == "" {
+		lines = lines[:l-1]
+	}
+	for i, line := range lines {
+		if i > 0 {
+			s.lb.WriteString("\n\t")
+		}
+		s.lb.WriteString(line)
+	}
+	s.lb.WriteByte('\n')
+}
+
+func (s *Storage) logISkip(skip int, format string, args ...interface{}) {
+	pc, _, _, ok := runtime.Caller(skip + 1)
+	if ok {
+		if f := runtime.FuncForPC(pc); f != nil {
+			fname := f.Name()
+			if index := strings.LastIndex(fname, "."); index >= 0 {
+				fname = fname[index+1:]
+			}
+			format = fname + ": " + format
+		}
+	}
+	s.log(skip+1, fmt.Sprintf(format, args...))
+}
+
+func (s *Storage) logI(format string, args ...interface{}) {
+	s.logISkip(1, format, args...)
+}
+
+func (s *Storage) Log(str string) {
+	s.log(1, "Log: "+str)
+	s.Storage.Log(str)
+}
+
+func (s *Storage) Lock() (r util.Releaser, err error) {
+	r, err = s.Storage.Lock()
+	if err != nil {
+		s.logI("storage locking failed, err=%v", err)
+	} else {
+		s.logI("storage locked")
+		r = storageLock{s, r}
+	}
+	return
+}
+
+func (s *Storage) GetFile(num uint64, t storage.FileType) storage.File {
+	return &file{s, s.Storage.GetFile(num, t)}
+}
+
+func (s *Storage) GetFiles(t storage.FileType) (files []storage.File, err error) {
+	rfiles, err := s.Storage.GetFiles(t)
+	if err != nil {
+		s.logI("get files failed, err=%v", err)
+		return
+	}
+	files = make([]storage.File, len(rfiles))
+	for i, f := range rfiles {
+		files[i] = &file{s, f}
+	}
+	s.logI("get files, type=0x%x count=%d", int(t), len(files))
+	return
+}
+
+func (s *Storage) GetManifest() (f storage.File, err error) {
+	manifest, err := s.Storage.GetManifest()
+	if err != nil {
+		if !os.IsNotExist(err) {
+			s.logI("get manifest failed, err=%v", err)
+		}
+		return
+	}
+	s.logI("get manifest, num=%d", manifest.Num())
+	return &file{s, manifest}, nil
+}
+
+func (s *Storage) SetManifest(f storage.File) error {
+	f_, ok := f.(*file)
+	ExpectWithOffset(1, ok).To(BeTrue())
+	ExpectWithOffset(1, f_.Type()).To(Equal(storage.TypeManifest))
+	err := s.Storage.SetManifest(f_.File)
+	if err != nil {
+		s.logI("set manifest failed, err=%v", err)
+	} else {
+		s.logI("set manifest, num=%d", f_.Num())
+	}
+	return err
+}
+
+func (s *Storage) openFiles() string {
+	out := "Open files:"
+	for x, writer := range s.opens {
+		num, t := unpackFile(x)
+		out += fmt.Sprintf("\n · num=%d type=%v writer=%v", num, t, writer)
+	}
+	return out
+}
+
+func (s *Storage) Close() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	ExpectWithOffset(1, s.opens).To(BeEmpty(), s.openFiles())
+	err := s.Storage.Close()
+	if err != nil {
+		s.logI("storage closing failed, err=%v", err)
+	} else {
+		s.logI("storage closed")
+	}
+	if s.closeFn != nil {
+		if err1 := s.closeFn(); err1 != nil {
+			s.logI("close func error, err=%v", err1)
+		}
+	}
+	return err
+}
+
+func (s *Storage) countNB(m StorageMode, t storage.FileType, n int) {
+	s.counters[flattenType(m, t)]++
+	s.bytesCounter[flattenType(m, t)] += int64(n)
+}
+
+func (s *Storage) count(m StorageMode, t storage.FileType, n int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.countNB(m, t, n)
+}
+
+func (s *Storage) ResetCounter(m StorageMode, t storage.FileType) {
+	for _, x := range listFlattenType(m, t) {
+		s.counters[x] = 0
+		s.bytesCounter[x] = 0
+	}
+}
+
+func (s *Storage) Counter(m StorageMode, t storage.FileType) (count int, bytes int64) {
+	for _, x := range listFlattenType(m, t) {
+		count += s.counters[x]
+		bytes += s.bytesCounter[x]
+	}
+	return
+}
+
+func (s *Storage) emulateError(m StorageMode, t storage.FileType) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	err := s.emulatedError[flattenType(m, t)]
+	if err != nil {
+		return emulatedError{err}
+	}
+	return nil
+}
+
+func (s *Storage) EmulateError(m StorageMode, t storage.FileType, err error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for _, x := range listFlattenType(m, t) {
+		s.emulatedError[x] = err
+	}
+}
+
+func (s *Storage) stall(m StorageMode, t storage.FileType) {
+	x := flattenType(m, t)
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for s.stalled[x] {
+		s.stallCond.Wait()
+	}
+}
+
+func (s *Storage) Stall(m StorageMode, t storage.FileType) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for _, x := range listFlattenType(m, t) {
+		s.stalled[x] = true
+	}
+}
+
+func (s *Storage) Release(m StorageMode, t storage.FileType) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for _, x := range listFlattenType(m, t) {
+		s.stalled[x] = false
+	}
+	s.stallCond.Broadcast()
+}
+
+func NewStorage() *Storage {
+	var stor storage.Storage
+	var closeFn func() error
+	if storageUseFS {
+		for {
+			storageMu.Lock()
+			num := storageNum
+			storageNum++
+			storageMu.Unlock()
+			path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
+			if _, err := os.Stat(path); os.IsNotExist(err) {
+				stor, err = storage.OpenFile(path)
+				ExpectWithOffset(1, err).NotTo(HaveOccurred(), "creating storage at %s", path)
+				closeFn = func() error {
+					if storageKeepFS {
+						return nil
+					}
+					return os.RemoveAll(path)
+				}
+				break
+			}
+		}
+	} else {
+		stor = storage.NewMemStorage()
+	}
+	s := &Storage{
+		Storage: stor,
+		closeFn: closeFn,
+		opens:   make(map[uint64]bool),
+	}
+	s.stallCond.L = &s.mu
+	return s
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/testutil/util.go b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/util.go
new file mode 100644
index 00000000..97c5294b
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/testutil/util.go
@@ -0,0 +1,171 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package testutil
+
+import (
+	"bytes"
+	"flag"
+	"math/rand"
+	"reflect"
+	"sync"
+
+	"github.com/onsi/ginkgo/config"
+
+	"github.com/syndtr/goleveldb/leveldb/comparer"
+)
+
+var (
+	runfn = make(map[string][]func())
+	runmu sync.Mutex
+)
+
+func Defer(args ...interface{}) bool {
+	var (
+		group string
+		fn    func()
+	)
+	for _, arg := range args {
+		v := reflect.ValueOf(arg)
+		switch v.Kind() {
+		case reflect.String:
+			group = v.String()
+		case reflect.Func:
+			r := reflect.ValueOf(&fn).Elem()
+			r.Set(v)
+		}
+	}
+	if fn != nil {
+		runmu.Lock()
+		runfn[group] = append(runfn[group], fn)
+		runmu.Unlock()
+	}
+	return true
+}
+
+func RunDefer(groups ...string) bool {
+	if len(groups) == 0 {
+		groups = append(groups, "")
+	}
+	runmu.Lock()
+	var runfn_ []func()
+	for _, group := range groups {
+		runfn_ = append(runfn_, runfn[group]...)
+		delete(runfn, group)
+	}
+	runmu.Unlock()
+	for _, fn := range runfn_ {
+		fn()
+	}
+	return runfn_ != nil
+}
+
+func RandomSeed() int64 {
+	if !flag.Parsed() {
+		panic("random seed not initialized")
+	}
+	return config.GinkgoConfig.RandomSeed
+}
+
+func NewRand() *rand.Rand {
+	return rand.New(rand.NewSource(RandomSeed()))
+}
+
+var cmp = comparer.DefaultComparer
+
+func BytesSeparator(a, b []byte) []byte {
+	if bytes.Equal(a, b) {
+		return b
+	}
+	i, n := 0, len(a)
+	if n > len(b) {
+		n = len(b)
+	}
+	for ; i < n && (a[i] == b[i]); i++ {
+	}
+	x := append([]byte{}, a[:i]...)
+	if i < n {
+		if c := a[i] + 1; c < b[i] {
+			return append(x, c)
+		}
+		x = append(x, a[i])
+		i++
+	}
+	for ; i < len(a); i++ {
+		if c := a[i]; c < 0xff {
+			return append(x, c+1)
+		} else {
+			x = append(x, c)
+		}
+	}
+	if len(b) > i && b[i] > 0 {
+		return append(x, b[i]-1)
+	}
+	return append(x, 'x')
+}
+
+func BytesAfter(b []byte) []byte {
+	var x []byte
+	for _, c := range b {
+		if c < 0xff {
+			return append(x, c+1)
+		} else {
+			x = append(x, c)
+		}
+	}
+	return append(x, 'x')
+}
+
+func RandomIndex(rnd *rand.Rand, n, round int, fn func(i int)) {
+	if rnd == nil {
+		rnd = NewRand()
+	}
+	for x := 0; x < round; x++ {
+		fn(rnd.Intn(n))
+	}
+	return
+}
+
+func ShuffledIndex(rnd *rand.Rand, n, round int, fn func(i int)) {
+	if rnd == nil {
+		rnd = NewRand()
+	}
+	for x := 0; x < round; x++ {
+		for _, i := range rnd.Perm(n) {
+			fn(i)
+		}
+	}
+	return
+}
+
+func RandomRange(rnd *rand.Rand, n, round int, fn func(start, limit int)) {
+	if rnd == nil {
+		rnd = NewRand()
+	}
+	for x := 0; x < round; x++ {
+		start := rnd.Intn(n)
+		length := 0
+		if j := n - start; j > 0 {
+			length = rnd.Intn(j)
+		}
+		fn(start, start+length)
+	}
+	return
+}
+
+func Max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func Min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util.go b/vendor/github.com/syndtr/goleveldb/leveldb/util.go
new file mode 100644
index 00000000..1a5bf71a
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util.go
@@ -0,0 +1,91 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/syndtr/goleveldb/leveldb/storage"
+)
+
+func shorten(str string) string {
+	if len(str) <= 8 {
+		return str
+	}
+	return str[:3] + ".." + str[len(str)-3:]
+}
+
+var bunits = [...]string{"", "Ki", "Mi", "Gi"}
+
+func shortenb(bytes int) string {
+	i := 0
+	for ; bytes > 1024 && i < 4; i++ {
+		bytes /= 1024
+	}
+	return fmt.Sprintf("%d%sB", bytes, bunits[i])
+}
+
+func sshortenb(bytes int) string {
+	if bytes == 0 {
+		return "~"
+	}
+	sign := "+"
+	if bytes < 0 {
+		sign = "-"
+		bytes *= -1
+	}
+	i := 0
+	for ; bytes > 1024 && i < 4; i++ {
+		bytes /= 1024
+	}
+	return fmt.Sprintf("%s%d%sB", sign, bytes, bunits[i])
+}
+
+func sint(x int) string {
+	if x == 0 {
+		return "~"
+	}
+	sign := "+"
+	if x < 0 {
+		sign = "-"
+		x *= -1
+	}
+	return fmt.Sprintf("%s%d", sign, x)
+}
+
+func minInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func maxInt(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+type files []storage.File
+
+func (p files) Len() int {
+	return len(p)
+}
+
+func (p files) Less(i, j int) bool {
+	return p[i].Num() < p[j].Num()
+}
+
+func (p files) Swap(i, j int) {
+	p[i], p[j] = p[j], p[i]
+}
+
+func (p files) sort() {
+	sort.Sort(p)
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/buffer.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/buffer.go
new file mode 100644
index 00000000..21de2425
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/buffer.go
@@ -0,0 +1,293 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package util
+
+// This a copy of Go std bytes.Buffer with some modification
+// and some features stripped.
+
+import (
+	"bytes"
+	"io"
+)
+
+// A Buffer is a variable-sized buffer of bytes with Read and Write methods.
+// The zero value for Buffer is an empty buffer ready to use.
+type Buffer struct {
+	buf       []byte   // contents are the bytes buf[off : len(buf)]
+	off       int      // read at &buf[off], write at &buf[len(buf)]
+	bootstrap [64]byte // memory to hold first slice; helps small buffers (Printf) avoid allocation.
+}
+
+// Bytes returns a slice of the contents of the unread portion of the buffer;
+// len(b.Bytes()) == b.Len().  If the caller changes the contents of the
+// returned slice, the contents of the buffer will change provided there
+// are no intervening method calls on the Buffer.
+func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }
+
+// String returns the contents of the unread portion of the buffer
+// as a string.  If the Buffer is a nil pointer, it returns "<nil>".
+func (b *Buffer) String() string {
+	if b == nil {
+		// Special case, useful in debugging.
+		return "<nil>"
+	}
+	return string(b.buf[b.off:])
+}
+
+// Len returns the number of bytes of the unread portion of the buffer;
+// b.Len() == len(b.Bytes()).
+func (b *Buffer) Len() int { return len(b.buf) - b.off }
+
+// Truncate discards all but the first n unread bytes from the buffer.
+// It panics if n is negative or greater than the length of the buffer.
+func (b *Buffer) Truncate(n int) {
+	switch {
+	case n < 0 || n > b.Len():
+		panic("leveldb/util.Buffer: truncation out of range")
+	case n == 0:
+		// Reuse buffer space.
+		b.off = 0
+	}
+	b.buf = b.buf[0 : b.off+n]
+}
+
+// Reset resets the buffer so it has no content.
+// b.Reset() is the same as b.Truncate(0).
+func (b *Buffer) Reset() { b.Truncate(0) }
+
+// grow grows the buffer to guarantee space for n more bytes.
+// It returns the index where bytes should be written.
+// If the buffer can't grow it will panic with bytes.ErrTooLarge.
+func (b *Buffer) grow(n int) int {
+	m := b.Len()
+	// If buffer is empty, reset to recover space.
+	if m == 0 && b.off != 0 {
+		b.Truncate(0)
+	}
+	if len(b.buf)+n > cap(b.buf) {
+		var buf []byte
+		if b.buf == nil && n <= len(b.bootstrap) {
+			buf = b.bootstrap[0:]
+		} else if m+n <= cap(b.buf)/2 {
+			// We can slide things down instead of allocating a new
+			// slice. We only need m+n <= cap(b.buf) to slide, but
+			// we instead let capacity get twice as large so we
+			// don't spend all our time copying.
+			copy(b.buf[:], b.buf[b.off:])
+			buf = b.buf[:m]
+		} else {
+			// not enough space anywhere
+			buf = makeSlice(2*cap(b.buf) + n)
+			copy(buf, b.buf[b.off:])
+		}
+		b.buf = buf
+		b.off = 0
+	}
+	b.buf = b.buf[0 : b.off+m+n]
+	return b.off + m
+}
+
+// Alloc allocs n bytes of slice from the buffer, growing the buffer as
+// needed. If n is negative, Alloc will panic.
+// If the buffer can't grow it will panic with bytes.ErrTooLarge.
+func (b *Buffer) Alloc(n int) []byte {
+	if n < 0 {
+		panic("leveldb/util.Buffer.Alloc: negative count")
+	}
+	m := b.grow(n)
+	return b.buf[m:]
+}
+
+// Grow grows the buffer's capacity, if necessary, to guarantee space for
+// another n bytes. After Grow(n), at least n bytes can be written to the
+// buffer without another allocation.
+// If n is negative, Grow will panic.
+// If the buffer can't grow it will panic with bytes.ErrTooLarge.
+func (b *Buffer) Grow(n int) {
+	if n < 0 {
+		panic("leveldb/util.Buffer.Grow: negative count")
+	}
+	m := b.grow(n)
+	b.buf = b.buf[0:m]
+}
+
+// Write appends the contents of p to the buffer, growing the buffer as
+// needed. The return value n is the length of p; err is always nil. If the
+// buffer becomes too large, Write will panic with bytes.ErrTooLarge.
+func (b *Buffer) Write(p []byte) (n int, err error) {
+	m := b.grow(len(p))
+	return copy(b.buf[m:], p), nil
+}
+
+// MinRead is the minimum slice size passed to a Read call by
+// Buffer.ReadFrom.  As long as the Buffer has at least MinRead bytes beyond
+// what is required to hold the contents of r, ReadFrom will not grow the
+// underlying buffer.
+const MinRead = 512
+
+// ReadFrom reads data from r until EOF and appends it to the buffer, growing
+// the buffer as needed. The return value n is the number of bytes read. Any
+// error except io.EOF encountered during the read is also returned. If the
+// buffer becomes too large, ReadFrom will panic with bytes.ErrTooLarge.
+func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
+	// If buffer is empty, reset to recover space.
+	if b.off >= len(b.buf) {
+		b.Truncate(0)
+	}
+	for {
+		if free := cap(b.buf) - len(b.buf); free < MinRead {
+			// not enough space at end
+			newBuf := b.buf
+			if b.off+free < MinRead {
+				// not enough space using beginning of buffer;
+				// double buffer capacity
+				newBuf = makeSlice(2*cap(b.buf) + MinRead)
+			}
+			copy(newBuf, b.buf[b.off:])
+			b.buf = newBuf[:len(b.buf)-b.off]
+			b.off = 0
+		}
+		m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
+		b.buf = b.buf[0 : len(b.buf)+m]
+		n += int64(m)
+		if e == io.EOF {
+			break
+		}
+		if e != nil {
+			return n, e
+		}
+	}
+	return n, nil // err is EOF, so return nil explicitly
+}
+
+// makeSlice allocates a slice of size n. If the allocation fails, it panics
+// with bytes.ErrTooLarge.
+func makeSlice(n int) []byte {
+	// If the make fails, give a known error.
+	defer func() {
+		if recover() != nil {
+			panic(bytes.ErrTooLarge)
+		}
+	}()
+	return make([]byte, n)
+}
+
+// WriteTo writes data to w until the buffer is drained or an error occurs.
+// The return value n is the number of bytes written; it always fits into an
+// int, but it is int64 to match the io.WriterTo interface. Any error
+// encountered during the write is also returned.
+func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) {
+	if b.off < len(b.buf) {
+		nBytes := b.Len()
+		m, e := w.Write(b.buf[b.off:])
+		if m > nBytes {
+			panic("leveldb/util.Buffer.WriteTo: invalid Write count")
+		}
+		b.off += m
+		n = int64(m)
+		if e != nil {
+			return n, e
+		}
+		// all bytes should have been written, by definition of
+		// Write method in io.Writer
+		if m != nBytes {
+			return n, io.ErrShortWrite
+		}
+	}
+	// Buffer is now empty; reset.
+	b.Truncate(0)
+	return
+}
+
+// WriteByte appends the byte c to the buffer, growing the buffer as needed.
+// The returned error is always nil, but is included to match bufio.Writer's
+// WriteByte. If the buffer becomes too large, WriteByte will panic with
+// bytes.ErrTooLarge.
+func (b *Buffer) WriteByte(c byte) error {
+	m := b.grow(1)
+	b.buf[m] = c
+	return nil
+}
+
+// Read reads the next len(p) bytes from the buffer or until the buffer
+// is drained.  The return value n is the number of bytes read.  If the
+// buffer has no data to return, err is io.EOF (unless len(p) is zero);
+// otherwise it is nil.
+func (b *Buffer) Read(p []byte) (n int, err error) {
+	if b.off >= len(b.buf) {
+		// Buffer is empty, reset to recover space.
+		b.Truncate(0)
+		if len(p) == 0 {
+			return
+		}
+		return 0, io.EOF
+	}
+	n = copy(p, b.buf[b.off:])
+	b.off += n
+	return
+}
+
+// Next returns a slice containing the next n bytes from the buffer,
+// advancing the buffer as if the bytes had been returned by Read.
+// If there are fewer than n bytes in the buffer, Next returns the entire buffer.
+// The slice is only valid until the next call to a read or write method.
+func (b *Buffer) Next(n int) []byte {
+	m := b.Len()
+	if n > m {
+		n = m
+	}
+	data := b.buf[b.off : b.off+n]
+	b.off += n
+	return data
+}
+
+// ReadByte reads and returns the next byte from the buffer.
+// If no byte is available, it returns error io.EOF.
+func (b *Buffer) ReadByte() (c byte, err error) {
+	if b.off >= len(b.buf) {
+		// Buffer is empty, reset to recover space.
+		b.Truncate(0)
+		return 0, io.EOF
+	}
+	c = b.buf[b.off]
+	b.off++
+	return c, nil
+}
+
+// ReadBytes reads until the first occurrence of delim in the input,
+// returning a slice containing the data up to and including the delimiter.
+// If ReadBytes encounters an error before finding a delimiter,
+// it returns the data read before the error and the error itself (often io.EOF).
+// ReadBytes returns err != nil if and only if the returned data does not end in
+// delim.
+func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) {
+	slice, err := b.readSlice(delim)
+	// return a copy of slice. The buffer's backing array may
+	// be overwritten by later calls.
+	line = append(line, slice...)
+	return
+}
+
+// readSlice is like ReadBytes but returns a reference to internal buffer data.
+func (b *Buffer) readSlice(delim byte) (line []byte, err error) {
+	i := bytes.IndexByte(b.buf[b.off:], delim)
+	end := b.off + i + 1
+	if i < 0 {
+		end = len(b.buf)
+		err = io.EOF
+	}
+	line = b.buf[b.off:end]
+	b.off = end
+	return line, err
+}
+
+// NewBuffer creates and initializes a new Buffer using buf as its initial
+// contents.  It is intended to prepare a Buffer to read existing data.  It
+// can also be used to size the internal buffer for writing. To do that,
+// buf should have the desired capacity but a length of zero.
+//
+// In most cases, new(Buffer) (or just declaring a Buffer variable) is
+// sufficient to initialize a Buffer.
+func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/buffer_pool.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/buffer_pool.go
new file mode 100644
index 00000000..2b8453d7
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/buffer_pool.go
@@ -0,0 +1,238 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+type buffer struct {
+	b    []byte
+	miss int
+}
+
+// BufferPool is a 'buffer pool'.
+type BufferPool struct {
+	pool      [6]chan []byte
+	size      [5]uint32
+	sizeMiss  [5]uint32
+	sizeHalf  [5]uint32
+	baseline  [4]int
+	baseline0 int
+
+	mu     sync.RWMutex
+	closed bool
+	closeC chan struct{}
+
+	get     uint32
+	put     uint32
+	half    uint32
+	less    uint32
+	equal   uint32
+	greater uint32
+	miss    uint32
+}
+
+func (p *BufferPool) poolNum(n int) int {
+	if n <= p.baseline0 && n > p.baseline0/2 {
+		return 0
+	}
+	for i, x := range p.baseline {
+		if n <= x {
+			return i + 1
+		}
+	}
+	return len(p.baseline) + 1
+}
+
+// Get returns buffer with length of n.
+func (p *BufferPool) Get(n int) []byte {
+	if p == nil {
+		return make([]byte, n)
+	}
+
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	if p.closed {
+		return make([]byte, n)
+	}
+
+	atomic.AddUint32(&p.get, 1)
+
+	poolNum := p.poolNum(n)
+	pool := p.pool[poolNum]
+	if poolNum == 0 {
+		// Fast path.
+		select {
+		case b := <-pool:
+			switch {
+			case cap(b) > n:
+				if cap(b)-n >= n {
+					atomic.AddUint32(&p.half, 1)
+					select {
+					case pool <- b:
+					default:
+					}
+					return make([]byte, n)
+				} else {
+					atomic.AddUint32(&p.less, 1)
+					return b[:n]
+				}
+			case cap(b) == n:
+				atomic.AddUint32(&p.equal, 1)
+				return b[:n]
+			default:
+				atomic.AddUint32(&p.greater, 1)
+			}
+		default:
+			atomic.AddUint32(&p.miss, 1)
+		}
+
+		return make([]byte, n, p.baseline0)
+	} else {
+		sizePtr := &p.size[poolNum-1]
+
+		select {
+		case b := <-pool:
+			switch {
+			case cap(b) > n:
+				if cap(b)-n >= n {
+					atomic.AddUint32(&p.half, 1)
+					sizeHalfPtr := &p.sizeHalf[poolNum-1]
+					if atomic.AddUint32(sizeHalfPtr, 1) == 20 {
+						atomic.StoreUint32(sizePtr, uint32(cap(b)/2))
+						atomic.StoreUint32(sizeHalfPtr, 0)
+					} else {
+						select {
+						case pool <- b:
+						default:
+						}
+					}
+					return make([]byte, n)
+				} else {
+					atomic.AddUint32(&p.less, 1)
+					return b[:n]
+				}
+			case cap(b) == n:
+				atomic.AddUint32(&p.equal, 1)
+				return b[:n]
+			default:
+				atomic.AddUint32(&p.greater, 1)
+				if uint32(cap(b)) >= atomic.LoadUint32(sizePtr) {
+					select {
+					case pool <- b:
+					default:
+					}
+				}
+			}
+		default:
+			atomic.AddUint32(&p.miss, 1)
+		}
+
+		if size := atomic.LoadUint32(sizePtr); uint32(n) > size {
+			if size == 0 {
+				atomic.CompareAndSwapUint32(sizePtr, 0, uint32(n))
+			} else {
+				sizeMissPtr := &p.sizeMiss[poolNum-1]
+				if atomic.AddUint32(sizeMissPtr, 1) == 20 {
+					atomic.StoreUint32(sizePtr, uint32(n))
+					atomic.StoreUint32(sizeMissPtr, 0)
+				}
+			}
+			return make([]byte, n)
+		} else {
+			return make([]byte, n, size)
+		}
+	}
+}
+
+// Put adds given buffer to the pool.
+func (p *BufferPool) Put(b []byte) {
+	if p == nil {
+		return
+	}
+
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	if p.closed {
+		return
+	}
+
+	atomic.AddUint32(&p.put, 1)
+
+	pool := p.pool[p.poolNum(cap(b))]
+	select {
+	case pool <- b:
+	default:
+	}
+
+}
+
+func (p *BufferPool) Close() {
+	if p == nil {
+		return
+	}
+
+	p.mu.Lock()
+	if !p.closed {
+		p.closed = true
+		p.closeC <- struct{}{}
+	}
+	p.mu.Unlock()
+}
+
+func (p *BufferPool) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+
+	return fmt.Sprintf("BufferPool{B·%d Z·%v Zm·%v Zh·%v G·%d P·%d H·%d <·%d =·%d >·%d M·%d}",
+		p.baseline0, p.size, p.sizeMiss, p.sizeHalf, p.get, p.put, p.half, p.less, p.equal, p.greater, p.miss)
+}
+
+func (p *BufferPool) drain() {
+	ticker := time.NewTicker(2 * time.Second)
+	for {
+		select {
+		case <-ticker.C:
+			for _, ch := range p.pool {
+				select {
+				case <-ch:
+				default:
+				}
+			}
+		case <-p.closeC:
+			close(p.closeC)
+			for _, ch := range p.pool {
+				close(ch)
+			}
+			return
+		}
+	}
+}
+
+// NewBufferPool creates a new initialized 'buffer pool'.
+func NewBufferPool(baseline int) *BufferPool {
+	if baseline <= 0 {
+		panic("baseline can't be <= 0")
+	}
+	p := &BufferPool{
+		baseline0: baseline,
+		baseline:  [...]int{baseline / 4, baseline / 2, baseline * 2, baseline * 4},
+		closeC:    make(chan struct{}, 1),
+	}
+	for i, cap := range []int{2, 2, 4, 4, 2, 1} {
+		p.pool[i] = make(chan []byte, cap)
+	}
+	go p.drain()
+	return p
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/crc32.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/crc32.go
new file mode 100644
index 00000000..631c9d61
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/crc32.go
@@ -0,0 +1,30 @@
+// Copyright 2011 The LevelDB-Go Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+import (
+	"hash/crc32"
+)
+
+var table = crc32.MakeTable(crc32.Castagnoli)
+
+// CRC is a CRC-32 checksum computed using Castagnoli's polynomial.
+type CRC uint32
+
+// NewCRC creates a new crc based on the given bytes.
+func NewCRC(b []byte) CRC {
+	return CRC(0).Update(b)
+}
+
+// Update updates the crc with the given bytes.
+func (c CRC) Update(b []byte) CRC {
+	return CRC(crc32.Update(uint32(c), table, b))
+}
+
+// Value returns a masked crc.
+func (c CRC) Value() uint32 {
+	return uint32(c>>15|c<<17) + 0xa282ead8
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/hash.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/hash.go
new file mode 100644
index 00000000..54903660
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/hash.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+// Hash return hash of the given data.
+func Hash(data []byte, seed uint32) uint32 {
+	// Similar to murmur hash
+	var m uint32 = 0xc6a4a793
+	var r uint32 = 24
+	h := seed ^ (uint32(len(data)) * m)
+
+	buf := bytes.NewBuffer(data)
+	for buf.Len() >= 4 {
+		var w uint32
+		binary.Read(buf, binary.LittleEndian, &w)
+		h += w
+		h *= m
+		h ^= (h >> 16)
+	}
+
+	rest := buf.Bytes()
+	switch len(rest) {
+	default:
+		panic("not reached")
+	case 3:
+		h += uint32(rest[2]) << 16
+		fallthrough
+	case 2:
+		h += uint32(rest[1]) << 8
+		fallthrough
+	case 1:
+		h += uint32(rest[0])
+		h *= m
+		h ^= (h >> r)
+	case 0:
+	}
+
+	return h
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/pool.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/pool.go
new file mode 100644
index 00000000..1f7fdd41
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/pool.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// 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.3
+
+package util
+
+import (
+	"sync"
+)
+
+type Pool struct {
+	sync.Pool
+}
+
+func NewPool(cap int) *Pool {
+	return &Pool{}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/pool_legacy.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/pool_legacy.go
new file mode 100644
index 00000000..27b8d03b
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/pool_legacy.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// 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.3
+
+package util
+
+type Pool struct {
+	pool chan interface{}
+}
+
+func (p *Pool) Get() interface{} {
+	select {
+	case x := <-p.pool:
+		return x
+	default:
+		return nil
+	}
+}
+
+func (p *Pool) Put(x interface{}) {
+	select {
+	case p.pool <- x:
+	default:
+	}
+}
+
+func NewPool(cap int) *Pool {
+	return &Pool{pool: make(chan interface{}, cap)}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/range.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/range.go
new file mode 100644
index 00000000..85159583
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/range.go
@@ -0,0 +1,32 @@
+// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package util
+
+// Range is a key range.
+type Range struct {
+	// Start of the key range, include in the range.
+	Start []byte
+
+	// Limit of the key range, not include in the range.
+	Limit []byte
+}
+
+// BytesPrefix returns key range that satisfy the given prefix.
+// This only applicable for the standard 'bytes comparer'.
+func BytesPrefix(prefix []byte) *Range {
+	var limit []byte
+	for i := len(prefix) - 1; i >= 0; i-- {
+		c := prefix[i]
+		if c < 0xff {
+			limit = make([]byte, i+1)
+			copy(limit, prefix)
+			limit[i] = c + 1
+			break
+		}
+	}
+	return &Range{prefix, limit}
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go
new file mode 100644
index 00000000..f3597686
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Package util provides utilities used throughout leveldb.
+package util
+
+import (
+	"errors"
+)
+
+var (
+	ErrReleased    = errors.New("leveldb: resource already relesed")
+	ErrHasReleaser = errors.New("leveldb: releaser already defined")
+)
+
+// Releaser is the interface that wraps the basic Release method.
+type Releaser interface {
+	// Release releases associated resources. Release should always success
+	// and can be called multipe times without causing error.
+	Release()
+}
+
+// ReleaseSetter is the interface that wraps the basic SetReleaser method.
+type ReleaseSetter interface {
+	// SetReleaser associates the given releaser to the resources. The
+	// releaser will be called once coresponding resources released.
+	// Calling SetReleaser with nil will clear the releaser.
+	//
+	// This will panic if a releaser already present or coresponding
+	// resource is already released. Releaser should be cleared first
+	// before assigned a new one.
+	SetReleaser(releaser Releaser)
+}
+
+// BasicReleaser provides basic implementation of Releaser and ReleaseSetter.
+type BasicReleaser struct {
+	releaser Releaser
+	released bool
+}
+
+// Released returns whether Release method already called.
+func (r *BasicReleaser) Released() bool {
+	return r.released
+}
+
+// Release implements Releaser.Release.
+func (r *BasicReleaser) Release() {
+	if !r.released {
+		if r.releaser != nil {
+			r.releaser.Release()
+			r.releaser = nil
+		}
+		r.released = true
+	}
+}
+
+// SetReleaser implements ReleaseSetter.SetReleaser.
+func (r *BasicReleaser) SetReleaser(releaser Releaser) {
+	if r.released {
+		panic(ErrReleased)
+	}
+	if r.releaser != nil && releaser != nil {
+		panic(ErrHasReleaser)
+	}
+	r.releaser = releaser
+}
+
+type NoopReleaser struct{}
+
+func (NoopReleaser) Release() {}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/version.go b/vendor/github.com/syndtr/goleveldb/leveldb/version.go
new file mode 100644
index 00000000..011d982d
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/version.go
@@ -0,0 +1,457 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package leveldb
+
+import (
+	"sync/atomic"
+	"unsafe"
+
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type tSet struct {
+	level int
+	table *tFile
+}
+
+type version struct {
+	s *session
+
+	tables []tFiles
+
+	// Level that should be compacted next and its compaction score.
+	// Score < 1 means compaction is not strictly needed. These fields
+	// are initialized by computeCompaction()
+	cLevel int
+	cScore float64
+
+	cSeek unsafe.Pointer
+
+	ref int
+	// Succeeding version.
+	next *version
+}
+
+func newVersion(s *session) *version {
+	return &version{s: s, tables: make([]tFiles, s.o.GetNumLevel())}
+}
+
+func (v *version) releaseNB() {
+	v.ref--
+	if v.ref > 0 {
+		return
+	}
+	if v.ref < 0 {
+		panic("negative version ref")
+	}
+
+	tables := make(map[uint64]bool)
+	for _, tt := range v.next.tables {
+		for _, t := range tt {
+			num := t.file.Num()
+			tables[num] = true
+		}
+	}
+
+	for _, tt := range v.tables {
+		for _, t := range tt {
+			num := t.file.Num()
+			if _, ok := tables[num]; !ok {
+				v.s.tops.remove(t)
+			}
+		}
+	}
+
+	v.next.releaseNB()
+	v.next = nil
+}
+
+func (v *version) release() {
+	v.s.vmu.Lock()
+	v.releaseNB()
+	v.s.vmu.Unlock()
+}
+
+func (v *version) walkOverlapping(ikey iKey, f func(level int, t *tFile) bool, lf func(level int) bool) {
+	ukey := ikey.ukey()
+
+	// Walk tables level-by-level.
+	for level, tables := range v.tables {
+		if len(tables) == 0 {
+			continue
+		}
+
+		if level == 0 {
+			// Level-0 files may overlap each other. Find all files that
+			// overlap ukey.
+			for _, t := range tables {
+				if t.overlaps(v.s.icmp, ukey, ukey) {
+					if !f(level, t) {
+						return
+					}
+				}
+			}
+		} else {
+			if i := tables.searchMax(v.s.icmp, ikey); i < len(tables) {
+				t := tables[i]
+				if v.s.icmp.uCompare(ukey, t.imin.ukey()) >= 0 {
+					if !f(level, t) {
+						return
+					}
+				}
+			}
+		}
+
+		if lf != nil && !lf(level) {
+			return
+		}
+	}
+}
+
+func (v *version) get(ikey iKey, ro *opt.ReadOptions, noValue bool) (value []byte, tcomp bool, err error) {
+	ukey := ikey.ukey()
+
+	var (
+		tset  *tSet
+		tseek bool
+
+		// Level-0.
+		zfound bool
+		zseq   uint64
+		zkt    kType
+		zval   []byte
+	)
+
+	err = ErrNotFound
+
+	// Since entries never hope across level, finding key/value
+	// in smaller level make later levels irrelevant.
+	v.walkOverlapping(ikey, func(level int, t *tFile) bool {
+		if !tseek {
+			if tset == nil {
+				tset = &tSet{level, t}
+			} else {
+				tseek = true
+			}
+		}
+
+		var (
+			fikey, fval []byte
+			ferr        error
+		)
+		if noValue {
+			fikey, ferr = v.s.tops.findKey(t, ikey, ro)
+		} else {
+			fikey, fval, ferr = v.s.tops.find(t, ikey, ro)
+		}
+		switch ferr {
+		case nil:
+		case ErrNotFound:
+			return true
+		default:
+			err = ferr
+			return false
+		}
+
+		if fukey, fseq, fkt, fkerr := parseIkey(fikey); fkerr == nil {
+			if v.s.icmp.uCompare(ukey, fukey) == 0 {
+				if level == 0 {
+					if fseq >= zseq {
+						zfound = true
+						zseq = fseq
+						zkt = fkt
+						zval = fval
+					}
+				} else {
+					switch fkt {
+					case ktVal:
+						value = fval
+						err = nil
+					case ktDel:
+					default:
+						panic("leveldb: invalid iKey type")
+					}
+					return false
+				}
+			}
+		} else {
+			err = fkerr
+			return false
+		}
+
+		return true
+	}, func(level int) bool {
+		if zfound {
+			switch zkt {
+			case ktVal:
+				value = zval
+				err = nil
+			case ktDel:
+			default:
+				panic("leveldb: invalid iKey type")
+			}
+			return false
+		}
+
+		return true
+	})
+
+	if tseek && tset.table.consumeSeek() <= 0 {
+		tcomp = atomic.CompareAndSwapPointer(&v.cSeek, nil, unsafe.Pointer(tset))
+	}
+
+	return
+}
+
+func (v *version) sampleSeek(ikey iKey) (tcomp bool) {
+	var tset *tSet
+
+	v.walkOverlapping(ikey, func(level int, t *tFile) bool {
+		if tset == nil {
+			tset = &tSet{level, t}
+			return true
+		} else {
+			if tset.table.consumeSeek() <= 0 {
+				tcomp = atomic.CompareAndSwapPointer(&v.cSeek, nil, unsafe.Pointer(tset))
+			}
+			return false
+		}
+	}, nil)
+
+	return
+}
+
+func (v *version) getIterators(slice *util.Range, ro *opt.ReadOptions) (its []iterator.Iterator) {
+	// Merge all level zero files together since they may overlap
+	for _, t := range v.tables[0] {
+		it := v.s.tops.newIterator(t, slice, ro)
+		its = append(its, it)
+	}
+
+	strict := opt.GetStrict(v.s.o.Options, ro, opt.StrictReader)
+	for _, tables := range v.tables[1:] {
+		if len(tables) == 0 {
+			continue
+		}
+
+		it := iterator.NewIndexedIterator(tables.newIndexIterator(v.s.tops, v.s.icmp, slice, ro), strict)
+		its = append(its, it)
+	}
+
+	return
+}
+
+func (v *version) newStaging() *versionStaging {
+	return &versionStaging{base: v, tables: make([]tablesScratch, v.s.o.GetNumLevel())}
+}
+
+// Spawn a new version based on this version.
+func (v *version) spawn(r *sessionRecord) *version {
+	staging := v.newStaging()
+	staging.commit(r)
+	return staging.finish()
+}
+
+func (v *version) fillRecord(r *sessionRecord) {
+	for level, ts := range v.tables {
+		for _, t := range ts {
+			r.addTableFile(level, t)
+		}
+	}
+}
+
+func (v *version) tLen(level int) int {
+	return len(v.tables[level])
+}
+
+func (v *version) offsetOf(ikey iKey) (n uint64, err error) {
+	for level, tables := range v.tables {
+		for _, t := range tables {
+			if v.s.icmp.Compare(t.imax, ikey) <= 0 {
+				// Entire file is before "ikey", so just add the file size
+				n += t.size
+			} else if v.s.icmp.Compare(t.imin, ikey) > 0 {
+				// Entire file is after "ikey", so ignore
+				if level > 0 {
+					// Files other than level 0 are sorted by meta->min, so
+					// no further files in this level will contain data for
+					// "ikey".
+					break
+				}
+			} else {
+				// "ikey" falls in the range for this table. Add the
+				// approximate offset of "ikey" within the table.
+				var nn uint64
+				nn, err = v.s.tops.offsetOf(t, ikey)
+				if err != nil {
+					return 0, err
+				}
+				n += nn
+			}
+		}
+	}
+
+	return
+}
+
+func (v *version) pickMemdbLevel(umin, umax []byte) (level int) {
+	if !v.tables[0].overlaps(v.s.icmp, umin, umax, true) {
+		var overlaps tFiles
+		maxLevel := v.s.o.GetMaxMemCompationLevel()
+		for ; level < maxLevel; level++ {
+			if v.tables[level+1].overlaps(v.s.icmp, umin, umax, false) {
+				break
+			}
+			overlaps = v.tables[level+2].getOverlaps(overlaps, v.s.icmp, umin, umax, false)
+			if overlaps.size() > uint64(v.s.o.GetCompactionGPOverlaps(level)) {
+				break
+			}
+		}
+	}
+
+	return
+}
+
+func (v *version) computeCompaction() {
+	// Precomputed best level for next compaction
+	var bestLevel int = -1
+	var bestScore float64 = -1
+
+	for level, tables := range v.tables {
+		var score float64
+		if level == 0 {
+			// We treat level-0 specially by bounding the number of files
+			// instead of number of bytes for two reasons:
+			//
+			// (1) With larger write-buffer sizes, it is nice not to do too
+			// many level-0 compactions.
+			//
+			// (2) The files in level-0 are merged on every read and
+			// therefore we wish to avoid too many files when the individual
+			// file size is small (perhaps because of a small write-buffer
+			// setting, or very high compression ratios, or lots of
+			// overwrites/deletions).
+			score = float64(len(tables)) / float64(v.s.o.GetCompactionL0Trigger())
+		} else {
+			score = float64(tables.size()) / float64(v.s.o.GetCompactionTotalSize(level))
+		}
+
+		if score > bestScore {
+			bestLevel = level
+			bestScore = score
+		}
+	}
+
+	v.cLevel = bestLevel
+	v.cScore = bestScore
+}
+
+func (v *version) needCompaction() bool {
+	return v.cScore >= 1 || atomic.LoadPointer(&v.cSeek) != nil
+}
+
+type tablesScratch struct {
+	added   map[uint64]atRecord
+	deleted map[uint64]struct{}
+}
+
+type versionStaging struct {
+	base   *version
+	tables []tablesScratch
+}
+
+func (p *versionStaging) commit(r *sessionRecord) {
+	// Deleted tables.
+	for _, r := range r.deletedTables {
+		tm := &(p.tables[r.level])
+
+		if len(p.base.tables[r.level]) > 0 {
+			if tm.deleted == nil {
+				tm.deleted = make(map[uint64]struct{})
+			}
+			tm.deleted[r.num] = struct{}{}
+		}
+
+		if tm.added != nil {
+			delete(tm.added, r.num)
+		}
+	}
+
+	// New tables.
+	for _, r := range r.addedTables {
+		tm := &(p.tables[r.level])
+
+		if tm.added == nil {
+			tm.added = make(map[uint64]atRecord)
+		}
+		tm.added[r.num] = r
+
+		if tm.deleted != nil {
+			delete(tm.deleted, r.num)
+		}
+	}
+}
+
+func (p *versionStaging) finish() *version {
+	// Build new version.
+	nv := newVersion(p.base.s)
+	for level, tm := range p.tables {
+		btables := p.base.tables[level]
+
+		n := len(btables) + len(tm.added) - len(tm.deleted)
+		if n < 0 {
+			n = 0
+		}
+		nt := make(tFiles, 0, n)
+
+		// Base tables.
+		for _, t := range btables {
+			if _, ok := tm.deleted[t.file.Num()]; ok {
+				continue
+			}
+			if _, ok := tm.added[t.file.Num()]; ok {
+				continue
+			}
+			nt = append(nt, t)
+		}
+
+		// New tables.
+		for _, r := range tm.added {
+			nt = append(nt, p.base.s.tableFileFromRecord(r))
+		}
+
+		// Sort tables.
+		if level == 0 {
+			nt.sortByNum()
+		} else {
+			nt.sortByKey(p.base.s.icmp)
+		}
+		nv.tables[level] = nt
+	}
+
+	// Compute compaction score for new version.
+	nv.computeCompaction()
+
+	return nv
+}
+
+type versionReleaser struct {
+	v    *version
+	once bool
+}
+
+func (vr *versionReleaser) Release() {
+	v := vr.v
+	v.s.vmu.Lock()
+	if !vr.once {
+		v.releaseNB()
+		vr.once = true
+	}
+	v.s.vmu.Unlock()
+}
diff --git a/vendor/github.com/syndtr/gosnappy/snappy/decode.go b/vendor/github.com/syndtr/gosnappy/snappy/decode.go
new file mode 100644
index 00000000..552a17bf
--- /dev/null
+++ b/vendor/github.com/syndtr/gosnappy/snappy/decode.go
@@ -0,0 +1,292 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+)
+
+var (
+	// ErrCorrupt reports that the input is invalid.
+	ErrCorrupt = errors.New("snappy: corrupt input")
+	// ErrUnsupported reports that the input isn't supported.
+	ErrUnsupported = errors.New("snappy: unsupported input")
+)
+
+// DecodedLen returns the length of the decoded block.
+func DecodedLen(src []byte) (int, error) {
+	v, _, err := decodedLen(src)
+	return v, err
+}
+
+// decodedLen returns the length of the decoded block and the number of bytes
+// that the length header occupied.
+func decodedLen(src []byte) (blockLen, headerLen int, err error) {
+	v, n := binary.Uvarint(src)
+	if n == 0 {
+		return 0, 0, ErrCorrupt
+	}
+	if uint64(int(v)) != v {
+		return 0, 0, errors.New("snappy: decoded block is too large")
+	}
+	return int(v), n, nil
+}
+
+// Decode returns the decoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire decoded block.
+// Otherwise, a newly allocated slice will be returned.
+// It is valid to pass a nil dst.
+func Decode(dst, src []byte) ([]byte, error) {
+	dLen, s, err := decodedLen(src)
+	if err != nil {
+		return nil, err
+	}
+	if len(dst) < dLen {
+		dst = make([]byte, dLen)
+	}
+
+	var d, offset, length int
+	for s < len(src) {
+		switch src[s] & 0x03 {
+		case tagLiteral:
+			x := uint(src[s] >> 2)
+			switch {
+			case x < 60:
+				s += 1
+			case x == 60:
+				s += 2
+				if s > len(src) {
+					return nil, ErrCorrupt
+				}
+				x = uint(src[s-1])
+			case x == 61:
+				s += 3
+				if s > len(src) {
+					return nil, ErrCorrupt
+				}
+				x = uint(src[s-2]) | uint(src[s-1])<<8
+			case x == 62:
+				s += 4
+				if s > len(src) {
+					return nil, ErrCorrupt
+				}
+				x = uint(src[s-3]) | uint(src[s-2])<<8 | uint(src[s-1])<<16
+			case x == 63:
+				s += 5
+				if s > len(src) {
+					return nil, ErrCorrupt
+				}
+				x = uint(src[s-4]) | uint(src[s-3])<<8 | uint(src[s-2])<<16 | uint(src[s-1])<<24
+			}
+			length = int(x + 1)
+			if length <= 0 {
+				return nil, errors.New("snappy: unsupported literal length")
+			}
+			if length > len(dst)-d || length > len(src)-s {
+				return nil, ErrCorrupt
+			}
+			copy(dst[d:], src[s:s+length])
+			d += length
+			s += length
+			continue
+
+		case tagCopy1:
+			s += 2
+			if s > len(src) {
+				return nil, ErrCorrupt
+			}
+			length = 4 + int(src[s-2])>>2&0x7
+			offset = int(src[s-2])&0xe0<<3 | int(src[s-1])
+
+		case tagCopy2:
+			s += 3
+			if s > len(src) {
+				return nil, ErrCorrupt
+			}
+			length = 1 + int(src[s-3])>>2
+			offset = int(src[s-2]) | int(src[s-1])<<8
+
+		case tagCopy4:
+			return nil, errors.New("snappy: unsupported COPY_4 tag")
+		}
+
+		end := d + length
+		if offset > d || end > len(dst) {
+			return nil, ErrCorrupt
+		}
+		for ; d < end; d++ {
+			dst[d] = dst[d-offset]
+		}
+	}
+	if d != dLen {
+		return nil, ErrCorrupt
+	}
+	return dst[:d], nil
+}
+
+// NewReader returns a new Reader that decompresses from r, using the framing
+// format described at
+// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+func NewReader(r io.Reader) *Reader {
+	return &Reader{
+		r:       r,
+		decoded: make([]byte, maxUncompressedChunkLen),
+		buf:     make([]byte, MaxEncodedLen(maxUncompressedChunkLen)+checksumSize),
+	}
+}
+
+// Reader is an io.Reader than can read Snappy-compressed bytes.
+type Reader struct {
+	r       io.Reader
+	err     error
+	decoded []byte
+	buf     []byte
+	// decoded[i:j] contains decoded bytes that have not yet been passed on.
+	i, j       int
+	readHeader bool
+}
+
+// Reset discards any buffered data, resets all state, and switches the Snappy
+// reader to read from r. This permits reusing a Reader rather than allocating
+// a new one.
+func (r *Reader) Reset(reader io.Reader) {
+	r.r = reader
+	r.err = nil
+	r.i = 0
+	r.j = 0
+	r.readHeader = false
+}
+
+func (r *Reader) readFull(p []byte) (ok bool) {
+	if _, r.err = io.ReadFull(r.r, p); r.err != nil {
+		if r.err == io.ErrUnexpectedEOF {
+			r.err = ErrCorrupt
+		}
+		return false
+	}
+	return true
+}
+
+// Read satisfies the io.Reader interface.
+func (r *Reader) Read(p []byte) (int, error) {
+	if r.err != nil {
+		return 0, r.err
+	}
+	for {
+		if r.i < r.j {
+			n := copy(p, r.decoded[r.i:r.j])
+			r.i += n
+			return n, nil
+		}
+		if !r.readFull(r.buf[:4]) {
+			return 0, r.err
+		}
+		chunkType := r.buf[0]
+		if !r.readHeader {
+			if chunkType != chunkTypeStreamIdentifier {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			r.readHeader = true
+		}
+		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
+		if chunkLen > len(r.buf) {
+			r.err = ErrUnsupported
+			return 0, r.err
+		}
+
+		// The chunk types are specified at
+		// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+		switch chunkType {
+		case chunkTypeCompressedData:
+			// Section 4.2. Compressed data (chunk type 0x00).
+			if chunkLen < checksumSize {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			buf := r.buf[:chunkLen]
+			if !r.readFull(buf) {
+				return 0, r.err
+			}
+			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+			buf = buf[checksumSize:]
+
+			n, err := DecodedLen(buf)
+			if err != nil {
+				r.err = err
+				return 0, r.err
+			}
+			if n > len(r.decoded) {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			if _, err := Decode(r.decoded, buf); err != nil {
+				r.err = err
+				return 0, r.err
+			}
+			if crc(r.decoded[:n]) != checksum {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			r.i, r.j = 0, n
+			continue
+
+		case chunkTypeUncompressedData:
+			// Section 4.3. Uncompressed data (chunk type 0x01).
+			if chunkLen < checksumSize {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			buf := r.buf[:checksumSize]
+			if !r.readFull(buf) {
+				return 0, r.err
+			}
+			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+			// Read directly into r.decoded instead of via r.buf.
+			n := chunkLen - checksumSize
+			if !r.readFull(r.decoded[:n]) {
+				return 0, r.err
+			}
+			if crc(r.decoded[:n]) != checksum {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			r.i, r.j = 0, n
+			continue
+
+		case chunkTypeStreamIdentifier:
+			// Section 4.1. Stream identifier (chunk type 0xff).
+			if chunkLen != len(magicBody) {
+				r.err = ErrCorrupt
+				return 0, r.err
+			}
+			if !r.readFull(r.buf[:len(magicBody)]) {
+				return 0, r.err
+			}
+			for i := 0; i < len(magicBody); i++ {
+				if r.buf[i] != magicBody[i] {
+					r.err = ErrCorrupt
+					return 0, r.err
+				}
+			}
+			continue
+		}
+
+		if chunkType <= 0x7f {
+			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
+			r.err = ErrUnsupported
+			return 0, r.err
+
+		} else {
+			// Section 4.4 Padding (chunk type 0xfe).
+			// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
+			if !r.readFull(r.buf[:chunkLen]) {
+				return 0, r.err
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/syndtr/gosnappy/snappy/encode.go b/vendor/github.com/syndtr/gosnappy/snappy/encode.go
new file mode 100644
index 00000000..dda37242
--- /dev/null
+++ b/vendor/github.com/syndtr/gosnappy/snappy/encode.go
@@ -0,0 +1,258 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+// We limit how far copy back-references can go, the same as the C++ code.
+const maxOffset = 1 << 15
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+func emitLiteral(dst, lit []byte) int {
+	i, n := 0, uint(len(lit)-1)
+	switch {
+	case n < 60:
+		dst[0] = uint8(n)<<2 | tagLiteral
+		i = 1
+	case n < 1<<8:
+		dst[0] = 60<<2 | tagLiteral
+		dst[1] = uint8(n)
+		i = 2
+	case n < 1<<16:
+		dst[0] = 61<<2 | tagLiteral
+		dst[1] = uint8(n)
+		dst[2] = uint8(n >> 8)
+		i = 3
+	case n < 1<<24:
+		dst[0] = 62<<2 | tagLiteral
+		dst[1] = uint8(n)
+		dst[2] = uint8(n >> 8)
+		dst[3] = uint8(n >> 16)
+		i = 4
+	case int64(n) < 1<<32:
+		dst[0] = 63<<2 | tagLiteral
+		dst[1] = uint8(n)
+		dst[2] = uint8(n >> 8)
+		dst[3] = uint8(n >> 16)
+		dst[4] = uint8(n >> 24)
+		i = 5
+	default:
+		panic("snappy: source buffer is too long")
+	}
+	if copy(dst[i:], lit) != len(lit) {
+		panic("snappy: destination buffer is too short")
+	}
+	return i + len(lit)
+}
+
+// emitCopy writes a copy chunk and returns the number of bytes written.
+func emitCopy(dst []byte, offset, length int) int {
+	i := 0
+	for length > 0 {
+		x := length - 4
+		if 0 <= x && x < 1<<3 && offset < 1<<11 {
+			dst[i+0] = uint8(offset>>8)&0x07<<5 | uint8(x)<<2 | tagCopy1
+			dst[i+1] = uint8(offset)
+			i += 2
+			break
+		}
+
+		x = length
+		if x > 1<<6 {
+			x = 1 << 6
+		}
+		dst[i+0] = uint8(x-1)<<2 | tagCopy2
+		dst[i+1] = uint8(offset)
+		dst[i+2] = uint8(offset >> 8)
+		i += 3
+		length -= x
+	}
+	return i
+}
+
+// Encode returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+// It is valid to pass a nil dst.
+func Encode(dst, src []byte) ([]byte, error) {
+	if n := MaxEncodedLen(len(src)); len(dst) < n {
+		dst = make([]byte, n)
+	}
+
+	// The block starts with the varint-encoded length of the decompressed bytes.
+	d := binary.PutUvarint(dst, uint64(len(src)))
+
+	// Return early if src is short.
+	if len(src) <= 4 {
+		if len(src) != 0 {
+			d += emitLiteral(dst[d:], src)
+		}
+		return dst[:d], nil
+	}
+
+	// Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
+	const maxTableSize = 1 << 14
+	shift, tableSize := uint(32-8), 1<<8
+	for tableSize < maxTableSize && tableSize < len(src) {
+		shift--
+		tableSize *= 2
+	}
+	var table [maxTableSize]int
+
+	// Iterate over the source bytes.
+	var (
+		s   int // The iterator position.
+		t   int // The last position with the same hash as s.
+		lit int // The start position of any pending literal bytes.
+	)
+	for s+3 < len(src) {
+		// Update the hash table.
+		b0, b1, b2, b3 := src[s], src[s+1], src[s+2], src[s+3]
+		h := uint32(b0) | uint32(b1)<<8 | uint32(b2)<<16 | uint32(b3)<<24
+		p := &table[(h*0x1e35a7bd)>>shift]
+		// We need to to store values in [-1, inf) in table. To save
+		// some initialization time, (re)use the table's zero value
+		// and shift the values against this zero: add 1 on writes,
+		// subtract 1 on reads.
+		t, *p = *p-1, s+1
+		// If t is invalid or src[s:s+4] differs from src[t:t+4], accumulate a literal byte.
+		if t < 0 || s-t >= maxOffset || b0 != src[t] || b1 != src[t+1] || b2 != src[t+2] || b3 != src[t+3] {
+			s++
+			continue
+		}
+		// Otherwise, we have a match. First, emit any pending literal bytes.
+		if lit != s {
+			d += emitLiteral(dst[d:], src[lit:s])
+		}
+		// Extend the match to be as long as possible.
+		s0 := s
+		s, t = s+4, t+4
+		for s < len(src) && src[s] == src[t] {
+			s++
+			t++
+		}
+		// Emit the copied bytes.
+		d += emitCopy(dst[d:], s-t, s-s0)
+		lit = s
+	}
+
+	// Emit any final pending literal bytes and return.
+	if lit != len(src) {
+		d += emitLiteral(dst[d:], src[lit:])
+	}
+	return dst[:d], nil
+}
+
+// MaxEncodedLen returns the maximum length of a snappy block, given its
+// uncompressed length.
+func MaxEncodedLen(srcLen int) int {
+	// Compressed data can be defined as:
+	//    compressed := item* literal*
+	//    item       := literal* copy
+	//
+	// The trailing literal sequence has a space blowup of at most 62/60
+	// since a literal of length 60 needs one tag byte + one extra byte
+	// for length information.
+	//
+	// Item blowup is trickier to measure. Suppose the "copy" op copies
+	// 4 bytes of data. Because of a special check in the encoding code,
+	// we produce a 4-byte copy only if the offset is < 65536. Therefore
+	// the copy op takes 3 bytes to encode, and this type of item leads
+	// to at most the 62/60 blowup for representing literals.
+	//
+	// Suppose the "copy" op copies 5 bytes of data. If the offset is big
+	// enough, it will take 5 bytes to encode the copy op. Therefore the
+	// worst case here is a one-byte literal followed by a five-byte copy.
+	// That is, 6 bytes of input turn into 7 bytes of "compressed" data.
+	//
+	// This last factor dominates the blowup, so the final estimate is:
+	return 32 + srcLen + srcLen/6
+}
+
+// NewWriter returns a new Writer that compresses to w, using the framing
+// format described at
+// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{
+		w:   w,
+		enc: make([]byte, MaxEncodedLen(maxUncompressedChunkLen)),
+	}
+}
+
+// Writer is an io.Writer than can write Snappy-compressed bytes.
+type Writer struct {
+	w           io.Writer
+	err         error
+	enc         []byte
+	buf         [checksumSize + chunkHeaderSize]byte
+	wroteHeader bool
+}
+
+// Reset discards the writer's state and switches the Snappy writer to write to
+// w. This permits reusing a Writer rather than allocating a new one.
+func (w *Writer) Reset(writer io.Writer) {
+	w.w = writer
+	w.err = nil
+	w.wroteHeader = false
+}
+
+// Write satisfies the io.Writer interface.
+func (w *Writer) Write(p []byte) (n int, errRet error) {
+	if w.err != nil {
+		return 0, w.err
+	}
+	if !w.wroteHeader {
+		copy(w.enc, magicChunk)
+		if _, err := w.w.Write(w.enc[:len(magicChunk)]); err != nil {
+			w.err = err
+			return n, err
+		}
+		w.wroteHeader = true
+	}
+	for len(p) > 0 {
+		var uncompressed []byte
+		if len(p) > maxUncompressedChunkLen {
+			uncompressed, p = p[:maxUncompressedChunkLen], p[maxUncompressedChunkLen:]
+		} else {
+			uncompressed, p = p, nil
+		}
+		checksum := crc(uncompressed)
+
+		// Compress the buffer, discarding the result if the improvement
+		// isn't at least 12.5%.
+		chunkType := uint8(chunkTypeCompressedData)
+		chunkBody, err := Encode(w.enc, uncompressed)
+		if err != nil {
+			w.err = err
+			return n, err
+		}
+		if len(chunkBody) >= len(uncompressed)-len(uncompressed)/8 {
+			chunkType, chunkBody = chunkTypeUncompressedData, uncompressed
+		}
+
+		chunkLen := 4 + len(chunkBody)
+		w.buf[0] = chunkType
+		w.buf[1] = uint8(chunkLen >> 0)
+		w.buf[2] = uint8(chunkLen >> 8)
+		w.buf[3] = uint8(chunkLen >> 16)
+		w.buf[4] = uint8(checksum >> 0)
+		w.buf[5] = uint8(checksum >> 8)
+		w.buf[6] = uint8(checksum >> 16)
+		w.buf[7] = uint8(checksum >> 24)
+		if _, err = w.w.Write(w.buf[:]); err != nil {
+			w.err = err
+			return n, err
+		}
+		if _, err = w.w.Write(chunkBody); err != nil {
+			w.err = err
+			return n, err
+		}
+		n += len(uncompressed)
+	}
+	return n, nil
+}
diff --git a/vendor/github.com/syndtr/gosnappy/snappy/snappy.go b/vendor/github.com/syndtr/gosnappy/snappy/snappy.go
new file mode 100644
index 00000000..043bf3d8
--- /dev/null
+++ b/vendor/github.com/syndtr/gosnappy/snappy/snappy.go
@@ -0,0 +1,68 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package snappy implements the snappy block-based compression format.
+// It aims for very high speeds and reasonable compression.
+//
+// The C++ snappy implementation is at http://code.google.com/p/snappy/
+package snappy
+
+import (
+	"hash/crc32"
+)
+
+/*
+Each encoded block begins with the varint-encoded length of the decoded data,
+followed by a sequence of chunks. Chunks begin and end on byte boundaries. The
+first byte of each chunk is broken into its 2 least and 6 most significant bits
+called l and m: l ranges in [0, 4) and m ranges in [0, 64). l is the chunk tag.
+Zero means a literal tag. All other values mean a copy tag.
+
+For literal tags:
+  - If m < 60, the next 1 + m bytes are literal bytes.
+  - Otherwise, let n be the little-endian unsigned integer denoted by the next
+    m - 59 bytes. The next 1 + n bytes after that are literal bytes.
+
+For copy tags, length bytes are copied from offset bytes ago, in the style of
+Lempel-Ziv compression algorithms. In particular:
+  - For l == 1, the offset ranges in [0, 1<<11) and the length in [4, 12).
+    The length is 4 + the low 3 bits of m. The high 3 bits of m form bits 8-10
+    of the offset. The next byte is bits 0-7 of the offset.
+  - For l == 2, the offset ranges in [0, 1<<16) and the length in [1, 65).
+    The length is 1 + m. The offset is the little-endian unsigned integer
+    denoted by the next 2 bytes.
+  - For l == 3, this tag is a legacy format that is no longer supported.
+*/
+const (
+	tagLiteral = 0x00
+	tagCopy1   = 0x01
+	tagCopy2   = 0x02
+	tagCopy4   = 0x03
+)
+
+const (
+	checksumSize    = 4
+	chunkHeaderSize = 4
+	magicChunk      = "\xff\x06\x00\x00" + magicBody
+	magicBody       = "sNaPpY"
+	// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt says
+	// that "the uncompressed data in a chunk must be no longer than 65536 bytes".
+	maxUncompressedChunkLen = 65536
+)
+
+const (
+	chunkTypeCompressedData   = 0x00
+	chunkTypeUncompressedData = 0x01
+	chunkTypePadding          = 0xfe
+	chunkTypeStreamIdentifier = 0xff
+)
+
+var crcTable = crc32.MakeTable(crc32.Castagnoli)
+
+// crc implements the checksum specified in section 3 of
+// https://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
+func crc(b []byte) uint32 {
+	c := crc32.Update(0, crcTable, b)
+	return uint32(c>>15|c<<17) + 0xa282ead8
+}
diff --git a/vendor/github.com/tylerb/graceful/.gitignore b/vendor/github.com/tylerb/graceful/.gitignore
new file mode 100644
index 00000000..83656241
--- /dev/null
+++ b/vendor/github.com/tylerb/graceful/.gitignore
@@ -0,0 +1,23 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
diff --git a/vendor/github.com/tylerb/graceful/LICENSE b/vendor/github.com/tylerb/graceful/LICENSE
new file mode 100644
index 00000000..a4f2f281
--- /dev/null
+++ b/vendor/github.com/tylerb/graceful/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Tyler Bunnell
+
+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.
diff --git a/vendor/github.com/tylerb/graceful/README.md b/vendor/github.com/tylerb/graceful/README.md
new file mode 100644
index 00000000..531249a7
--- /dev/null
+++ b/vendor/github.com/tylerb/graceful/README.md
@@ -0,0 +1,137 @@
+graceful [![GoDoc](https://godoc.org/github.com/tylerb/graceful?status.png)](http://godoc.org/github.com/tylerb/graceful) [![Build Status](https://drone.io/github.com/tylerb/graceful/status.png)](https://drone.io/github.com/tylerb/graceful/latest) [![Coverage Status](https://coveralls.io/repos/tylerb/graceful/badge.svg?branch=dronedebug)](https://coveralls.io/r/tylerb/graceful?branch=dronedebug) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/tylerb/graceful?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+========
+
+Graceful is a Go 1.3+ package enabling graceful shutdown of http.Handler servers.
+
+## Installation
+
+To install, simply execute:
+
+```
+go get gopkg.in/tylerb/graceful.v1
+```
+
+I am using [gopkg.in](http://labix.org/gopkg.in) to control releases.
+
+## Usage
+
+Using Graceful is easy. Simply create your http.Handler and pass it to the `Run` function:
+
+```go
+package main
+
+import (
+  "gopkg.in/tylerb/graceful.v1"
+  "net/http"
+  "fmt"
+  "time"
+)
+
+func main() {
+  mux := http.NewServeMux()
+  mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+    fmt.Fprintf(w, "Welcome to the home page!")
+  })
+
+  graceful.Run(":3001",10*time.Second,mux)
+}
+```
+
+Another example, using [Negroni](https://github.com/codegangsta/negroni), functions in much the same manner:
+
+```go
+package main
+
+import (
+  "github.com/codegangsta/negroni"
+  "gopkg.in/tylerb/graceful.v1"
+  "net/http"
+  "fmt"
+  "time"
+)
+
+func main() {
+  mux := http.NewServeMux()
+  mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+    fmt.Fprintf(w, "Welcome to the home page!")
+  })
+
+  n := negroni.Classic()
+  n.UseHandler(mux)
+  //n.Run(":3000")
+  graceful.Run(":3001",10*time.Second,n)
+}
+```
+
+In addition to Run there are the http.Server counterparts ListenAndServe, ListenAndServeTLS and Serve, which allow you to configure HTTPS, custom timeouts and error handling.
+Graceful may also be used by instantiating its Server type directly, which embeds an http.Server:
+
+```go
+mux := // ...
+
+srv := &graceful.Server{
+  Timeout: 10 * time.Second,
+
+  Server: &http.Server{
+    Addr: ":1234",
+    Handler: mux,
+  },
+}
+
+srv.ListenAndServe()
+```
+
+This form allows you to set the ConnState callback, which works in the same way as in http.Server:
+
+```go
+mux := // ...
+
+srv := &graceful.Server{
+  Timeout: 10 * time.Second,
+
+  ConnState: func(conn net.Conn, state http.ConnState) {
+    // conn has a new state
+  },
+
+  Server: &http.Server{
+    Addr: ":1234",
+    Handler: mux,
+  },
+}
+
+srv.ListenAndServe()
+```
+
+## Behaviour
+
+When Graceful is sent a SIGINT or SIGTERM (possibly from ^C or a kill command), it:
+
+1. Disables keepalive connections.
+2. Closes the listening socket, allowing another process to listen on that port immediately.
+3. Starts a timer of `timeout` duration to give active requests a chance to finish.
+4. When timeout expires, closes all active connections.
+5. Closes the `stopChan`, waking up any blocking goroutines.
+6. Returns from the function, allowing the server to terminate.
+
+## Notes
+
+If the `timeout` argument to `Run` is 0, the server never times out, allowing all active requests to complete.
+
+If you wish to stop the server in some way other than an OS signal, you may call the `Stop()` function.
+This function stops the server, gracefully, using the new timeout value you provide. The `StopChan()` function
+returns a channel on which you can block while waiting for the server to stop. This channel will be closed when
+the server is stopped, allowing your execution to proceed. Multiple goroutines can block on this channel at the
+same time and all will be signalled when stopping is complete.
+
+## Contributing
+
+If you would like to contribute, please:
+
+1. Create a GitHub issue regarding the contribution. Features and bugs should be discussed beforehand.
+2. Fork the repository.
+3. Create a pull request with your solution. This pull request should reference and close the issues (Fix #2).
+
+All pull requests should:
+
+1. Pass [gometalinter -t .](https://github.com/alecthomas/gometalinter) with no warnings.
+2. Be `go fmt` formatted.
diff --git a/vendor/github.com/tylerb/graceful/graceful.go b/vendor/github.com/tylerb/graceful/graceful.go
new file mode 100644
index 00000000..5ce9f98c
--- /dev/null
+++ b/vendor/github.com/tylerb/graceful/graceful.go
@@ -0,0 +1,346 @@
+package graceful
+
+import (
+	"crypto/tls"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"golang.org/x/net/netutil"
+)
+
+// Server wraps an http.Server with graceful connection handling.
+// It may be used directly in the same way as http.Server, or may
+// be constructed with the global functions in this package.
+//
+// Example:
+//	srv := &graceful.Server{
+//		Timeout: 5 * time.Second,
+//		Server: &http.Server{Addr: ":1234", Handler: handler},
+//	}
+//	srv.ListenAndServe()
+type Server struct {
+	*http.Server
+
+	// Timeout is the duration to allow outstanding requests to survive
+	// before forcefully terminating them.
+	Timeout time.Duration
+
+	// Limit the number of outstanding requests
+	ListenLimit int
+
+	// ConnState specifies an optional callback function that is
+	// called when a client connection changes state. This is a proxy
+	// to the underlying http.Server's ConnState, and the original
+	// must not be set directly.
+	ConnState func(net.Conn, http.ConnState)
+
+	// BeforeShutdown is an optional callback function that is called
+	// before the listener is closed.
+	BeforeShutdown func()
+
+	// ShutdownInitiated is an optional callback function that is called
+	// when shutdown is initiated. It can be used to notify the client
+	// side of long lived connections (e.g. websockets) to reconnect.
+	ShutdownInitiated func()
+
+	// NoSignalHandling prevents graceful from automatically shutting down
+	// on SIGINT and SIGTERM. If set to true, you must shut down the server
+	// manually with Stop().
+	NoSignalHandling bool
+
+	// interrupt signals the listener to stop serving connections,
+	// and the server to shut down.
+	interrupt chan os.Signal
+
+	// stopLock is used to protect against concurrent calls to Stop
+	stopLock sync.Mutex
+
+	// stopChan is the channel on which callers may block while waiting for
+	// the server to stop.
+	stopChan chan struct{}
+
+	// chanLock is used to protect access to the various channel constructors.
+	chanLock sync.RWMutex
+
+	// connections holds all connections managed by graceful
+	connections map[net.Conn]struct{}
+}
+
+// Run serves the http.Handler with graceful shutdown enabled.
+//
+// timeout is the duration to wait until killing active requests and stopping the server.
+// If timeout is 0, the server never times out. It waits for all active requests to finish.
+func Run(addr string, timeout time.Duration, n http.Handler) {
+	srv := &Server{
+		Timeout: timeout,
+		Server:  &http.Server{Addr: addr, Handler: n},
+	}
+
+	if err := srv.ListenAndServe(); err != nil {
+		if opErr, ok := err.(*net.OpError); !ok || (ok && opErr.Op != "accept") {
+			logger := log.New(os.Stdout, "[graceful] ", 0)
+			logger.Fatal(err)
+		}
+	}
+
+}
+
+// ListenAndServe is equivalent to http.Server.ListenAndServe with graceful shutdown enabled.
+//
+// timeout is the duration to wait until killing active requests and stopping the server.
+// If timeout is 0, the server never times out. It waits for all active requests to finish.
+func ListenAndServe(server *http.Server, timeout time.Duration) error {
+	srv := &Server{Timeout: timeout, Server: server}
+	return srv.ListenAndServe()
+}
+
+// ListenAndServe is equivalent to http.Server.ListenAndServe with graceful shutdown enabled.
+func (srv *Server) ListenAndServe() error {
+	// Create the listener so we can control their lifetime
+	addr := srv.Addr
+	if addr == "" {
+		addr = ":http"
+	}
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+
+	return srv.Serve(l)
+}
+
+// ListenAndServeTLS is equivalent to http.Server.ListenAndServeTLS with graceful shutdown enabled.
+//
+// timeout is the duration to wait until killing active requests and stopping the server.
+// If timeout is 0, the server never times out. It waits for all active requests to finish.
+func ListenAndServeTLS(server *http.Server, certFile, keyFile string, timeout time.Duration) error {
+	srv := &Server{Timeout: timeout, Server: server}
+	return srv.ListenAndServeTLS(certFile, keyFile)
+}
+
+// ListenTLS is a convenience method that creates an https listener using the
+// provided cert and key files. Use this method if you need access to the
+// listener object directly. When ready, pass it to the Serve method.
+func (srv *Server) ListenTLS(certFile, keyFile string) (net.Listener, error) {
+	// Create the listener ourselves so we can control its lifetime
+	addr := srv.Addr
+	if addr == "" {
+		addr = ":https"
+	}
+
+	config := &tls.Config{}
+	if srv.TLSConfig != nil {
+		*config = *srv.TLSConfig
+	}
+	if config.NextProtos == nil {
+		config.NextProtos = []string{"http/1.1"}
+	}
+
+	var err error
+	config.Certificates = make([]tls.Certificate, 1)
+	config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	tlsListener := tls.NewListener(conn, config)
+	return tlsListener, nil
+}
+
+// ListenAndServeTLS is equivalent to http.Server.ListenAndServeTLS with graceful shutdown enabled.
+func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error {
+	l, err := srv.ListenTLS(certFile, keyFile)
+	if err != nil {
+		return err
+	}
+
+	return srv.Serve(l)
+}
+
+// ListenAndServeTLSConfig can be used with an existing TLS config and is equivalent to
+// http.Server.ListenAndServeTLS with graceful shutdown enabled,
+func (srv *Server) ListenAndServeTLSConfig(config *tls.Config) error {
+	addr := srv.Addr
+	if addr == "" {
+		addr = ":https"
+	}
+
+	conn, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+
+	tlsListener := tls.NewListener(conn, config)
+	return srv.Serve(tlsListener)
+}
+
+// Serve is equivalent to http.Server.Serve with graceful shutdown enabled.
+//
+// timeout is the duration to wait until killing active requests and stopping the server.
+// If timeout is 0, the server never times out. It waits for all active requests to finish.
+func Serve(server *http.Server, l net.Listener, timeout time.Duration) error {
+	srv := &Server{Timeout: timeout, Server: server}
+	return srv.Serve(l)
+}
+
+// Serve is equivalent to http.Server.Serve with graceful shutdown enabled.
+func (srv *Server) Serve(listener net.Listener) error {
+
+	if srv.ListenLimit != 0 {
+		listener = netutil.LimitListener(listener, srv.ListenLimit)
+	}
+
+	// Track connection state
+	add := make(chan net.Conn)
+	remove := make(chan net.Conn)
+
+	srv.Server.ConnState = func(conn net.Conn, state http.ConnState) {
+		switch state {
+		case http.StateNew:
+			add <- conn
+		case http.StateClosed, http.StateHijacked:
+			remove <- conn
+		}
+		if srv.ConnState != nil {
+			srv.ConnState(conn, state)
+		}
+	}
+
+	// Manage open connections
+	shutdown := make(chan chan struct{})
+	kill := make(chan struct{})
+	go srv.manageConnections(add, remove, shutdown, kill)
+
+	interrupt := srv.interruptChan()
+	// Set up the interrupt handler
+	if !srv.NoSignalHandling {
+		signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)
+	}
+	go srv.handleInterrupt(interrupt, listener)
+
+	// Serve with graceful listener.
+	// Execution blocks here until listener.Close() is called, above.
+	err := srv.Server.Serve(listener)
+
+	srv.shutdown(shutdown, kill)
+
+	return err
+}
+
+// Stop instructs the type to halt operations and close
+// the stop channel when it is finished.
+//
+// timeout is grace period for which to wait before shutting
+// down the server. The timeout value passed here will override the
+// timeout given when constructing the server, as this is an explicit
+// command to stop the server.
+func (srv *Server) Stop(timeout time.Duration) {
+	srv.stopLock.Lock()
+	srv.Timeout = timeout
+	interrupt := srv.interruptChan()
+	interrupt <- syscall.SIGINT
+	srv.stopLock.Unlock()
+}
+
+// StopChan gets the stop channel which will block until
+// stopping has completed, at which point it is closed.
+// Callers should never close the stop channel.
+func (srv *Server) StopChan() <-chan struct{} {
+	srv.chanLock.Lock()
+	if srv.stopChan == nil {
+		srv.stopChan = make(chan struct{})
+	}
+	srv.chanLock.Unlock()
+	return srv.stopChan
+}
+
+func (srv *Server) manageConnections(add, remove chan net.Conn, shutdown chan chan struct{}, kill chan struct{}) {
+	var done chan struct{}
+	srv.connections = map[net.Conn]struct{}{}
+	for {
+		select {
+		case conn := <-add:
+			srv.connections[conn] = struct{}{}
+		case conn := <-remove:
+			delete(srv.connections, conn)
+			if done != nil && len(srv.connections) == 0 {
+				done <- struct{}{}
+				return
+			}
+		case done = <-shutdown:
+			if len(srv.connections) == 0 {
+				done <- struct{}{}
+				return
+			}
+		case <-kill:
+			for k := range srv.connections {
+				_ = k.Close() // nothing to do here if it errors
+			}
+			return
+		}
+	}
+}
+
+func (srv *Server) interruptChan() chan os.Signal {
+	srv.chanLock.Lock()
+	if srv.interrupt == nil {
+		srv.interrupt = make(chan os.Signal, 1)
+	}
+	srv.chanLock.Unlock()
+
+	return srv.interrupt
+}
+
+func (srv *Server) handleInterrupt(interrupt chan os.Signal, listener net.Listener) {
+	<-interrupt
+
+	if srv.BeforeShutdown != nil {
+		srv.BeforeShutdown()
+	}
+
+	srv.SetKeepAlivesEnabled(false)
+	_ = listener.Close() // we are shutting down anyway. ignore error.
+
+	if srv.ShutdownInitiated != nil {
+		srv.ShutdownInitiated()
+	}
+
+	srv.stopLock.Lock()
+	signal.Stop(interrupt)
+	close(interrupt)
+	srv.interrupt = nil
+	srv.stopLock.Unlock()
+}
+
+func (srv *Server) shutdown(shutdown chan chan struct{}, kill chan struct{}) {
+	// Request done notification
+	done := make(chan struct{})
+	shutdown <- done
+
+	if srv.Timeout > 0 {
+		select {
+		case <-done:
+		case <-time.After(srv.Timeout):
+			close(kill)
+		}
+	} else {
+		<-done
+	}
+	// Close the stopChan to wake up any blocked goroutines.
+	srv.chanLock.Lock()
+	if srv.stopChan != nil {
+		close(srv.stopChan)
+	}
+	srv.chanLock.Unlock()
+}
diff --git a/vendor/github.com/tylerb/graceful/tests/main.go b/vendor/github.com/tylerb/graceful/tests/main.go
new file mode 100644
index 00000000..8c8fa204
--- /dev/null
+++ b/vendor/github.com/tylerb/graceful/tests/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/codegangsta/negroni"
+	"github.com/tylerb/graceful"
+)
+
+func main() {
+
+	var wg sync.WaitGroup
+
+	wg.Add(3)
+	go func() {
+		n := negroni.New()
+		fmt.Println("Launching server on :3000")
+		graceful.Run(":3000", 0, n)
+		fmt.Println("Terminated server on :3000")
+		wg.Done()
+	}()
+	go func() {
+		n := negroni.New()
+		fmt.Println("Launching server on :3001")
+		graceful.Run(":3001", 0, n)
+		fmt.Println("Terminated server on :3001")
+		wg.Done()
+	}()
+	go func() {
+		n := negroni.New()
+		fmt.Println("Launching server on :3002")
+		graceful.Run(":3002", 0, n)
+		fmt.Println("Terminated server on :3002")
+		wg.Done()
+	}()
+	fmt.Println("Press ctrl+c. All servers should terminate.")
+	wg.Wait()
+
+}
diff --git a/vendor/golang.org/x/net/netutil/listen.go b/vendor/golang.org/x/net/netutil/listen.go
new file mode 100644
index 00000000..a2591f83
--- /dev/null
+++ b/vendor/golang.org/x/net/netutil/listen.go
@@ -0,0 +1,48 @@
+// Copyright 2013 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package netutil provides network utility functions, complementing the more
+// common ones in the net package.
+package netutil
+
+import (
+	"net"
+	"sync"
+)
+
+// LimitListener returns a Listener that accepts at most n simultaneous
+// connections from the provided Listener.
+func LimitListener(l net.Listener, n int) net.Listener {
+	return &limitListener{l, make(chan struct{}, n)}
+}
+
+type limitListener struct {
+	net.Listener
+	sem chan struct{}
+}
+
+func (l *limitListener) acquire() { l.sem <- struct{}{} }
+func (l *limitListener) release() { <-l.sem }
+
+func (l *limitListener) Accept() (net.Conn, error) {
+	l.acquire()
+	c, err := l.Listener.Accept()
+	if err != nil {
+		l.release()
+		return nil, err
+	}
+	return &limitListenerConn{Conn: c, release: l.release}, nil
+}
+
+type limitListenerConn struct {
+	net.Conn
+	releaseOnce sync.Once
+	release     func()
+}
+
+func (l *limitListenerConn) Close() error {
+	err := l.Conn.Close()
+	l.releaseOnce.Do(l.release)
+	return err
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/.travis.yml b/vendor/gopkg.in/alecthomas/kingpin.v2/.travis.yml
new file mode 100644
index 00000000..b4f15bac
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/.travis.yml
@@ -0,0 +1,3 @@
+language: go
+install: go get -t -v ./...
+go: 1.2
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/COPYING b/vendor/gopkg.in/alecthomas/kingpin.v2/COPYING
new file mode 100644
index 00000000..2993ec08
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/COPYING
@@ -0,0 +1,19 @@
+Copyright (C) 2014 Alec Thomas
+
+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.
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/README.md b/vendor/gopkg.in/alecthomas/kingpin.v2/README.md
new file mode 100644
index 00000000..efe8574b
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/README.md
@@ -0,0 +1,538 @@
+# Kingpin - A Go (golang) command line and flag parser [![Build Status](https://travis-ci.org/alecthomas/kingpin.png)](https://travis-ci.org/alecthomas/kingpin)
+
+<!-- MarkdownTOC -->
+
+- [Overview](#overview)
+- [Features](#features)
+- [User-visible changes between v1 and v2](#user-visible-changes-between-v1-and-v2)
+  - [Flags can be used at any point after their definition.](#flags-can-be-used-at-any-point-after-their-definition)
+  - [Short flags can be combined with their parameters](#short-flags-can-be-combined-with-their-parameters)
+- [API changes between v1 and v2](#api-changes-between-v1-and-v2)
+- [Versions](#versions)
+  - [V2 is the current stable version](#v2-is-the-current-stable-version)
+  - [V1 is the OLD stable version](#v1-is-the-old-stable-version)
+- [Change History](#change-history)
+- [Examples](#examples)
+  - [Simple Example](#simple-example)
+  - [Complex Example](#complex-example)
+- [Reference Documentation](#reference-documentation)
+  - [Displaying errors and usage information](#displaying-errors-and-usage-information)
+  - [Sub-commands](#sub-commands)
+  - [Custom Parsers](#custom-parsers)
+  - [Default Values](#default-values)
+  - [Place-holders in Help](#place-holders-in-help)
+  - [Consuming all remaining arguments](#consuming-all-remaining-arguments)
+  - [Custom help](#custom-help)
+
+<!-- /MarkdownTOC -->
+
+## Overview
+
+Kingpin is a [fluent-style](http://en.wikipedia.org/wiki/Fluent_interface),
+type-safe command-line parser. It supports flags, nested commands, and
+positional arguments.
+
+Install it with:
+
+    $ go get gopkg.in/alecthomas/kingpin.v2
+
+It looks like this:
+
+```go
+var (
+  verbose = kingpin.Flag("verbose", "Verbose mode.").Short('v').Bool()
+  name    = kingpin.Arg("name", "Name of user.").Required().String()
+)
+
+func main() {
+  kingpin.Parse()
+  fmt.Printf("%v, %s\n", *verbose, *name)
+}
+```
+
+More [examples](https://github.com/alecthomas/kingpin/tree/master/examples) are available.
+
+Second to parsing, providing the user with useful help is probably the most
+important thing a command-line parser does. Kingpin tries to provide detailed
+contextual help if `--help` is encountered at any point in the command line
+(excluding after `--`).
+
+## Features
+
+- Help output that isn't as ugly as sin.
+- Fully [customisable help](#custom-help), via Go templates.
+- Parsed, type-safe flags (`kingpin.Flag("f", "help").Int()`)
+- Parsed, type-safe positional arguments (`kingpin.Arg("a", "help").Int()`).
+- Support for required flags and required positional arguments (`kingpin.Flag("f", "").Required().Int()`).
+- Callbacks per command, flag and argument (`kingpin.Command("c", "").Action(myAction)`).
+- POSIX-style short flag combining (`-a -b` -> `-ab`).
+- Short-flag+parameter combining (`-a parm` -> `-aparm`).
+- Read command-line from files (`@<file>`).
+- Automatically generate man pages (`--man-page`).
+
+## User-visible changes between v1 and v2
+
+### Flags can be used at any point after their definition.
+
+Flags can be specified at any point after their definition, not just
+*immediately after their associated command*. From the chat example below, the
+following used to be required:
+
+```
+$ chat --server=chat.server.com:8080 post --image=~/Downloads/owls.jpg pics
+```
+
+But the following will now work:
+
+```
+$ chat post --server=chat.server.com:8080 --image=~/Downloads/owls.jpg pics
+```
+
+### Short flags can be combined with their parameters
+
+Previously, if a short flag was used, any argument to that flag would have to
+be separated by a space. That is no longer the case.
+
+## API changes between v1 and v2
+
+- `ParseWithFileExpansion()` is gone. The new parser directly supports expanding `@<file>`.
+- Added `FatalUsage()` and `FatalUsageContext()` for displaying an error + usage and terminating.
+- `Dispatch()` renamed to `Action()`.
+- Added `ParseContext()` for parsing a command line into its intermediate context form without executing.
+- Added `Terminate()` function to override the termination function.
+- Added `UsageForContextWithTemplate()` for printing usage via a custom template.
+- Added `UsageTemplate()` for overriding the default template to use. Two templates are included:
+    1. `DefaultUsageTemplate` - default template.
+    2. `CompactUsageTemplate` - compact command template for larger applications.
+
+## Versions
+
+Kingpin uses [gopkg.in](https://gopkg.in/alecthomas/kingpin) for versioning.
+
+The current stable version is [gopkg.in/alecthomas/kingpin.v2](https://gopkg.in/alecthomas/kingpin.v2). The previous version, [gopkg.in/alecthomas/kingpin.v1](https://gopkg.in/alecthomas/kingpin.v1), is deprecated and in maintenance mode.
+
+### [V2](https://gopkg.in/alecthomas/kingpin.v2) is the current stable version
+
+Installation:
+
+```sh
+$ go get gopkg.in/alecthomas/kingpin.v2
+```
+
+### [V1](https://gopkg.in/alecthomas/kingpin.v1) is the OLD stable version
+
+Installation:
+
+```sh
+$ go get gopkg.in/alecthomas/kingpin.v1
+```
+
+## Change History
+
+- *2015-05-22* -- Stable v2.0.0 release.
+    - Initial stable release of v2.0.0.
+    - Fully supports interspersed flags, commands and arguments.
+    - Flags can be present at any point after their logical definition.
+    - Application.Parse() terminates if commands are present and a command is not parsed.
+    - Dispatch() -> Action().
+    - Actions are dispatched after all values are populated.
+    - Override termination function (defaults to os.Exit).
+    - Override output stream (defaults to os.Stderr).
+    - Templatised usage help, with default and compact templates.
+    - Make error/usage functions more consistent.
+    - Support argument expansion from files by default (with @<file>).
+    - Fully public data model is available via .Model().
+    - Parser has been completely refactored.
+    - Parsing and execution has been split into distinct stages.
+    - Use `go generate` to generate repeated flags.
+    - Support combined short-flag+argument: -fARG.
+
+- *2015-01-23* -- Stable v1.3.4 release.
+    - Support "--" for separating flags from positional arguments.
+    - Support loading flags from files (ParseWithFileExpansion()). Use @FILE as an argument.
+    - Add post-app and post-cmd validation hooks. This allows arbitrary validation to be added.
+    - A bunch of improvements to help usage and formatting.
+    - Support arbitrarily nested sub-commands.
+
+- *2014-07-08* -- Stable v1.2.0 release.
+    - Pass any value through to `Strings()` when final argument.
+      Allows for values that look like flags to be processed.
+    - Allow `--help` to be used with commands.
+    - Support `Hidden()` flags.
+    - Parser for [units.Base2Bytes](https://github.com/alecthomas/units)
+      type. Allows for flags like `--ram=512MB` or `--ram=1GB`.
+    - Add an `Enum()` value, allowing only one of a set of values
+      to be selected. eg. `Flag(...).Enum("debug", "info", "warning")`.
+
+- *2014-06-27* -- Stable v1.1.0 release.
+    - Bug fixes.
+    - Always return an error (rather than panicing) when misconfigured.
+    - `OpenFile(flag, perm)` value type added, for finer control over opening files.
+    - Significantly improved usage formatting.
+
+- *2014-06-19* -- Stable v1.0.0 release.
+    - Support [cumulative positional](#consuming-all-remaining-arguments) arguments.
+    - Return error rather than panic when there are fatal errors not caught by
+      the type system. eg. when a default value is invalid.
+    - Use gokpg.in.
+
+- *2014-06-10* -- Place-holder streamlining.
+    - Renamed `MetaVar` to `PlaceHolder`.
+    - Removed `MetaVarFromDefault`. Kingpin now uses [heuristics](#place-holders-in-help)
+      to determine what to display.
+
+## Examples
+
+### Simple Example
+
+Kingpin can be used for simple flag+arg applications like so:
+
+```
+$ ping --help
+usage: ping [<flags>] <ip> [<count>]
+
+Flags:
+  --debug            Enable debug mode.
+  --help             Show help.
+  -t, --timeout=5s   Timeout waiting for ping.
+
+Args:
+  <ip>        IP address to ping.
+  [<count>]   Number of packets to send
+$ ping 1.2.3.4 5
+Would ping: 1.2.3.4 with timeout 5s and count 0
+```
+
+From the following source:
+
+```go
+package main
+
+import (
+  "fmt"
+
+  "gopkg.in/alecthomas/kingpin.v2"
+)
+
+var (
+  debug   = kingpin.Flag("debug", "Enable debug mode.").Bool()
+  timeout = kingpin.Flag("timeout", "Timeout waiting for ping.").Default("5s").OverrideDefaultFromEnvar("PING_TIMEOUT").Short('t').Duration()
+  ip      = kingpin.Arg("ip", "IP address to ping.").Required().IP()
+  count   = kingpin.Arg("count", "Number of packets to send").Int()
+)
+
+func main() {
+  kingpin.Version("0.0.1")
+  kingpin.Parse()
+  fmt.Printf("Would ping: %s with timeout %s and count %d", *ip, *timeout, *count)
+}
+```
+
+### Complex Example
+
+Kingpin can also produce complex command-line applications with global flags,
+subcommands, and per-subcommand flags, like this:
+
+```
+$ chat --help
+usage: chat [<flags>] <command> [<flags>] [<args> ...]
+
+A command-line chat application.
+
+Flags:
+  --help              Show help.
+  --debug             Enable debug mode.
+  --server=127.0.0.1  Server address.
+
+Commands:
+  help [<command>]
+    Show help for a command.
+
+  register <nick> <name>
+    Register a new user.
+
+  post [<flags>] <channel> [<text>]
+    Post a message to a channel.
+
+$ chat help post
+usage: chat [<flags>] post [<flags>] <channel> [<text>]
+
+Post a message to a channel.
+
+Flags:
+  --image=IMAGE  Image to post.
+
+Args:
+  <channel>  Channel to post to.
+  [<text>]   Text to post.
+
+$ chat post --image=~/Downloads/owls.jpg pics
+...
+```
+
+From this code:
+
+```go
+package main
+
+import (
+  "os"
+  "strings"
+  "gopkg.in/alecthomas/kingpin.v2"
+)
+
+var (
+  app      = kingpin.New("chat", "A command-line chat application.")
+  debug    = app.Flag("debug", "Enable debug mode.").Bool()
+  serverIP = app.Flag("server", "Server address.").Default("127.0.0.1").IP()
+
+  register     = app.Command("register", "Register a new user.")
+  registerNick = register.Arg("nick", "Nickname for user.").Required().String()
+  registerName = register.Arg("name", "Name of user.").Required().String()
+
+  post        = app.Command("post", "Post a message to a channel.")
+  postImage   = post.Flag("image", "Image to post.").File()
+  postChannel = post.Arg("channel", "Channel to post to.").Required().String()
+  postText    = post.Arg("text", "Text to post.").Strings()
+)
+
+func main() {
+  switch kingpin.MustParse(app.Parse(os.Args[1:])) {
+  // Register user
+  case register.FullCommand():
+    println(*registerNick)
+
+  // Post message
+  case post.FullCommand():
+    if *postImage != nil {
+    }
+    text := strings.Join(*postText, " ")
+    println("Post:", text)
+  }
+}
+```
+
+## Reference Documentation
+
+### Displaying errors and usage information
+
+Kingpin exports a set of functions to provide consistent errors and usage
+information to the user.
+
+Error messages look something like this:
+
+    <app>: error: <message>
+
+The functions on `Application` are:
+
+Function | Purpose
+---------|--------------
+`Errorf(format, args)` | Display a printf formatted error to the user.
+`Fatalf(format, args)` | As with Errorf, but also call the termination handler.
+`FatalUsage(format, args)` | As with Fatalf, but also print contextual usage information.
+`FatalUsageContext(context, format, args)` | As with Fatalf, but also print contextual usage information from a `ParseContext`.
+`FatalIfError(err, format, args)` | Conditionally print an error prefixed with format+args, then call the termination handler
+
+There are equivalent global functions in the kingpin namespace for the default
+`kingpin.CommandLine` instance.
+
+### Sub-commands
+
+Kingpin supports nested sub-commands, with separate flag and positional
+arguments per sub-command. Note that positional arguments may only occur after
+sub-commands.
+
+For example:
+
+```go
+var (
+  deleteCommand     = kingpin.Command("delete", "Delete an object.")
+  deleteUserCommand = deleteCommand.Command("user", "Delete a user.")
+  deleteUserUIDFlag = deleteUserCommand.Flag("uid", "Delete user by UID rather than username.")
+  deleteUserUsername = deleteUserCommand.Arg("username", "Username to delete.")
+  deletePostCommand = deleteCommand.Command("post", "Delete a post.")
+)
+
+func main() {
+  switch kingpin.Parse() {
+  case "delete user":
+  case "delete post":
+  }
+}
+```
+
+### Custom Parsers
+
+Kingpin supports both flag and positional argument parsers for converting to
+Go types. For example, some included parsers are `Int()`, `Float()`,
+`Duration()` and `ExistingFile()`.
+
+Parsers conform to Go's [`flag.Value`](http://godoc.org/flag#Value)
+interface, so any existing implementations will work.
+
+For example, a parser for accumulating HTTP header values might look like this:
+
+```go
+type HTTPHeaderValue http.Header
+
+func (h *HTTPHeaderValue) Set(value string) error {
+  parts := strings.SplitN(value, ":", 2)
+  if len(parts) != 2 {
+    return fmt.Errorf("expected HEADER:VALUE got '%s'", value)
+  }
+  (*http.Header)(h).Add(parts[0], parts[1])
+  return nil
+}
+
+func (h *HTTPHeaderValue) String() string {
+  return ""
+}
+```
+
+As a convenience, I would recommend something like this:
+
+```go
+func HTTPHeader(s Settings) (target *http.Header) {
+  target = new(http.Header)
+  s.SetValue((*HTTPHeaderValue)(target))
+  return
+}
+```
+
+You would use it like so:
+
+```go
+headers = HTTPHeader(kingpin.Flag("header", "Add a HTTP header to the request.").Short('H'))
+```
+
+### Default Values
+
+The default value is the zero value for a type. This can be overridden with
+the `Default(value)` function on flags and arguments. This function accepts a
+string, which is parsed by the value itself, so it *must* be compliant with
+the format expected.
+
+### Place-holders in Help
+
+The place-holder value for a flag is the value used in the help to describe
+the value of a non-boolean flag.
+
+The value provided to PlaceHolder() is used if provided, then the value
+provided by Default() if provided, then finally the capitalised flag name is
+used.
+
+Here are some examples of flags with various permutations:
+
+    --name=NAME           // Flag(...).String()
+    --name="Harry"        // Flag(...).Default("Harry").String()
+    --name=FULL-NAME      // flag(...).PlaceHolder("FULL-NAME").Default("Harry").String()
+
+### Consuming all remaining arguments
+
+A common command-line idiom is to use all remaining arguments for some
+purpose. eg. The following command accepts an arbitrary number of
+IP addresses as positional arguments:
+
+    ./cmd ping 10.1.1.1 192.168.1.1
+
+Kingpin supports this by having `Value` provide a `IsCumulative() bool`
+function. If this function exists and returns true, the value parser will be
+called repeatedly for every remaining argument.
+
+Examples of this are the `Strings()` and `StringMap()` values.
+
+To implement the above example we might do something like this:
+
+```go
+type ipList []net.IP
+
+func (i *ipList) Set(value string) error {
+  if ip := net.ParseIP(value); ip == nil {
+    return fmt.Errorf("'%s' is not an IP address", value)
+  } else {
+    *i = append(*i, ip)
+    return nil
+  }
+}
+
+func (i *ipList) String() string {
+  return ""
+}
+
+func (i *ipList) IsCumulative() bool {
+  return true
+}
+
+func IPList(s Settings) (target *[]net.IP) {
+  target = new([]net.IP)
+  s.SetValue((*ipList)(target))
+  return
+}
+```
+
+And use it like so:
+
+```go
+ips := IPList(kingpin.Arg("ips", "IP addresses to ping."))
+```
+
+### Custom help
+
+Kingpin v2 supports templatised help using the text/template library (actually, [a fork](https://github.com/alecthomas/template)).
+
+You can specify the template to use with the [Application.UsageTemplate()](http://godoc.org/gopkg.in/alecthomas/kingpin.v2#Application.UsageTemplate) function.
+
+There are three included templates: `kingpin.DefaultUsageTemplate` is the default,
+`kingpin.CompactUsageTemplate` provides a more compact representation for more complex command-line structures, and `kingpin.ManPageTemplate` is used to generate man pages.
+
+See the above templates for examples of usage, and the the function [UsageForContextWithTemplate()](https://github.com/alecthomas/kingpin/blob/master/usage.go#L198) method for details on the context.
+
+#### Default help template
+
+```
+$ go run ./examples/curl/curl.go --help
+usage: curl [<flags>] <command> [<args> ...]
+
+An example implementation of curl.
+
+Flags:
+  --help            Show help.
+  -t, --timeout=5s  Set connection timeout.
+  -H, --headers=HEADER=VALUE
+                    Add HTTP headers to the request.
+
+Commands:
+  help [<command>...]
+    Show help.
+
+  get url <url>
+    Retrieve a URL.
+
+  get file <file>
+    Retrieve a file.
+
+  post [<flags>] <url>
+    POST a resource.
+```
+
+#### Compact help template
+
+```
+$ go run ./examples/curl/curl.go --help
+usage: curl [<flags>] <command> [<args> ...]
+
+An example implementation of curl.
+
+Flags:
+  --help            Show help.
+  -t, --timeout=5s  Set connection timeout.
+  -H, --headers=HEADER=VALUE
+                    Add HTTP headers to the request.
+
+Commands:
+  help [<command>...]
+  get [<flags>]
+    url <url>
+    file <file>
+  post [<flags>] <url>
+```
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/app.go b/vendor/gopkg.in/alecthomas/kingpin.v2/app.go
new file mode 100644
index 00000000..be4a4c4c
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/app.go
@@ -0,0 +1,564 @@
+package kingpin
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+var (
+	ErrCommandNotSpecified = fmt.Errorf("command not specified")
+)
+
+// Action callback executed at various stages after all values are populated.
+// The application, commands, arguments and flags all have corresponding
+// actions.
+type Action func(*ParseContext) error
+
+type ApplicationValidator func(*Application) error
+
+// An Application contains the definitions of flags, arguments and commands
+// for an application.
+type Application struct {
+	*flagGroup
+	*argGroup
+	*cmdGroup
+	initialized   bool
+	Name          string
+	Help          string
+	author        string
+	version       string
+	writer        io.Writer // Destination for usage and errors.
+	usageTemplate string
+	action        Action
+	preAction     Action
+	validator     ApplicationValidator
+	terminate     func(status int) // See Terminate()
+}
+
+// New creates a new Kingpin application instance.
+func New(name, help string) *Application {
+	a := &Application{
+		flagGroup:     newFlagGroup(),
+		argGroup:      newArgGroup(),
+		Name:          name,
+		Help:          help,
+		writer:        os.Stderr,
+		usageTemplate: DefaultUsageTemplate,
+		terminate:     os.Exit,
+	}
+	a.cmdGroup = newCmdGroup(a)
+	a.Flag("help", "Show help (also see --help-long and --help-man).").Bool()
+	a.Flag("help-long", "Generate long help.").Hidden().PreAction(a.generateLongHelp).Bool()
+	a.Flag("help-man", "Generate a man page.").Hidden().PreAction(a.generateManPage).Bool()
+	return a
+}
+
+func (a *Application) generateLongHelp(c *ParseContext) error {
+	a.Writer(os.Stdout)
+	if err := a.UsageForContextWithTemplate(c, 2, LongHelpTemplate); err != nil {
+		return err
+	}
+	a.terminate(0)
+	return nil
+}
+
+func (a *Application) generateManPage(c *ParseContext) error {
+	a.Writer(os.Stdout)
+	if err := a.UsageForContextWithTemplate(c, 2, ManPageTemplate); err != nil {
+		return err
+	}
+	a.terminate(0)
+	return nil
+}
+
+// Terminate specifies the termination handler. Defaults to os.Exit(status).
+// If nil is passed, a no-op function will be used.
+func (a *Application) Terminate(terminate func(int)) *Application {
+	if terminate == nil {
+		terminate = func(int) {}
+	}
+	a.terminate = terminate
+	return a
+}
+
+// Specify the writer to use for usage and errors. Defaults to os.Stderr.
+func (a *Application) Writer(w io.Writer) *Application {
+	a.writer = w
+	return a
+}
+
+// UsageTemplate specifies the text template to use when displaying usage
+// information. The default is UsageTemplate.
+func (a *Application) UsageTemplate(template string) *Application {
+	a.usageTemplate = template
+	return a
+}
+
+// Validate sets a validation function to run when parsing.
+func (a *Application) Validate(validator ApplicationValidator) *Application {
+	a.validator = validator
+	return a
+}
+
+// ParseContext parses the given command line and returns the fully populated
+// ParseContext.
+func (a *Application) ParseContext(args []string) (*ParseContext, error) {
+	if err := a.init(); err != nil {
+		return nil, err
+	}
+	context := tokenize(args)
+	_, err := parse(context, a)
+	return context, err
+}
+
+// Parse parses command-line arguments. It returns the selected command and an
+// error. The selected command will be a space separated subcommand, if
+// subcommands have been configured.
+//
+// This will populate all flag and argument values, call all callbacks, and so
+// on.
+func (a *Application) Parse(args []string) (command string, err error) {
+	context, err := a.ParseContext(args)
+	if err != nil {
+		if a.hasHelp(args) {
+			a.writeUsage(context, err)
+		}
+		return "", err
+	}
+	a.maybeHelp(context)
+	if !context.EOL() {
+		return "", fmt.Errorf("unexpected argument '%s'", context.Peek())
+	}
+	command, err = a.execute(context)
+	if err == ErrCommandNotSpecified {
+		a.writeUsage(context, nil)
+	}
+	return command, err
+}
+
+func (a *Application) writeUsage(context *ParseContext, err error) {
+	if err != nil {
+		a.Errorf("%s", err)
+	}
+	if err := a.UsageForContext(context); err != nil {
+		panic(err)
+	}
+	a.terminate(1)
+}
+
+func (a *Application) hasHelp(args []string) bool {
+	for _, arg := range args {
+		if arg == "--help" {
+			return true
+		}
+	}
+	return false
+}
+
+func (a *Application) maybeHelp(context *ParseContext) {
+	for _, element := range context.Elements {
+		if flag, ok := element.Clause.(*FlagClause); ok && flag.name == "help" {
+			a.writeUsage(context, nil)
+		}
+	}
+}
+
+// findCommandFromArgs finds a command (if any) from the given command line arguments.
+func (a *Application) findCommandFromArgs(args []string) (command string, err error) {
+	if err := a.init(); err != nil {
+		return "", err
+	}
+	context := tokenize(args)
+	if err := a.parse(context); err != nil {
+		return "", err
+	}
+	return a.findCommandFromContext(context), nil
+}
+
+// findCommandFromContext finds a command (if any) from a parsed context.
+func (a *Application) findCommandFromContext(context *ParseContext) string {
+	commands := []string{}
+	for _, element := range context.Elements {
+		if c, ok := element.Clause.(*CmdClause); ok {
+			commands = append(commands, c.name)
+		}
+	}
+	return strings.Join(commands, " ")
+}
+
+// Version adds a --version flag for displaying the application version.
+func (a *Application) Version(version string) *Application {
+	a.version = version
+	a.Flag("version", "Show application version.").Action(func(*ParseContext) error {
+		fmt.Println(version)
+		a.terminate(0)
+		return nil
+	}).Bool()
+	return a
+}
+
+func (a *Application) Author(author string) *Application {
+	a.author = author
+	return a
+}
+
+// Action callback to call when all values are populated and parsing is
+// complete, but before any command, flag or argument actions.
+//
+// All Action() callbacks are called in the order they are encountered on the
+// command line.
+func (a *Application) Action(action Action) *Application {
+	a.action = action
+	return a
+}
+
+// Action called after parsing completes but before validation and execution.
+func (a *Application) PreAction(action Action) *Application {
+	a.preAction = action
+	return a
+}
+
+// Command adds a new top-level command.
+func (a *Application) Command(name, help string) *CmdClause {
+	return a.addCommand(name, help)
+}
+
+func (a *Application) init() error {
+	if a.initialized {
+		return nil
+	}
+	if a.cmdGroup.have() && a.argGroup.have() {
+		return fmt.Errorf("can't mix top-level Arg()s with Command()s")
+	}
+
+	// If we have subcommands, add a help command at the top-level.
+	if a.cmdGroup.have() {
+		var command []string
+		help := a.Command("help", "Show help.").Action(func(c *ParseContext) error {
+			a.Usage(command)
+			a.terminate(0)
+			return nil
+		})
+		help.Arg("command", "Show help on command.").StringsVar(&command)
+		// Make help first command.
+		l := len(a.commandOrder)
+		a.commandOrder = append(a.commandOrder[l-1:l], a.commandOrder[:l-1]...)
+	}
+
+	if err := a.flagGroup.init(); err != nil {
+		return err
+	}
+	if err := a.cmdGroup.init(); err != nil {
+		return err
+	}
+	if err := a.argGroup.init(); err != nil {
+		return err
+	}
+	for _, cmd := range a.commands {
+		if err := cmd.init(); err != nil {
+			return err
+		}
+	}
+	flagGroups := []*flagGroup{a.flagGroup}
+	for _, cmd := range a.commandOrder {
+		if err := checkDuplicateFlags(cmd, flagGroups); err != nil {
+			return err
+		}
+	}
+	a.initialized = true
+	return nil
+}
+
+// Recursively check commands for duplicate flags.
+func checkDuplicateFlags(current *CmdClause, flagGroups []*flagGroup) error {
+	// Check for duplicates.
+	for _, flags := range flagGroups {
+		for _, flag := range current.flagOrder {
+			if flag.shorthand != 0 {
+				if _, ok := flags.short[string(flag.shorthand)]; ok {
+					return fmt.Errorf("duplicate short flag -%c", flag.shorthand)
+				}
+			}
+			if _, ok := flags.long[flag.name]; ok {
+				return fmt.Errorf("duplicate long flag --%s", flag.name)
+			}
+		}
+	}
+	flagGroups = append(flagGroups, current.flagGroup)
+	// Check subcommands.
+	for _, subcmd := range current.commandOrder {
+		if err := checkDuplicateFlags(subcmd, flagGroups); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (a *Application) execute(context *ParseContext) (string, error) {
+	var err error
+	selected := []string{}
+
+	if err = a.setDefaults(context); err != nil {
+		return "", err
+	}
+
+	selected, err = a.setValues(context)
+	if err != nil {
+		return "", err
+	}
+
+	if err = a.applyPreActions(context); err != nil {
+		return "", err
+	}
+
+	if err = a.validateRequired(context); err != nil {
+		return "", err
+	}
+
+	if err = a.applyValidators(context); err != nil {
+		return "", err
+	}
+
+	if err = a.applyActions(context); err != nil {
+		return "", err
+	}
+
+	command := strings.Join(selected, " ")
+	if command == "" && a.cmdGroup.have() {
+		return "", ErrCommandNotSpecified
+	}
+	return command, err
+}
+
+func (a *Application) setDefaults(context *ParseContext) error {
+	flagElements := map[string]*ParseElement{}
+	for _, element := range context.Elements {
+		if flag, ok := element.Clause.(*FlagClause); ok {
+			flagElements[flag.name] = element
+		}
+	}
+
+	argElements := map[string]*ParseElement{}
+	for _, element := range context.Elements {
+		if arg, ok := element.Clause.(*ArgClause); ok {
+			argElements[arg.name] = element
+		}
+	}
+
+	// Check required flags and set defaults.
+	for _, flag := range context.flags.long {
+		if flagElements[flag.name] == nil {
+			// Set defaults, if any.
+			if flag.defaultValue != "" {
+				if err := flag.value.Set(flag.defaultValue); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	for _, arg := range context.arguments.args {
+		if argElements[arg.name] == nil {
+			// Set defaults, if any.
+			if arg.defaultValue != "" {
+				if err := arg.value.Set(arg.defaultValue); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (a *Application) validateRequired(context *ParseContext) error {
+	flagElements := map[string]*ParseElement{}
+	for _, element := range context.Elements {
+		if flag, ok := element.Clause.(*FlagClause); ok {
+			flagElements[flag.name] = element
+		}
+	}
+
+	argElements := map[string]*ParseElement{}
+	for _, element := range context.Elements {
+		if arg, ok := element.Clause.(*ArgClause); ok {
+			argElements[arg.name] = element
+		}
+	}
+
+	// Check required flags and set defaults.
+	for _, flag := range context.flags.long {
+		if flagElements[flag.name] == nil {
+			// Check required flags were provided.
+			if flag.needsValue() {
+				return fmt.Errorf("required flag --%s not provided", flag.name)
+			}
+		}
+	}
+
+	for _, arg := range context.arguments.args {
+		if argElements[arg.name] == nil {
+			if arg.required {
+				return fmt.Errorf("required argument '%s' not provided", arg.name)
+			}
+		}
+	}
+	return nil
+}
+
+func (a *Application) setValues(context *ParseContext) (selected []string, err error) {
+	// Set all arg and flag values.
+	var lastCmd *CmdClause
+	for _, element := range context.Elements {
+		switch clause := element.Clause.(type) {
+		case *FlagClause:
+			if err = clause.value.Set(*element.Value); err != nil {
+				return
+			}
+
+		case *ArgClause:
+			if err = clause.value.Set(*element.Value); err != nil {
+				return
+			}
+
+		case *CmdClause:
+			if clause.validator != nil {
+				if err = clause.validator(clause); err != nil {
+					return
+				}
+			}
+			selected = append(selected, clause.name)
+			lastCmd = clause
+		}
+	}
+
+	if lastCmd != nil && len(lastCmd.commands) > 0 {
+		return nil, fmt.Errorf("must select a subcommand of '%s'", lastCmd.FullCommand())
+	}
+
+	return
+}
+
+func (a *Application) applyValidators(context *ParseContext) (err error) {
+	// Call command validation functions.
+	for _, element := range context.Elements {
+		if cmd, ok := element.Clause.(*CmdClause); ok && cmd.validator != nil {
+			if err = cmd.validator(cmd); err != nil {
+				return err
+			}
+		}
+	}
+
+	if a.validator != nil {
+		err = a.validator(a)
+	}
+	return err
+}
+
+func (a *Application) applyPreActions(context *ParseContext) error {
+	if a.preAction != nil {
+		if err := a.preAction(context); err != nil {
+			return err
+		}
+	}
+	// Dispatch to actions.
+	for _, element := range context.Elements {
+		switch clause := element.Clause.(type) {
+		case *ArgClause:
+			if clause.preAction != nil {
+				if err := clause.preAction(context); err != nil {
+					return err
+				}
+			}
+		case *CmdClause:
+			if clause.preAction != nil {
+				if err := clause.preAction(context); err != nil {
+					return err
+				}
+			}
+		case *FlagClause:
+			if clause.preAction != nil {
+				if err := clause.preAction(context); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (a *Application) applyActions(context *ParseContext) error {
+	if a.action != nil {
+		if err := a.action(context); err != nil {
+			return err
+		}
+	}
+	// Dispatch to actions.
+	for _, element := range context.Elements {
+		switch clause := element.Clause.(type) {
+		case *ArgClause:
+			if clause.action != nil {
+				if err := clause.action(context); err != nil {
+					return err
+				}
+			}
+		case *CmdClause:
+			if clause.action != nil {
+				if err := clause.action(context); err != nil {
+					return err
+				}
+			}
+		case *FlagClause:
+			if clause.action != nil {
+				if err := clause.action(context); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// Errorf prints an error message to w in the format "<appname>: error: <message>".
+func (a *Application) Errorf(format string, args ...interface{}) {
+	fmt.Fprintf(a.writer, a.Name+": error: "+format+"\n", args...)
+}
+
+// Fatalf writes a formatted error to w then terminates with exit status 1.
+func (a *Application) Fatalf(format string, args ...interface{}) {
+	a.Errorf(format, args...)
+	a.terminate(1)
+}
+
+// FatalUsage prints an error message followed by usage information, then
+// exits with a non-zero status.
+func (a *Application) FatalUsage(format string, args ...interface{}) {
+	a.Errorf(format, args...)
+	a.Usage([]string{})
+	a.terminate(1)
+}
+
+// FatalUsageContext writes a printf formatted error message to w, then usage
+// information for the given ParseContext, before exiting.
+func (a *Application) FatalUsageContext(context *ParseContext, format string, args ...interface{}) {
+	a.Errorf(format, args...)
+	if err := a.UsageForContext(context); err != nil {
+		panic(err)
+	}
+	a.terminate(1)
+}
+
+// FatalIfError prints an error and exits if err is not nil. The error is printed
+// with the given formatted string, if any.
+func (a *Application) FatalIfError(err error, format string, args ...interface{}) {
+	if err != nil {
+		prefix := ""
+		if format != "" {
+			prefix = fmt.Sprintf(format, args...) + ": "
+		}
+		a.Errorf(prefix+"%s", err)
+		a.terminate(1)
+	}
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/args.go b/vendor/gopkg.in/alecthomas/kingpin.v2/args.go
new file mode 100644
index 00000000..e15fc096
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/args.go
@@ -0,0 +1,106 @@
+package kingpin
+
+import "fmt"
+
+type argGroup struct {
+	args []*ArgClause
+}
+
+func newArgGroup() *argGroup {
+	return &argGroup{}
+}
+
+func (a *argGroup) have() bool {
+	return len(a.args) > 0
+}
+
+func (a *argGroup) Arg(name, help string) *ArgClause {
+	arg := newArg(name, help)
+	a.args = append(a.args, arg)
+	return arg
+}
+
+func (a *argGroup) init() error {
+	required := 0
+	seen := map[string]struct{}{}
+	previousArgMustBeLast := false
+	for i, arg := range a.args {
+		if previousArgMustBeLast {
+			return fmt.Errorf("Args() can't be followed by another argument '%s'", arg.name)
+		}
+		if arg.consumesRemainder() {
+			previousArgMustBeLast = true
+		}
+		if _, ok := seen[arg.name]; ok {
+			return fmt.Errorf("duplicate argument '%s'", arg.name)
+		}
+		seen[arg.name] = struct{}{}
+		if arg.required && required != i {
+			return fmt.Errorf("required arguments found after non-required")
+		}
+		if arg.required {
+			required++
+		}
+		if err := arg.init(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type ArgClause struct {
+	parserMixin
+	name         string
+	help         string
+	defaultValue string
+	required     bool
+	action       Action
+	preAction    Action
+}
+
+func newArg(name, help string) *ArgClause {
+	a := &ArgClause{
+		name: name,
+		help: help,
+	}
+	return a
+}
+
+func (a *ArgClause) consumesRemainder() bool {
+	if r, ok := a.value.(remainderArg); ok {
+		return r.IsCumulative()
+	}
+	return false
+}
+
+// Required arguments must be input by the user. They can not have a Default() value provided.
+func (a *ArgClause) Required() *ArgClause {
+	a.required = true
+	return a
+}
+
+// Default value for this argument. It *must* be parseable by the value of the argument.
+func (a *ArgClause) Default(value string) *ArgClause {
+	a.defaultValue = value
+	return a
+}
+
+func (a *ArgClause) Action(action Action) *ArgClause {
+	a.action = action
+	return a
+}
+
+func (a *ArgClause) PreAction(action Action) *ArgClause {
+	a.preAction = action
+	return a
+}
+
+func (a *ArgClause) init() error {
+	if a.required && a.defaultValue != "" {
+		return fmt.Errorf("required argument '%s' with unusable default value", a.name)
+	}
+	if a.value == nil {
+		return fmt.Errorf("no parser defined for arg '%s'", a.name)
+	}
+	return nil
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/cmd.go b/vendor/gopkg.in/alecthomas/kingpin.v2/cmd.go
new file mode 100644
index 00000000..00161bb2
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/cmd.go
@@ -0,0 +1,129 @@
+package kingpin
+
+import (
+	"fmt"
+	"strings"
+)
+
+type cmdGroup struct {
+	app          *Application
+	parent       *CmdClause
+	commands     map[string]*CmdClause
+	commandOrder []*CmdClause
+}
+
+func newCmdGroup(app *Application) *cmdGroup {
+	return &cmdGroup{
+		app:      app,
+		commands: make(map[string]*CmdClause),
+	}
+}
+
+func (c *cmdGroup) flattenedCommands() (out []*CmdClause) {
+	for _, cmd := range c.commandOrder {
+		if len(cmd.commands) == 0 {
+			out = append(out, cmd)
+		}
+		out = append(out, cmd.flattenedCommands()...)
+	}
+	return
+}
+
+func (c *cmdGroup) addCommand(name, help string) *CmdClause {
+	cmd := newCommand(c.app, name, help)
+	c.commands[name] = cmd
+	c.commandOrder = append(c.commandOrder, cmd)
+	return cmd
+}
+
+func (c *cmdGroup) init() error {
+	seen := map[string]bool{}
+	for _, cmd := range c.commandOrder {
+		if seen[cmd.name] {
+			return fmt.Errorf("duplicate command '%s'", cmd.name)
+		}
+		seen[cmd.name] = true
+		if err := cmd.init(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+func (c *cmdGroup) have() bool {
+	return len(c.commands) > 0
+}
+
+type CmdClauseValidator func(*CmdClause) error
+
+// A CmdClause is a single top-level command. It encapsulates a set of flags
+// and either subcommands or positional arguments.
+type CmdClause struct {
+	*flagGroup
+	*argGroup
+	*cmdGroup
+	app       *Application
+	name      string
+	help      string
+	action    Action
+	preAction Action
+	validator CmdClauseValidator
+}
+
+func newCommand(app *Application, name, help string) *CmdClause {
+	c := &CmdClause{
+		flagGroup: newFlagGroup(),
+		argGroup:  newArgGroup(),
+		cmdGroup:  newCmdGroup(app),
+		app:       app,
+		name:      name,
+		help:      help,
+	}
+	return c
+}
+
+// Validate sets a validation function to run when parsing.
+func (c *CmdClause) Validate(validator CmdClauseValidator) *CmdClause {
+	c.validator = validator
+	return c
+}
+
+func (c *CmdClause) FullCommand() string {
+	out := []string{c.name}
+	for p := c.parent; p != nil; p = p.parent {
+		out = append([]string{p.name}, out...)
+	}
+	return strings.Join(out, " ")
+}
+
+// Command adds a new sub-command.
+func (c *CmdClause) Command(name, help string) *CmdClause {
+	cmd := c.addCommand(name, help)
+	cmd.parent = c
+	return cmd
+}
+
+func (c *CmdClause) Action(action Action) *CmdClause {
+	c.action = action
+	return c
+}
+
+func (c *CmdClause) PreAction(action Action) *CmdClause {
+	c.preAction = action
+	return c
+}
+
+func (c *CmdClause) init() error {
+	if err := c.flagGroup.init(); err != nil {
+		return err
+	}
+	if c.argGroup.have() && c.cmdGroup.have() {
+		return fmt.Errorf("can't mix Arg()s with Command()s")
+	}
+	if err := c.argGroup.init(); err != nil {
+		return err
+	}
+	if err := c.cmdGroup.init(); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/doc.go b/vendor/gopkg.in/alecthomas/kingpin.v2/doc.go
new file mode 100644
index 00000000..c14762c5
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/doc.go
@@ -0,0 +1,68 @@
+// Package kingpin provides command line interfaces like this:
+//
+//     $ chat
+//     usage: chat [<flags>] <command> [<flags>] [<args> ...]
+//
+//     Flags:
+//       --debug              enable debug mode
+//       --help               Show help.
+//       --server=127.0.0.1   server address
+//
+//     Commands:
+//       help <command>
+//         Show help for a command.
+//
+//       post [<flags>] <channel>
+//         Post a message to a channel.
+//
+//       register <nick> <name>
+//         Register a new user.
+//
+//     $ chat help post
+//     usage: chat [<flags>] post [<flags>] <channel> [<text>]
+//
+//     Post a message to a channel.
+//
+//     Flags:
+//       --image=IMAGE   image to post
+//
+//     Args:
+//       <channel>   channel to post to
+//       [<text>]    text to post
+//     $ chat post --image=~/Downloads/owls.jpg pics
+//
+// From code like this:
+//
+//     package main
+//
+//     import "gopkg.in/alecthomas/kingpin.v1"
+//
+//     var (
+//       debug    = kingpin.Flag("debug", "enable debug mode").Default("false").Bool()
+//       serverIP = kingpin.Flag("server", "server address").Default("127.0.0.1").IP()
+//
+//       register     = kingpin.Command("register", "Register a new user.")
+//       registerNick = register.Arg("nick", "nickname for user").Required().String()
+//       registerName = register.Arg("name", "name of user").Required().String()
+//
+//       post        = kingpin.Command("post", "Post a message to a channel.")
+//       postImage   = post.Flag("image", "image to post").ExistingFile()
+//       postChannel = post.Arg("channel", "channel to post to").Required().String()
+//       postText    = post.Arg("text", "text to post").String()
+//     )
+//
+//     func main() {
+//       switch kingpin.Parse() {
+//       // Register user
+//       case "register":
+//         println(*registerNick)
+//
+//       // Post message
+//       case "post":
+//         if *postImage != nil {
+//         }
+//         if *postText != "" {
+//         }
+//       }
+//     }
+package kingpin
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/examples/chat1/main.go b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/chat1/main.go
new file mode 100644
index 00000000..375d2f6a
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/chat1/main.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/alecthomas/kingpin"
+)
+
+var (
+	debug   = kingpin.Flag("debug", "Enable debug mode.").Bool()
+	timeout = kingpin.Flag("timeout", "Timeout waiting for ping.").Default("5s").OverrideDefaultFromEnvar("PING_TIMEOUT").Short('t').Duration()
+	ip      = kingpin.Arg("ip", "IP address to ping.").Required().IP()
+	count   = kingpin.Arg("count", "Number of packets to send").Int()
+)
+
+func main() {
+	kingpin.Version("0.0.1")
+	kingpin.Parse()
+	fmt.Printf("Would ping: %s with timeout %s and count %d", *ip, *timeout, *count)
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/examples/chat2/main.go b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/chat2/main.go
new file mode 100644
index 00000000..e7e84efb
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/chat2/main.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"os"
+	"strings"
+
+	"github.com/alecthomas/kingpin"
+)
+
+var (
+	app      = kingpin.New("chat", "A command-line chat application.")
+	debug    = app.Flag("debug", "Enable debug mode.").Bool()
+	serverIP = app.Flag("server", "Server address.").Default("127.0.0.1").IP()
+
+	register     = app.Command("register", "Register a new user.")
+	registerNick = register.Arg("nick", "Nickname for user.").Required().String()
+	registerName = register.Arg("name", "Name of user.").Required().String()
+
+	post        = app.Command("post", "Post a message to a channel.")
+	postImage   = post.Flag("image", "Image to post.").File()
+	postChannel = post.Arg("channel", "Channel to post to.").Required().String()
+	postText    = post.Arg("text", "Text to post.").Strings()
+)
+
+func main() {
+	switch kingpin.MustParse(app.Parse(os.Args[1:])) {
+	// Register user
+	case register.FullCommand():
+		println(*registerNick)
+
+	// Post message
+	case post.FullCommand():
+		if *postImage != nil {
+		}
+		text := strings.Join(*postText, " ")
+		println("Post:", text)
+	}
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/examples/curl/main.go b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/curl/main.go
new file mode 100644
index 00000000..af387f82
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/curl/main.go
@@ -0,0 +1,105 @@
+// A curl-like HTTP command-line client.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/alecthomas/kingpin"
+)
+
+var (
+	timeout = kingpin.Flag("timeout", "Set connection timeout.").Short('t').Default("5s").Duration()
+	headers = HTTPHeader(kingpin.Flag("headers", "Add HTTP headers to the request.").Short('H').PlaceHolder("HEADER=VALUE"))
+
+	get         = kingpin.Command("get", "GET a resource.")
+	getFlag     = get.Flag("test", "Test flag").Bool()
+	getURL      = get.Command("url", "Retrieve a URL.")
+	getURLURL   = getURL.Arg("url", "URL to GET.").Required().URL()
+	getFile     = get.Command("file", "Retrieve a file.")
+	getFileFile = getFile.Arg("file", "File to retrieve.").Required().ExistingFile()
+
+	post           = kingpin.Command("post", "POST a resource.")
+	postData       = post.Flag("data", "Key-value data to POST").Short('d').PlaceHolder("KEY:VALUE").StringMap()
+	postBinaryFile = post.Flag("data-binary", "File with binary data to POST.").File()
+	postURL        = post.Arg("url", "URL to POST to.").Required().URL()
+)
+
+type HTTPHeaderValue http.Header
+
+func (h HTTPHeaderValue) Set(value string) error {
+	parts := strings.SplitN(value, "=", 2)
+	if len(parts) != 2 {
+		return fmt.Errorf("expected HEADER=VALUE got '%s'", value)
+	}
+	(http.Header)(h).Add(parts[0], parts[1])
+	return nil
+}
+
+func (h HTTPHeaderValue) String() string {
+	return ""
+}
+
+func HTTPHeader(s kingpin.Settings) (target *http.Header) {
+	target = &http.Header{}
+	s.SetValue((*HTTPHeaderValue)(target))
+	return
+}
+
+func applyRequest(req *http.Request) error {
+	req.Header = *headers
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return fmt.Errorf("HTTP request failed: %s", resp.Status)
+	}
+	_, err = io.Copy(os.Stdout, resp.Body)
+	return err
+}
+
+func apply(method string, url string) error {
+	req, err := http.NewRequest(method, url, nil)
+	if err != nil {
+		return err
+	}
+	return applyRequest(req)
+}
+
+func applyPOST() error {
+	req, err := http.NewRequest("POST", (*postURL).String(), nil)
+	if err != nil {
+		return err
+	}
+	if len(*postData) > 0 {
+		for key, value := range *postData {
+			req.Form.Set(key, value)
+		}
+	} else if postBinaryFile != nil {
+		if headers.Get("Content-Type") != "" {
+			headers.Set("Content-Type", "application/octet-stream")
+		}
+		req.Body = *postBinaryFile
+	} else {
+		return errors.New("--data or --data-binary must be provided to POST")
+	}
+	return applyRequest(req)
+}
+
+func main() {
+	kingpin.UsageTemplate(kingpin.CompactUsageTemplate).Version("1.0").Author("Alec Thomas")
+	kingpin.CommandLine.Help = "An example implementation of curl."
+	switch kingpin.Parse() {
+	case "get url":
+		kingpin.FatalIfError(apply("GET", (*getURLURL).String()), "GET failed")
+
+	case "post":
+		kingpin.FatalIfError(applyPOST(), "POST failed")
+	}
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/examples/modular/main.go b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/modular/main.go
new file mode 100644
index 00000000..7ac13c99
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/modular/main.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/alecthomas/kingpin"
+)
+
+// Context for "ls" command
+type LsCommand struct {
+	All bool
+}
+
+func (l *LsCommand) run(c *kingpin.ParseContext) error {
+	fmt.Printf("all=%v\n", l.All)
+	return nil
+}
+
+func configureLsCommand(app *kingpin.Application) {
+	c := &LsCommand{}
+	ls := app.Command("ls", "List files.").Action(c.run)
+	ls.Flag("all", "List all files.").Short('a').BoolVar(&c.All)
+}
+
+func main() {
+	app := kingpin.New("modular", "My modular application.")
+	configureLsCommand(app)
+	kingpin.MustParse(app.Parse(os.Args[1:]))
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/examples/ping/main.go b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/ping/main.go
new file mode 100644
index 00000000..c770521d
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/examples/ping/main.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/alecthomas/kingpin"
+)
+
+var (
+	debug   = kingpin.Flag("debug", "Enable debug mode.").Bool()
+	timeout = kingpin.Flag("timeout", "Timeout waiting for ping.").OverrideDefaultFromEnvar("PING_TIMEOUT").Required().Short('t').Duration()
+	ip      = kingpin.Arg("ip", "IP address to ping.").Required().IP()
+	count   = kingpin.Arg("count", "Number of packets to send").Int()
+)
+
+func main() {
+	kingpin.Version("0.0.1")
+	kingpin.Parse()
+	fmt.Printf("Would ping: %s with timeout %s and count %d", *ip, *timeout, *count)
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/flags.go b/vendor/gopkg.in/alecthomas/kingpin.v2/flags.go
new file mode 100644
index 00000000..75fe4f1a
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/flags.go
@@ -0,0 +1,235 @@
+package kingpin
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+type flagGroup struct {
+	short     map[string]*FlagClause
+	long      map[string]*FlagClause
+	flagOrder []*FlagClause
+}
+
+func newFlagGroup() *flagGroup {
+	return &flagGroup{
+		short: make(map[string]*FlagClause),
+		long:  make(map[string]*FlagClause),
+	}
+}
+
+func (f *flagGroup) merge(o *flagGroup) {
+	for _, flag := range o.flagOrder {
+		if flag.shorthand != 0 {
+			f.short[string(flag.shorthand)] = flag
+		}
+		f.long[flag.name] = flag
+		f.flagOrder = append(f.flagOrder, flag)
+	}
+}
+
+// Flag defines a new flag with the given long name and help.
+func (f *flagGroup) Flag(name, help string) *FlagClause {
+	flag := newFlag(name, help)
+	f.long[name] = flag
+	f.flagOrder = append(f.flagOrder, flag)
+	return flag
+}
+
+func (f *flagGroup) init() error {
+	for _, flag := range f.long {
+		if err := flag.init(); err != nil {
+			return err
+		}
+		if flag.shorthand != 0 {
+			f.short[string(flag.shorthand)] = flag
+		}
+	}
+	return nil
+}
+
+func (f *flagGroup) parse(context *ParseContext) error {
+	var token *Token
+
+loop:
+	for {
+		token = context.Peek()
+		switch token.Type {
+		case TokenEOL:
+			break loop
+
+		case TokenLong, TokenShort:
+			flagToken := token
+			defaultValue := ""
+			var flag *FlagClause
+			var ok bool
+			invert := false
+
+			name := token.Value
+			if token.Type == TokenLong {
+				if strings.HasPrefix(name, "no-") {
+					name = name[3:]
+					invert = true
+				}
+				flag, ok = f.long[name]
+				if !ok {
+					return fmt.Errorf("unknown long flag '%s'", flagToken)
+				}
+			} else {
+				flag, ok = f.short[name]
+				if !ok {
+					return fmt.Errorf("unknown short flag '%s'", flagToken)
+				}
+			}
+
+			context.Next()
+
+			fb, ok := flag.value.(boolFlag)
+			if ok && fb.IsBoolFlag() {
+				if invert {
+					defaultValue = "false"
+				} else {
+					defaultValue = "true"
+				}
+			} else {
+				if invert {
+					return fmt.Errorf("unknown long flag '%s'", flagToken)
+				}
+				token = context.Peek()
+				if token.Type != TokenArg {
+					return fmt.Errorf("expected argument for flag '%s'", flagToken)
+				}
+				context.Next()
+				defaultValue = token.Value
+			}
+
+			context.matchedFlag(flag, defaultValue)
+
+		default:
+			break loop
+		}
+	}
+	return nil
+}
+
+func (f *flagGroup) visibleFlags() int {
+	count := 0
+	for _, flag := range f.long {
+		if !flag.hidden {
+			count++
+		}
+	}
+	return count
+}
+
+// FlagClause is a fluid interface used to build flags.
+type FlagClause struct {
+	parserMixin
+	name         string
+	shorthand    byte
+	help         string
+	envar        string
+	defaultValue string
+	placeholder  string
+	action       Action
+	preAction    Action
+	hidden       bool
+}
+
+func newFlag(name, help string) *FlagClause {
+	f := &FlagClause{
+		name: name,
+		help: help,
+	}
+	return f
+}
+
+func (f *FlagClause) needsValue() bool {
+	return f.required && f.defaultValue == ""
+}
+
+func (f *FlagClause) formatPlaceHolder() string {
+	if f.placeholder != "" {
+		return f.placeholder
+	}
+	if f.defaultValue != "" {
+		if _, ok := f.value.(*stringValue); ok {
+			return fmt.Sprintf("%q", f.defaultValue)
+		}
+		return f.defaultValue
+	}
+	return strings.ToUpper(f.name)
+}
+
+func (f *FlagClause) init() error {
+	if f.required && f.defaultValue != "" {
+		return fmt.Errorf("required flag '--%s' with default value that will never be used", f.name)
+	}
+	if f.value == nil {
+		return fmt.Errorf("no type defined for --%s (eg. .String())", f.name)
+	}
+	if f.envar != "" {
+		if v := os.Getenv(f.envar); v != "" {
+			f.defaultValue = v
+		}
+	}
+	return nil
+}
+
+// Dispatch to the given function after the flag is parsed and validated.
+func (f *FlagClause) Action(action Action) *FlagClause {
+	f.action = action
+	return f
+}
+
+func (f *FlagClause) PreAction(action Action) *FlagClause {
+	f.preAction = action
+	return f
+}
+
+// Default value for this flag. It *must* be parseable by the value of the flag.
+func (f *FlagClause) Default(value string) *FlagClause {
+	f.defaultValue = value
+	return f
+}
+
+// OverrideDefaultFromEnvar overrides the default value for a flag from an
+// environment variable, if available.
+func (f *FlagClause) OverrideDefaultFromEnvar(envar string) *FlagClause {
+	f.envar = envar
+	return f
+}
+
+// PlaceHolder sets the place-holder string used for flag values in the help. The
+// default behaviour is to use the value provided by Default() if provided,
+// then fall back on the capitalized flag name.
+func (f *FlagClause) PlaceHolder(placeholder string) *FlagClause {
+	f.placeholder = placeholder
+	return f
+}
+
+// Hidden hides a flag from usage but still allows it to be used.
+func (f *FlagClause) Hidden() *FlagClause {
+	f.hidden = true
+	return f
+}
+
+// Required makes the flag required. You can not provide a Default() value to a Required() flag.
+func (f *FlagClause) Required() *FlagClause {
+	f.required = true
+	return f
+}
+
+// Short sets the short flag name.
+func (f *FlagClause) Short(name byte) *FlagClause {
+	f.shorthand = name
+	return f
+}
+
+// Bool makes this flag a boolean flag.
+func (f *FlagClause) Bool() (target *bool) {
+	target = new(bool)
+	f.SetValue(newBoolValue(target))
+	return
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/genrepeated/main.go b/vendor/gopkg.in/alecthomas/kingpin.v2/genrepeated/main.go
new file mode 100644
index 00000000..ea1245f9
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/genrepeated/main.go
@@ -0,0 +1,75 @@
+package main
+
+import (
+	"encoding/json"
+	"os/exec"
+	"strings"
+	"text/template"
+
+	"os"
+)
+
+const (
+	tmpl = `package kingpin
+
+// This file is autogenerated by "go generate .". Do not modify.
+
+{{range .}}
+// {{if .Comment}}{{.Comment}}{{else}}{{.|Name}} accumulates {{.Type}} values into a slice.{{end}}
+func (p *parserMixin) {{.|Name}}() (target *[]{{.Type}}) {
+	target = new([]{{.Type}})
+	p.{{.|Name}}Var(target)
+	return
+}
+
+func (p *parserMixin) {{.|Name}}Var(target *[]{{.Type}}) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return new{{.Name}}Value(v.(*{{.Type}})) }))
+}
+
+{{end}}
+`
+)
+
+type Repeated struct {
+	Name    string `json:"name"`
+	Comment string `json:"comment"`
+	Plural  string `json:"plural"`
+	Type    string `json:"type"`
+}
+
+func fatalIfError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	r, err := os.Open("repeated.json")
+	fatalIfError(err)
+	defer r.Close()
+
+	v := []Repeated{}
+	err = json.NewDecoder(r).Decode(&v)
+	fatalIfError(err)
+
+	t, err := template.New("genrepeated").Funcs(template.FuncMap{
+		"Lower": strings.ToLower,
+		"Name": func(v *Repeated) string {
+			if v.Plural != "" {
+				return v.Plural
+			}
+			return v.Name + "List"
+		},
+	}).Parse(tmpl)
+	fatalIfError(err)
+
+	w, err := os.Create("repeated.go")
+	fatalIfError(err)
+	defer w.Close()
+
+	err = t.Execute(w, v)
+	fatalIfError(err)
+
+	err = exec.Command("goimports", "-w", "repeated.go").Run()
+	fatalIfError(err)
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/global.go b/vendor/gopkg.in/alecthomas/kingpin.v2/global.go
new file mode 100644
index 00000000..b0906d3b
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/global.go
@@ -0,0 +1,88 @@
+package kingpin
+
+import (
+	"os"
+	"path/filepath"
+)
+
+var (
+	// CommandLine is the default Kingpin parser.
+	CommandLine = New(filepath.Base(os.Args[0]), "")
+)
+
+// Command adds a new command to the default parser.
+func Command(name, help string) *CmdClause {
+	return CommandLine.Command(name, help)
+}
+
+// Flag adds a new flag to the default parser.
+func Flag(name, help string) *FlagClause {
+	return CommandLine.Flag(name, help)
+}
+
+// Arg adds a new argument to the top-level of the default parser.
+func Arg(name, help string) *ArgClause {
+	return CommandLine.Arg(name, help)
+}
+
+// Parse and return the selected command. Will call the termination handler if
+// an error is encountered.
+func Parse() string {
+	selected := MustParse(CommandLine.Parse(os.Args[1:]))
+	if selected == "" && CommandLine.cmdGroup.have() {
+		Usage()
+		CommandLine.terminate(0)
+	}
+	return selected
+}
+
+// Errorf prints an error message to stderr.
+func Errorf(format string, args ...interface{}) {
+	CommandLine.Errorf(format, args...)
+}
+
+// Fatalf prints an error message to stderr and exits.
+func Fatalf(format string, args ...interface{}) {
+	CommandLine.Fatalf(format, args...)
+}
+
+// FatalIfError prints an error and exits if err is not nil. The error is printed
+// with the given prefix.
+func FatalIfError(err error, format string, args ...interface{}) {
+	CommandLine.FatalIfError(err, format, args...)
+}
+
+// FatalUsage prints an error message followed by usage information, then
+// exits with a non-zero status.
+func FatalUsage(format string, args ...interface{}) {
+	CommandLine.FatalUsage(format, args...)
+}
+
+// FatalUsageContext writes a printf formatted error message to stderr, then
+// usage information for the given ParseContext, before exiting.
+func FatalUsageContext(context *ParseContext, format string, args ...interface{}) {
+	CommandLine.FatalUsageContext(context, format, args...)
+}
+
+// Usage prints usage to stderr.
+func Usage() {
+	CommandLine.Usage(os.Args[1:])
+}
+
+// Set global usage template to use (defaults to DefaultUsageTemplate).
+func UsageTemplate(template string) *Application {
+	return CommandLine.UsageTemplate(template)
+}
+
+// MustParse can be used with app.Parse(args) to exit with an error if parsing fails.
+func MustParse(command string, err error) string {
+	if err != nil {
+		Fatalf("%s, try --help", err)
+	}
+	return command
+}
+
+// Version adds a flag for displaying the application version number.
+func Version(version string) *Application {
+	return CommandLine.Version(version)
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/guesswidth.go b/vendor/gopkg.in/alecthomas/kingpin.v2/guesswidth.go
new file mode 100644
index 00000000..22674c88
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/guesswidth.go
@@ -0,0 +1,9 @@
+// +build !linux,!freebsd,!darwin,!dragonfly,!netbsd,!openbsd
+
+package kingpin
+
+import "io"
+
+func guessWidth(w io.Writer) int {
+	return 80
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/guesswidth_unix.go b/vendor/gopkg.in/alecthomas/kingpin.v2/guesswidth_unix.go
new file mode 100644
index 00000000..a93484d7
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/guesswidth_unix.go
@@ -0,0 +1,38 @@
+// +build linux freebsd darwin dragonfly netbsd openbsd
+
+package kingpin
+
+import (
+	"io"
+	"os"
+	"strconv"
+	"syscall"
+	"unsafe"
+)
+
+func guessWidth(w io.Writer) int {
+	// check if COLUMNS env is set to comply with
+	// http://pubs.opengroup.org/onlinepubs/009604499/basedefs/xbd_chap08.html
+	colsStr := os.Getenv("COLUMNS")
+	if colsStr != "" {
+		if cols, err := strconv.Atoi(colsStr); err == nil {
+			return cols
+		}
+	}
+
+	if t, ok := w.(*os.File); ok {
+		fd := t.Fd()
+		var dimensions [4]uint16
+
+		if _, _, err := syscall.Syscall6(
+			syscall.SYS_IOCTL,
+			uintptr(fd),
+			uintptr(syscall.TIOCGWINSZ),
+			uintptr(unsafe.Pointer(&dimensions)),
+			0, 0, 0,
+		); err == 0 {
+			return int(dimensions[1])
+		}
+	}
+	return 80
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/model.go b/vendor/gopkg.in/alecthomas/kingpin.v2/model.go
new file mode 100644
index 00000000..79775cc4
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/model.go
@@ -0,0 +1,215 @@
+package kingpin
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Data model for Kingpin command-line structure.
+
+type FlagGroupModel struct {
+	Flags []*FlagModel
+}
+
+func (f *FlagGroupModel) FlagSummary() string {
+	out := []string{}
+	count := 0
+	for _, flag := range f.Flags {
+		if flag.Name != "help" {
+			count++
+		}
+		if flag.Required {
+			if flag.IsBoolFlag() {
+				out = append(out, fmt.Sprintf("--[no-]%s", flag.Name))
+			} else {
+				out = append(out, fmt.Sprintf("--%s=%s", flag.Name, flag.FormatPlaceHolder()))
+			}
+		}
+	}
+	if count != len(out) {
+		out = append(out, "[<flags>]")
+	}
+	return strings.Join(out, " ")
+}
+
+type FlagModel struct {
+	Name        string
+	Help        string
+	Short       rune
+	Default     string
+	Envar       string
+	PlaceHolder string
+	Required    bool
+	Hidden      bool
+	Value       Value
+}
+
+func (f *FlagModel) String() string {
+	return f.Value.String()
+}
+
+func (f *FlagModel) IsBoolFlag() bool {
+	if fl, ok := f.Value.(boolFlag); ok {
+		return fl.IsBoolFlag()
+	}
+	return false
+}
+
+func (f *FlagModel) FormatPlaceHolder() string {
+	if f.PlaceHolder != "" {
+		return f.PlaceHolder
+	}
+	if f.Default != "" {
+		if _, ok := f.Value.(*stringValue); ok {
+			return strconv.Quote(f.Default)
+		}
+		return f.Default
+	}
+	return strings.ToUpper(f.Name)
+}
+
+type ArgGroupModel struct {
+	Args []*ArgModel
+}
+
+func (a *ArgGroupModel) ArgSummary() string {
+	depth := 0
+	out := []string{}
+	for _, arg := range a.Args {
+		h := "<" + arg.Name + ">"
+		if !arg.Required {
+			h = "[" + h
+			depth++
+		}
+		out = append(out, h)
+	}
+	out[len(out)-1] = out[len(out)-1] + strings.Repeat("]", depth)
+	return strings.Join(out, " ")
+}
+
+type ArgModel struct {
+	Name     string
+	Help     string
+	Default  string
+	Required bool
+	Value    Value
+}
+
+func (a *ArgModel) String() string {
+	return a.Value.String()
+}
+
+type CmdGroupModel struct {
+	Commands []*CmdModel
+}
+
+func (c *CmdGroupModel) FlattenedCommands() (out []*CmdModel) {
+	for _, cmd := range c.Commands {
+		if len(cmd.Commands) == 0 {
+			out = append(out, cmd)
+		}
+		out = append(out, cmd.FlattenedCommands()...)
+	}
+	return
+}
+
+type CmdModel struct {
+	Name        string
+	Help        string
+	FullCommand string
+	Depth       int
+	*FlagGroupModel
+	*ArgGroupModel
+	*CmdGroupModel
+}
+
+func (c *CmdModel) String() string {
+	return c.FullCommand
+}
+
+type ApplicationModel struct {
+	Name    string
+	Help    string
+	Version string
+	Author  string
+	*ArgGroupModel
+	*CmdGroupModel
+	*FlagGroupModel
+}
+
+func (a *Application) Model() *ApplicationModel {
+	return &ApplicationModel{
+		Name:           a.Name,
+		Help:           a.Help,
+		Version:        a.version,
+		Author:         a.author,
+		FlagGroupModel: a.flagGroup.Model(),
+		ArgGroupModel:  a.argGroup.Model(),
+		CmdGroupModel:  a.cmdGroup.Model(),
+	}
+}
+
+func (a *argGroup) Model() *ArgGroupModel {
+	m := &ArgGroupModel{}
+	for _, arg := range a.args {
+		m.Args = append(m.Args, arg.Model())
+	}
+	return m
+}
+
+func (a *ArgClause) Model() *ArgModel {
+	return &ArgModel{
+		Name:     a.name,
+		Help:     a.help,
+		Default:  a.defaultValue,
+		Required: a.required,
+		Value:    a.value,
+	}
+}
+
+func (f *flagGroup) Model() *FlagGroupModel {
+	m := &FlagGroupModel{}
+	for _, fl := range f.flagOrder {
+		m.Flags = append(m.Flags, fl.Model())
+	}
+	return m
+}
+
+func (f *FlagClause) Model() *FlagModel {
+	return &FlagModel{
+		Name:        f.name,
+		Help:        f.help,
+		Short:       rune(f.shorthand),
+		Default:     f.defaultValue,
+		Envar:       f.envar,
+		PlaceHolder: f.placeholder,
+		Required:    f.required,
+		Hidden:      f.hidden,
+		Value:       f.value,
+	}
+}
+
+func (c *cmdGroup) Model() *CmdGroupModel {
+	m := &CmdGroupModel{}
+	for _, cm := range c.commandOrder {
+		m.Commands = append(m.Commands, cm.Model())
+	}
+	return m
+}
+
+func (c *CmdClause) Model() *CmdModel {
+	depth := 0
+	for i := c; i != nil; i = i.parent {
+		depth++
+	}
+	return &CmdModel{
+		Name:           c.name,
+		Help:           c.help,
+		Depth:          depth,
+		FullCommand:    c.FullCommand(),
+		FlagGroupModel: c.flagGroup.Model(),
+		ArgGroupModel:  c.argGroup.Model(),
+		CmdGroupModel:  c.cmdGroup.Model(),
+	}
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/parser.go b/vendor/gopkg.in/alecthomas/kingpin.v2/parser.go
new file mode 100644
index 00000000..2779c790
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/parser.go
@@ -0,0 +1,335 @@
+package kingpin
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+type TokenType int
+
+// Token types.
+const (
+	TokenShort TokenType = iota
+	TokenLong
+	TokenArg
+	TokenError
+	TokenEOL
+)
+
+func (t TokenType) String() string {
+	switch t {
+	case TokenShort:
+		return "short flag"
+	case TokenLong:
+		return "long flag"
+	case TokenArg:
+		return "argument"
+	case TokenError:
+		return "error"
+	case TokenEOL:
+		return "<EOL>"
+	}
+	return "?"
+}
+
+var (
+	TokenEOLMarker = Token{-1, TokenEOL, ""}
+)
+
+type Token struct {
+	Index int
+	Type  TokenType
+	Value string
+}
+
+func (t *Token) Equal(o *Token) bool {
+	return t.Index == o.Index
+}
+
+func (t *Token) IsFlag() bool {
+	return t.Type == TokenShort || t.Type == TokenLong
+}
+
+func (t *Token) IsEOF() bool {
+	return t.Type == TokenEOL
+}
+
+func (t *Token) String() string {
+	switch t.Type {
+	case TokenShort:
+		return "-" + t.Value
+	case TokenLong:
+		return "--" + t.Value
+	case TokenArg:
+		return t.Value
+	case TokenError:
+		return "error: " + t.Value
+	case TokenEOL:
+		return "<EOL>"
+	default:
+		panic("unhandled type")
+	}
+}
+
+// A union of possible elements in a parse stack.
+type ParseElement struct {
+	// Clause is either *CmdClause, *ArgClause or *FlagClause.
+	Clause interface{}
+	// Value is corresponding value for an ArgClause or FlagClause (if any).
+	Value *string
+}
+
+// ParseContext holds the current context of the parser. When passed to
+// Action() callbacks Elements will be fully populated with *FlagClause,
+// *ArgClause and *CmdClause values and their corresponding arguments (if
+// any).
+type ParseContext struct {
+	SelectedCommand *CmdClause
+	argsOnly        bool
+	peek            []*Token
+	argi            int // Index of current command-line arg we're processing.
+	args            []string
+	flags           *flagGroup
+	arguments       *argGroup
+	argumenti       int // Cursor into arguments
+	// Flags, arguments and commands encountered and collected during parse.
+	Elements []*ParseElement
+}
+
+func (p *ParseContext) nextArg() *ArgClause {
+	if p.argumenti >= len(p.arguments.args) {
+		return nil
+	}
+	arg := p.arguments.args[p.argumenti]
+	if !arg.consumesRemainder() {
+		p.argumenti++
+	}
+	return arg
+}
+
+func (p *ParseContext) next() {
+	p.argi++
+	p.args = p.args[1:]
+}
+
+// HasTrailingArgs returns true if there are unparsed command-line arguments.
+// This can occur if the parser can not match remaining arguments.
+func (p *ParseContext) HasTrailingArgs() bool {
+	return len(p.args) > 0
+}
+
+func tokenize(args []string) *ParseContext {
+	return &ParseContext{
+		args:      args,
+		flags:     newFlagGroup(),
+		arguments: newArgGroup(),
+	}
+}
+
+func (p *ParseContext) mergeFlags(flags *flagGroup) {
+	for _, flag := range flags.flagOrder {
+		if flag.shorthand != 0 {
+			p.flags.short[string(flag.shorthand)] = flag
+		}
+		p.flags.long[flag.name] = flag
+		p.flags.flagOrder = append(p.flags.flagOrder, flag)
+	}
+}
+
+func (p *ParseContext) mergeArgs(args *argGroup) {
+	for _, arg := range args.args {
+		p.arguments.args = append(p.arguments.args, arg)
+	}
+}
+
+func (p *ParseContext) EOL() bool {
+	return p.Peek().Type == TokenEOL
+}
+
+// Next token in the parse context.
+func (p *ParseContext) Next() *Token {
+	if len(p.peek) > 0 {
+		return p.pop()
+	}
+
+	// End of tokens.
+	if len(p.args) == 0 {
+		return &Token{Index: p.argi, Type: TokenEOL}
+	}
+
+	arg := p.args[0]
+	p.next()
+
+	if p.argsOnly {
+		return &Token{p.argi, TokenArg, arg}
+	}
+
+	// All remaining args are passed directly.
+	if arg == "--" {
+		p.argsOnly = true
+		return p.Next()
+	}
+
+	if strings.HasPrefix(arg, "--") {
+		parts := strings.SplitN(arg[2:], "=", 2)
+		token := &Token{p.argi, TokenLong, parts[0]}
+		if len(parts) == 2 {
+			p.push(&Token{p.argi, TokenArg, parts[1]})
+		}
+		return token
+	}
+
+	if strings.HasPrefix(arg, "-") {
+		if len(arg) == 1 {
+			return &Token{Index: p.argi, Type: TokenShort}
+		}
+		short := arg[1:2]
+		flag, ok := p.flags.short[short]
+		// Not a known short flag, we'll just return it anyway.
+		if !ok {
+		} else if fb, ok := flag.value.(boolFlag); ok && fb.IsBoolFlag() {
+			// Bool short flag.
+		} else {
+			// Short flag with combined argument: -fARG
+			token := &Token{p.argi, TokenShort, short}
+			if len(arg) > 2 {
+				p.push(&Token{p.argi, TokenArg, arg[2:]})
+			}
+			return token
+		}
+
+		if len(arg) > 2 {
+			p.args = append([]string{"-" + arg[2:]}, p.args...)
+		}
+		return &Token{p.argi, TokenShort, short}
+	} else if strings.HasPrefix(arg, "@") {
+		expanded, err := ExpandArgsFromFile(arg[1:])
+		if err != nil {
+			return &Token{p.argi, TokenError, err.Error()}
+		}
+		if p.argi >= len(p.args) {
+			p.args = append(p.args[:p.argi-1], expanded...)
+		} else {
+			p.args = append(p.args[:p.argi-1], append(expanded, p.args[p.argi+1:]...)...)
+		}
+		return p.Next()
+	}
+
+	return &Token{p.argi, TokenArg, arg}
+}
+
+func (p *ParseContext) Peek() *Token {
+	if len(p.peek) == 0 {
+		return p.push(p.Next())
+	}
+	return p.peek[len(p.peek)-1]
+}
+
+func (p *ParseContext) push(token *Token) *Token {
+	p.peek = append(p.peek, token)
+	return token
+}
+
+func (p *ParseContext) pop() *Token {
+	end := len(p.peek) - 1
+	token := p.peek[end]
+	p.peek = p.peek[0:end]
+	return token
+}
+
+func (p *ParseContext) String() string {
+	return p.SelectedCommand.FullCommand()
+}
+
+func (p *ParseContext) matchedFlag(flag *FlagClause, value string) {
+	p.Elements = append(p.Elements, &ParseElement{Clause: flag, Value: &value})
+}
+
+func (p *ParseContext) matchedArg(arg *ArgClause, value string) {
+	p.Elements = append(p.Elements, &ParseElement{Clause: arg, Value: &value})
+}
+
+func (p *ParseContext) matchedCmd(cmd *CmdClause) {
+	p.Elements = append(p.Elements, &ParseElement{Clause: cmd})
+	p.mergeFlags(cmd.flagGroup)
+	p.mergeArgs(cmd.argGroup)
+	p.SelectedCommand = cmd
+}
+
+// Expand arguments from a file. Lines starting with # will be treated as comments.
+func ExpandArgsFromFile(filename string) (out []string, err error) {
+	r, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer r.Close()
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+		out = append(out, line)
+	}
+	err = scanner.Err()
+	return
+}
+
+func parse(context *ParseContext, app *Application) (selected []string, err error) {
+	context.mergeFlags(app.flagGroup)
+	context.mergeArgs(app.argGroup)
+
+	cmds := app.cmdGroup
+
+loop:
+	for !context.EOL() {
+		token := context.Peek()
+		switch token.Type {
+		case TokenLong, TokenShort:
+			if err := context.flags.parse(context); err != nil {
+				return nil, err
+			}
+
+		case TokenArg:
+			if cmds.have() {
+				cmd, ok := cmds.commands[token.String()]
+				if !ok {
+					return nil, fmt.Errorf("expected command but got %s", token)
+				}
+				context.matchedCmd(cmd)
+				selected = append([]string{token.String()}, selected...)
+				cmds = cmd.cmdGroup
+				context.Next()
+			} else if context.arguments.have() {
+				arg := context.nextArg()
+				if arg == nil {
+					break loop
+				}
+				context.matchedArg(arg, token.String())
+				context.Next()
+			} else {
+				break loop
+			}
+
+		case TokenEOL:
+			break loop
+		}
+	}
+
+	if !context.EOL() {
+		return nil, fmt.Errorf("unexpected %s", context.Peek())
+	}
+
+	// Set defaults for all remaining args.
+	for arg := context.nextArg(); arg != nil && !arg.consumesRemainder(); arg = context.nextArg() {
+		if arg.defaultValue != "" {
+			if err := arg.value.Set(arg.defaultValue); err != nil {
+				return nil, fmt.Errorf("invalid default value '%s' for argument '%s'", arg.defaultValue, arg.name)
+			}
+		}
+	}
+
+	return
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/parsers.go b/vendor/gopkg.in/alecthomas/kingpin.v2/parsers.go
new file mode 100644
index 00000000..c9dbb359
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/parsers.go
@@ -0,0 +1,265 @@
+package kingpin
+
+//go:generate go run ./genrepeated/main.go
+
+import (
+	"net"
+	"net/url"
+	"os"
+	"time"
+
+	"github.com/alecthomas/units"
+)
+
+type Settings interface {
+	SetValue(value Value)
+}
+
+type parserMixin struct {
+	value    Value
+	required bool
+}
+
+func (p *parserMixin) SetValue(value Value) {
+	p.value = value
+}
+
+// String sets the parser to a string parser.
+func (p *parserMixin) String() (target *string) {
+	target = new(string)
+	p.StringVar(target)
+	return
+}
+
+// StringMap provides key=value parsing into a map.
+func (p *parserMixin) StringMap() (target *map[string]string) {
+	target = &(map[string]string{})
+	p.StringMapVar(target)
+	return
+}
+
+// Bool sets the parser to a boolean parser. Supports --no-<X> to disable the flag.
+func (p *parserMixin) Bool() (target *bool) {
+	target = new(bool)
+	p.BoolVar(target)
+	return
+}
+
+// Int sets the parser to an int parser.
+func (p *parserMixin) Int() (target *int) {
+	target = new(int)
+	p.IntVar(target)
+	return
+}
+
+// Int64 parses an int64
+func (p *parserMixin) Int64() (target *int64) {
+	target = new(int64)
+	p.Int64Var(target)
+	return
+}
+
+// Uint64 parses a uint64
+func (p *parserMixin) Uint64() (target *uint64) {
+	target = new(uint64)
+	p.Uint64Var(target)
+	return
+}
+
+// Float sets the parser to a float64 parser.
+func (p *parserMixin) Float() (target *float64) {
+	target = new(float64)
+	p.FloatVar(target)
+	return
+}
+
+// Duration sets the parser to a time.Duration parser.
+func (p *parserMixin) Duration() (target *time.Duration) {
+	target = new(time.Duration)
+	p.DurationVar(target)
+	return
+}
+
+// Bytes parses numeric byte units. eg. 1.5KB
+func (p *parserMixin) Bytes() (target *units.Base2Bytes) {
+	target = new(units.Base2Bytes)
+	p.BytesVar(target)
+	return
+}
+
+// IP sets the parser to a net.IP parser.
+func (p *parserMixin) IP() (target *net.IP) {
+	target = new(net.IP)
+	p.IPVar(target)
+	return
+}
+
+// TCP (host:port) address.
+func (p *parserMixin) TCP() (target **net.TCPAddr) {
+	target = new(*net.TCPAddr)
+	p.TCPVar(target)
+	return
+}
+
+// TCPVar (host:port) address.
+func (p *parserMixin) TCPVar(target **net.TCPAddr) {
+	p.SetValue(newTCPAddrValue(target))
+}
+
+// ExistingFile sets the parser to one that requires and returns an existing file.
+func (p *parserMixin) ExistingFile() (target *string) {
+	target = new(string)
+	p.ExistingFileVar(target)
+	return
+}
+
+// ExistingDir sets the parser to one that requires and returns an existing directory.
+func (p *parserMixin) ExistingDir() (target *string) {
+	target = new(string)
+	p.ExistingDirVar(target)
+	return
+}
+
+// ExistingFileOrDir sets the parser to one that requires and returns an existing file OR directory.
+func (p *parserMixin) ExistingFileOrDir() (target *string) {
+	target = new(string)
+	p.ExistingFileOrDirVar(target)
+	return
+}
+
+// File returns an os.File against an existing file.
+func (p *parserMixin) File() (target **os.File) {
+	target = new(*os.File)
+	p.FileVar(target)
+	return
+}
+
+// File attempts to open a File with os.OpenFile(flag, perm).
+func (p *parserMixin) OpenFile(flag int, perm os.FileMode) (target **os.File) {
+	target = new(*os.File)
+	p.OpenFileVar(target, flag, perm)
+	return
+}
+
+// URL provides a valid, parsed url.URL.
+func (p *parserMixin) URL() (target **url.URL) {
+	target = new(*url.URL)
+	p.URLVar(target)
+	return
+}
+
+// String sets the parser to a string parser.
+func (p *parserMixin) StringVar(target *string) {
+	p.SetValue(newStringValue(target))
+}
+
+// StringMap provides key=value parsing into a map.
+func (p *parserMixin) StringMapVar(target *map[string]string) {
+	p.SetValue(newStringMapValue(target))
+}
+
+// Bool sets the parser to a boolean parser. Supports --no-<X> to disable the flag.
+func (p *parserMixin) BoolVar(target *bool) {
+	p.SetValue(newBoolValue(target))
+}
+
+// Int sets the parser to an int parser.
+func (p *parserMixin) IntVar(target *int) {
+	p.SetValue(newIntValue(target))
+}
+
+// Int64 parses an int64
+func (p *parserMixin) Int64Var(target *int64) {
+	p.SetValue(newInt64Value(target))
+}
+
+// Uint64 parses a uint64
+func (p *parserMixin) Uint64Var(target *uint64) {
+	p.SetValue(newUint64Value(target))
+}
+
+// Float sets the parser to a float64 parser.
+func (p *parserMixin) FloatVar(target *float64) {
+	p.SetValue(newFloat64Value(target))
+}
+
+// Duration sets the parser to a time.Duration parser.
+func (p *parserMixin) DurationVar(target *time.Duration) {
+	p.SetValue(newDurationValue(target))
+}
+
+// BytesVar parses numeric byte units. eg. 1.5KB
+func (p *parserMixin) BytesVar(target *units.Base2Bytes) {
+	p.SetValue(newBytesValue(target))
+}
+
+// IP sets the parser to a net.IP parser.
+func (p *parserMixin) IPVar(target *net.IP) {
+	p.SetValue(newIPValue(target))
+}
+
+// ExistingFile sets the parser to one that requires and returns an existing file.
+func (p *parserMixin) ExistingFileVar(target *string) {
+	p.SetValue(newExistingFileValue(target))
+}
+
+// ExistingDir sets the parser to one that requires and returns an existing directory.
+func (p *parserMixin) ExistingDirVar(target *string) {
+	p.SetValue(newExistingDirValue(target))
+}
+
+// ExistingDir sets the parser to one that requires and returns an existing directory.
+func (p *parserMixin) ExistingFileOrDirVar(target *string) {
+	p.SetValue(newExistingFileOrDirValue(target))
+}
+
+// FileVar opens an existing file.
+func (p *parserMixin) FileVar(target **os.File) {
+	p.SetValue(newFileValue(target, os.O_RDONLY, 0))
+}
+
+// OpenFileVar calls os.OpenFile(flag, perm)
+func (p *parserMixin) OpenFileVar(target **os.File, flag int, perm os.FileMode) {
+	p.SetValue(newFileValue(target, flag, perm))
+}
+
+// URL provides a valid, parsed url.URL.
+func (p *parserMixin) URLVar(target **url.URL) {
+	p.SetValue(newURLValue(target))
+}
+
+// URLList provides a parsed list of url.URL values.
+func (p *parserMixin) URLList() (target *[]*url.URL) {
+	target = new([]*url.URL)
+	p.URLListVar(target)
+	return
+}
+
+// URLListVar provides a parsed list of url.URL values.
+func (p *parserMixin) URLListVar(target *[]*url.URL) {
+	p.SetValue(newURLListValue(target))
+}
+
+// Enum allows a value from a set of options.
+func (p *parserMixin) Enum(options ...string) (target *string) {
+	target = new(string)
+	p.EnumVar(&target, options...)
+	return
+}
+
+// EnumVar allows a value from a set of options.
+func (p *parserMixin) EnumVar(target **string, options ...string) {
+	p.SetValue(newEnumFlag(target, options...))
+}
+
+// Enums allows a set of values from a set of options.
+func (p *parserMixin) Enums(options ...string) (target *[]string) {
+	target = new([]string)
+	p.EnumsVar(target, options...)
+	return
+}
+
+// EnumVar allows a value from a set of options.
+func (p *parserMixin) EnumsVar(target *[]string, options ...string) {
+	p.SetValue(newEnumsFlag(target, options...))
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/repeated.go b/vendor/gopkg.in/alecthomas/kingpin.v2/repeated.go
new file mode 100644
index 00000000..9c13d204
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/repeated.go
@@ -0,0 +1,107 @@
+package kingpin
+
+import (
+	"net"
+	"time"
+)
+
+// This file is autogenerated by "go generate .". Do not modify.
+
+// Strings accumulates string values into a slice.
+func (p *parserMixin) Strings() (target *[]string) {
+	target = new([]string)
+	p.StringsVar(target)
+	return
+}
+
+func (p *parserMixin) StringsVar(target *[]string) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newStringValue(v.(*string)) }))
+}
+
+// Uint64List accumulates uint64 values into a slice.
+func (p *parserMixin) Uint64List() (target *[]uint64) {
+	target = new([]uint64)
+	p.Uint64ListVar(target)
+	return
+}
+
+func (p *parserMixin) Uint64ListVar(target *[]uint64) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newUint64Value(v.(*uint64)) }))
+}
+
+// Int64List accumulates int64 values into a slice.
+func (p *parserMixin) Int64List() (target *[]int64) {
+	target = new([]int64)
+	p.Int64ListVar(target)
+	return
+}
+
+func (p *parserMixin) Int64ListVar(target *[]int64) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newInt64Value(v.(*int64)) }))
+}
+
+// DurationList accumulates time.Duration values into a slice.
+func (p *parserMixin) DurationList() (target *[]time.Duration) {
+	target = new([]time.Duration)
+	p.DurationListVar(target)
+	return
+}
+
+func (p *parserMixin) DurationListVar(target *[]time.Duration) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newDurationValue(v.(*time.Duration)) }))
+}
+
+// IPList accumulates net.IP values into a slice.
+func (p *parserMixin) IPList() (target *[]net.IP) {
+	target = new([]net.IP)
+	p.IPListVar(target)
+	return
+}
+
+func (p *parserMixin) IPListVar(target *[]net.IP) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newIPValue(v.(*net.IP)) }))
+}
+
+// TCPList accumulates *net.TCPAddr values into a slice.
+func (p *parserMixin) TCPList() (target *[]*net.TCPAddr) {
+	target = new([]*net.TCPAddr)
+	p.TCPListVar(target)
+	return
+}
+
+func (p *parserMixin) TCPListVar(target *[]*net.TCPAddr) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newTCPAddrValue(v.(**net.TCPAddr)) }))
+}
+
+// ExistingFiles accumulates string values into a slice.
+func (p *parserMixin) ExistingFiles() (target *[]string) {
+	target = new([]string)
+	p.ExistingFilesVar(target)
+	return
+}
+
+func (p *parserMixin) ExistingFilesVar(target *[]string) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newExistingFileValue(v.(*string)) }))
+}
+
+// ExistingDirs accumulates string values into a slice.
+func (p *parserMixin) ExistingDirs() (target *[]string) {
+	target = new([]string)
+	p.ExistingDirsVar(target)
+	return
+}
+
+func (p *parserMixin) ExistingDirsVar(target *[]string) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newExistingDirValue(v.(*string)) }))
+}
+
+// ExistingFilesOrDirs accumulates string values into a slice.
+func (p *parserMixin) ExistingFilesOrDirs() (target *[]string) {
+	target = new([]string)
+	p.ExistingFilesOrDirsVar(target)
+	return
+}
+
+func (p *parserMixin) ExistingFilesOrDirsVar(target *[]string) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newExistingFileOrDirValue(v.(*string)) }))
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/repeated.json b/vendor/gopkg.in/alecthomas/kingpin.v2/repeated.json
new file mode 100644
index 00000000..f8b9d76f
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/repeated.json
@@ -0,0 +1,11 @@
+[
+  {"name": "String", "type": "string", "plural": "Strings"},
+  {"name": "Uint64", "type": "uint64"},
+  {"name": "Int64", "type": "int64"},
+  {"name": "Duration", "type": "time.Duration"},
+  {"name": "IP", "type": "net.IP"},
+  {"name": "TCPAddr", "Type": "*net.TCPAddr", "plural": "TCPList"},
+  {"name": "ExistingFile", "Type": "string", "plural": "ExistingFiles"},
+  {"name": "ExistingDir", "Type": "string", "plural": "ExistingDirs"},
+  {"name": "ExistingFileOrDir", "Type": "string", "plural": "ExistingFilesOrDirs"}
+]
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/templates.go b/vendor/gopkg.in/alecthomas/kingpin.v2/templates.go
new file mode 100644
index 00000000..3b7080de
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/templates.go
@@ -0,0 +1,174 @@
+package kingpin
+
+// Default usage template.
+var DefaultUsageTemplate = `{{define "FormatCommand"}}\
+{{if .FlagSummary}} {{.FlagSummary}}{{end}}\
+{{range .Args}} {{if not .Required}}[{{end}}<{{.Name}}>{{if .Value|IsCumulative}}...{{end}}{{if not .Required}}]{{end}}{{end}}\
+{{end}}\
+
+{{define "FormatCommands"}}\
+{{range .FlattenedCommands}}\
+  {{.FullCommand}}{{template "FormatCommand" .}}
+{{.Help|Wrap 4}}
+{{end}}\
+{{end}}\
+
+{{define "FormatUsage"}}\
+{{template "FormatCommand" .}}{{if .Commands}} <command> [<args> ...]{{end}}
+{{if .Help}}
+{{.Help|Wrap 0}}\
+{{end}}\
+
+{{end}}\
+
+{{if .Context.SelectedCommand}}\
+usage: {{.App.Name}} {{.Context.SelectedCommand}}{{template "FormatUsage" .Context.SelectedCommand}}
+{{else}}\
+usage: {{.App.Name}}{{template "FormatUsage" .App}}
+{{end}}\
+{{if .Context.Flags}}\
+Flags:
+{{.Context.Flags|FlagsToTwoColumns|FormatTwoColumns}}
+{{end}}\
+{{if .Context.Args}}\
+Args:
+{{.Context.Args|ArgsToTwoColumns|FormatTwoColumns}}
+{{end}}\
+{{if .Context.SelectedCommand}}\
+Subcommands:
+{{if .Context.SelectedCommand.Commands}}\
+{{template "FormatCommands" .Context.SelectedCommand}}
+{{end}}\
+{{else if .App.Commands}}\
+Commands:
+{{template "FormatCommands" .App}}
+{{end}}\
+`
+
+// Usage template with compactly formatted commands.
+var CompactUsageTemplate = `{{define "FormatCommand"}}\
+{{if .FlagSummary}} {{.FlagSummary}}{{end}}\
+{{range .Args}} {{if not .Required}}[{{end}}<{{.Name}}>{{if .Value|IsCumulative}}...{{end}}{{if not .Required}}]{{end}}{{end}}\
+{{end}}\
+
+{{define "FormatCommandList"}}\
+{{range .}}\
+{{.Depth|Indent}}{{.Name}}{{template "FormatCommand" .}}
+{{template "FormatCommandList" .Commands}}\
+{{end}}\
+{{end}}\
+
+{{define "FormatUsage"}}\
+{{template "FormatCommand" .}}{{if .Commands}} <command> [<args> ...]{{end}}
+{{if .Help}}
+{{.Help|Wrap 0}}\
+{{end}}\
+
+{{end}}\
+
+{{if .Context.SelectedCommand}}\
+usage: {{.App.Name}} {{.Context.SelectedCommand}}{{template "FormatUsage" .Context.SelectedCommand}}
+{{else}}\
+usage: {{.App.Name}}{{template "FormatUsage" .App}}
+{{end}}\
+{{if .Context.Flags}}\
+Flags:
+{{.Context.Flags|FlagsToTwoColumns|FormatTwoColumns}}
+{{end}}\
+{{if .Context.Args}}\
+Args:
+{{.Context.Args|ArgsToTwoColumns|FormatTwoColumns}}
+{{end}}\
+{{if .Context.SelectedCommand}}\
+{{if .Context.SelectedCommand.Commands}}\
+Commands:
+  {{.Context.SelectedCommand}}
+{{template "FormatCommandList" .Context.SelectedCommand.Commands}}
+{{end}}\
+{{else if .App.Commands}}\
+Commands:
+{{template "FormatCommandList" .App.Commands}}
+{{end}}\
+`
+
+var ManPageTemplate = `{{define "FormatFlags"}}\
+{{range .Flags}}\
+{{if not .Hidden}}\
+.TP
+\fB{{if .Short}}-{{.Short|Char}}, {{end}}--{{.Name}}{{if not .IsBoolFlag}}={{.FormatPlaceHolder}}{{end}}\\fR
+{{.Help}}
+{{end}}\
+{{end}}\
+{{end}}\
+
+{{define "FormatCommand"}}\
+{{if .FlagSummary}} {{.FlagSummary}}{{end}}\
+{{range .Args}} {{if not .Required}}[{{end}}<{{.Name}}>{{if .Value|IsCumulative}}...{{end}}{{if not .Required}}]{{end}}{{end}}\
+{{end}}\
+
+{{define "FormatCommands"}}\
+{{range .FlattenedCommands}}\
+.SS
+\fB{{.FullCommand}}{{template "FormatCommand" .}}\\fR
+.PP
+{{.Help}}
+{{template "FormatFlags" .}}\
+{{end}}\
+{{end}}\
+
+{{define "FormatUsage"}}\
+{{template "FormatCommand" .}}{{if .Commands}} <command> [<args> ...]{{end}}\\fR
+{{end}}\
+
+.TH {{.App.Name}} 1 {{.App.Version}} "{{.App.Author}}"
+.SH "NAME"
+{{.App.Name}}
+.SH "SYNOPSIS"
+.TP
+\fB{{.App.Name}}{{template "FormatUsage" .App}}
+.SH "DESCRIPTION"
+{{.App.Help}}
+.SH "OPTIONS"
+{{template "FormatFlags" .App}}\
+{{if .App.Commands}}\
+.SH "COMMANDS"
+{{template "FormatCommands" .App}}\
+{{end}}\
+`
+
+// Default usage template.
+var LongHelpTemplate = `{{define "FormatCommand"}}\
+{{if .FlagSummary}} {{.FlagSummary}}{{end}}\
+{{range .Args}} {{if not .Required}}[{{end}}<{{.Name}}>{{if .Value|IsCumulative}}...{{end}}{{if not .Required}}]{{end}}{{end}}\
+{{end}}\
+
+{{define "FormatCommands"}}\
+{{range .FlattenedCommands}}\
+  {{.FullCommand}}{{template "FormatCommand" .}}
+{{.Help|Wrap 4}}
+{{with .Flags|FlagsToTwoColumns}}{{FormatTwoColumnsWithIndent . 4 2}}{{end}}
+{{end}}\
+{{end}}\
+
+{{define "FormatUsage"}}\
+{{template "FormatCommand" .}}{{if .Commands}} <command> [<args> ...]{{end}}
+{{if .Help}}
+{{.Help|Wrap 0}}\
+{{end}}\
+
+{{end}}\
+
+usage: {{.App.Name}}{{template "FormatUsage" .App}}
+{{if .Context.Flags}}\
+Flags:
+{{.Context.Flags|FlagsToTwoColumns|FormatTwoColumns}}
+{{end}}\
+{{if .Context.Args}}\
+Args:
+{{.Context.Args|ArgsToTwoColumns|FormatTwoColumns}}
+{{end}}\
+{{if .App.Commands}}\
+Commands:
+{{template "FormatCommands" .App}}
+{{end}}\
+`
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/usage.go b/vendor/gopkg.in/alecthomas/kingpin.v2/usage.go
new file mode 100644
index 00000000..15b282ab
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/usage.go
@@ -0,0 +1,178 @@
+package kingpin
+
+import (
+	"bytes"
+	"fmt"
+	"go/doc"
+	"io"
+	"strings"
+
+	"github.com/alecthomas/template"
+)
+
+var (
+	preIndent = "  "
+)
+
+func formatTwoColumns(w io.Writer, indent, padding, width int, rows [][2]string) {
+	// Find size of first column.
+	s := 0
+	for _, row := range rows {
+		if c := len(row[0]); c > s && c < 20 {
+			s = c
+		}
+	}
+
+	indentStr := strings.Repeat(" ", indent)
+	offsetStr := strings.Repeat(" ", s+padding)
+
+	for _, row := range rows {
+		buf := bytes.NewBuffer(nil)
+		doc.ToText(buf, row[1], "", preIndent, width-s-padding-indent)
+		lines := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n")
+		fmt.Fprintf(w, "%s%-*s%*s", indentStr, s, row[0], padding, "")
+		if len(row[0]) >= 20 {
+			fmt.Fprintf(w, "\n%s%s", indentStr, offsetStr)
+		}
+		fmt.Fprintf(w, "%s\n", lines[0])
+		for _, line := range lines[1:] {
+			fmt.Fprintf(w, "%s%s%s\n", indentStr, offsetStr, line)
+		}
+	}
+}
+
+// Usage writes application usage to w. It parses args to determine
+// appropriate help context, such as which command to show help for.
+func (a *Application) Usage(args []string) {
+	context, err := a.ParseContext(args)
+	a.FatalIfError(err, "")
+	if err := a.UsageForContextWithTemplate(context, 2, a.usageTemplate); err != nil {
+		panic(err)
+	}
+}
+
+func formatAppUsage(app *ApplicationModel) string {
+	s := []string{app.Name}
+	if len(app.Flags) > 0 {
+		s = append(s, app.FlagSummary())
+	}
+	if len(app.Args) > 0 {
+		s = append(s, app.ArgSummary())
+	}
+	return strings.Join(s, " ")
+}
+
+func formatCmdUsage(app *ApplicationModel, cmd *CmdModel) string {
+	s := []string{app.Name, cmd.String()}
+	if len(app.Flags) > 0 {
+		s = append(s, app.FlagSummary())
+	}
+	if len(app.Args) > 0 {
+		s = append(s, app.ArgSummary())
+	}
+	return strings.Join(s, " ")
+}
+
+func formatFlag(flag *FlagModel) string {
+	flagString := ""
+	if flag.Short != 0 {
+		flagString += fmt.Sprintf("-%c, ", flag.Short)
+	}
+	flagString += fmt.Sprintf("--%s", flag.Name)
+	if !flag.IsBoolFlag() {
+		flagString += fmt.Sprintf("=%s", flag.FormatPlaceHolder())
+	}
+	return flagString
+}
+
+type templateParseContext struct {
+	SelectedCommand *CmdModel
+	*FlagGroupModel
+	*ArgGroupModel
+}
+
+type templateContext struct {
+	App     *ApplicationModel
+	Width   int
+	Context *templateParseContext
+}
+
+// UsageForContext displays usage information from a ParseContext (obtained from
+// Application.ParseContext() or Action(f) callbacks).
+func (a *Application) UsageForContext(context *ParseContext) error {
+	return a.UsageForContextWithTemplate(context, 2, a.usageTemplate)
+}
+
+// UsageForContextWithTemplate is the base usage function. You generally don't need to use this.
+func (a *Application) UsageForContextWithTemplate(context *ParseContext, indent int, tmpl string) error {
+	width := guessWidth(a.writer)
+	funcs := template.FuncMap{
+		"Indent": func(level int) string {
+			return strings.Repeat(" ", level*indent)
+		},
+		"Wrap": func(indent int, s string) string {
+			buf := bytes.NewBuffer(nil)
+			indentText := strings.Repeat(" ", indent)
+			doc.ToText(buf, s, indentText, indentText, width)
+			return buf.String()
+		},
+		"FormatFlag": formatFlag,
+		"FlagsToTwoColumns": func(f []*FlagModel) [][2]string {
+			rows := [][2]string{}
+			for _, flag := range f {
+				if !flag.Hidden {
+					rows = append(rows, [2]string{formatFlag(flag), flag.Help})
+				}
+			}
+			return rows
+		},
+		"ArgsToTwoColumns": func(a []*ArgModel) [][2]string {
+			rows := [][2]string{}
+			for _, arg := range a {
+				s := "<" + arg.Name + ">"
+				if !arg.Required {
+					s = "[" + s + "]"
+				}
+				rows = append(rows, [2]string{s, arg.Help})
+			}
+			return rows
+		},
+		"FormatTwoColumns": func(rows [][2]string) string {
+			buf := bytes.NewBuffer(nil)
+			formatTwoColumns(buf, indent, indent, width, rows)
+			return buf.String()
+		},
+		"FormatTwoColumnsWithIndent": func(rows [][2]string, indent, padding int) string {
+			buf := bytes.NewBuffer(nil)
+			formatTwoColumns(buf, indent, padding, width, rows)
+			return buf.String()
+		},
+		"FormatAppUsage":     formatAppUsage,
+		"FormatCommandUsage": formatCmdUsage,
+		"IsCumulative": func(value Value) bool {
+			_, ok := value.(remainderArg)
+			return ok
+		},
+		"Char": func(c rune) string {
+			return string(c)
+		},
+	}
+	t, err := template.New("usage").Funcs(funcs).Parse(tmpl)
+	if err != nil {
+		return err
+	}
+	var selectedCommand *CmdModel
+	if context.SelectedCommand != nil {
+		selectedCommand = context.SelectedCommand.Model()
+	}
+	ctx := templateContext{
+		App:   a.Model(),
+		Width: width,
+		Context: &templateParseContext{
+			SelectedCommand: selectedCommand,
+			FlagGroupModel:  context.flags.Model(),
+			ArgGroupModel:   context.arguments.Model(),
+		},
+	}
+	return t.Execute(a.writer, ctx)
+}
diff --git a/vendor/gopkg.in/alecthomas/kingpin.v2/values.go b/vendor/gopkg.in/alecthomas/kingpin.v2/values.go
new file mode 100644
index 00000000..5e362751
--- /dev/null
+++ b/vendor/gopkg.in/alecthomas/kingpin.v2/values.go
@@ -0,0 +1,507 @@
+package kingpin
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/alecthomas/units"
+)
+
+// NOTE: Most of the base type values were lifted from:
+// http://golang.org/src/pkg/flag/flag.go?s=20146:20222
+
+// Value is the interface to the dynamic value stored in a flag.
+// (The default value is represented as a string.)
+//
+// If a Value has an IsBoolFlag() bool method returning true, the command-line
+// parser makes --name equivalent to -name=true rather than using the next
+// command-line argument, and adds a --no-name counterpart for negating the
+// flag.
+type Value interface {
+	String() string
+	Set(string) error
+}
+
+// Getter is an interface that allows the contents of a Value to be retrieved.
+// It wraps the Value interface, rather than being part of it, because it
+// appeared after Go 1 and its compatibility rules. All Value types provided
+// by this package satisfy the Getter interface.
+type Getter interface {
+	Value
+	Get() interface{}
+}
+
+// Optional interface to indicate boolean flags that don't accept a value, and
+// implicitly have a --no-<x> negation counterpart.
+type boolFlag interface {
+	Value
+	IsBoolFlag() bool
+}
+
+// Optional interface for arguments that cumulatively consume all remaining
+// input.
+type remainderArg interface {
+	Value
+	IsCumulative() bool
+}
+
+type accumulator struct {
+	element func(value interface{}) Value
+	typ     reflect.Type
+	slice   reflect.Value
+}
+
+// Use reflection to accumulate values into a slice.
+//
+// target := []string{}
+// newAccumulator(&target, func (value interface{}) Value {
+//   return newStringValue(value.(*string))
+// })
+func newAccumulator(slice interface{}, element func(value interface{}) Value) *accumulator {
+	typ := reflect.TypeOf(slice)
+	if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Slice {
+		panic("expected a pointer to a slice")
+	}
+	return &accumulator{
+		element: element,
+		typ:     typ.Elem().Elem(),
+		slice:   reflect.ValueOf(slice),
+	}
+}
+
+func (a *accumulator) String() string {
+	out := []string{}
+	s := a.slice.Elem()
+	for i := 0; i < s.Len(); i++ {
+		out = append(out, a.element(s.Index(i).Addr().Interface()).String())
+	}
+	return strings.Join(out, ",")
+}
+
+func (a *accumulator) Set(value string) error {
+	e := reflect.New(a.typ)
+	if err := a.element(e.Interface()).Set(value); err != nil {
+		return err
+	}
+	slice := reflect.Append(a.slice.Elem(), e.Elem())
+	a.slice.Elem().Set(slice)
+	return nil
+}
+
+func (a *accumulator) IsCumulative() bool {
+	return true
+}
+
+// -- bool Value
+type boolValue bool
+
+func newBoolValue(p *bool) *boolValue {
+	return (*boolValue)(p)
+}
+
+func (b *boolValue) Set(s string) error {
+	if s == "" {
+		s = "true"
+	}
+	v, err := strconv.ParseBool(s)
+	*b = boolValue(v)
+	return err
+}
+
+func (b *boolValue) Get() interface{} { return bool(*b) }
+
+func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) }
+
+func (b *boolValue) IsBoolFlag() bool { return true }
+
+// -- int Value
+type intValue int
+
+func newIntValue(p *int) *intValue {
+	return (*intValue)(p)
+}
+
+func (i *intValue) Set(s string) error {
+	v, err := strconv.ParseInt(s, 0, 64)
+	*i = intValue(v)
+	return err
+}
+
+func (i *intValue) Get() interface{} { return int(*i) }
+
+func (i *intValue) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- int64 Value
+type int64Value int64
+
+func newInt64Value(p *int64) *int64Value {
+	return (*int64Value)(p)
+}
+
+func (i *int64Value) Set(s string) error {
+	v, err := strconv.ParseInt(s, 0, 64)
+	*i = int64Value(v)
+	return err
+}
+
+func (i *int64Value) Get() interface{} { return int64(*i) }
+
+func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- uint Value
+type uintValue uint
+
+func (i *uintValue) Set(s string) error {
+	v, err := strconv.ParseUint(s, 0, 64)
+	*i = uintValue(v)
+	return err
+}
+
+func (i *uintValue) Get() interface{} { return uint(*i) }
+
+func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- uint64 Value
+type uint64Value uint64
+
+func newUint64Value(p *uint64) *uint64Value {
+	return (*uint64Value)(p)
+}
+
+func (i *uint64Value) Set(s string) error {
+	v, err := strconv.ParseUint(s, 0, 64)
+	*i = uint64Value(v)
+	return err
+}
+
+func (i *uint64Value) Get() interface{} { return uint64(*i) }
+
+func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- string Value
+type stringValue string
+
+func newStringValue(p *string) *stringValue {
+	return (*stringValue)(p)
+}
+
+func (s *stringValue) Set(val string) error {
+	*s = stringValue(val)
+	return nil
+}
+
+func (s *stringValue) Get() interface{} { return string(*s) }
+
+func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) }
+
+// -- float64 Value
+type float64Value float64
+
+func newFloat64Value(p *float64) *float64Value {
+	return (*float64Value)(p)
+}
+
+func (f *float64Value) Set(s string) error {
+	v, err := strconv.ParseFloat(s, 64)
+	*f = float64Value(v)
+	return err
+}
+
+func (f *float64Value) Get() interface{} { return float64(*f) }
+
+func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) }
+
+// -- time.Duration Value
+type durationValue time.Duration
+
+func newDurationValue(p *time.Duration) *durationValue {
+	return (*durationValue)(p)
+}
+
+func (d *durationValue) Set(s string) error {
+	v, err := time.ParseDuration(s)
+	*d = durationValue(v)
+	return err
+}
+
+func (d *durationValue) Get() interface{} { return time.Duration(*d) }
+
+func (d *durationValue) String() string { return (*time.Duration)(d).String() }
+
+// -- map[string]string Value
+type stringMapValue map[string]string
+
+func newStringMapValue(p *map[string]string) *stringMapValue {
+	return (*stringMapValue)(p)
+}
+
+var stringMapRegex = regexp.MustCompile("[:=]")
+
+func (s *stringMapValue) Set(value string) error {
+	parts := stringMapRegex.Split(value, 2)
+	if len(parts) != 2 {
+		return fmt.Errorf("expected KEY=VALUE got '%s'", value)
+	}
+	(*s)[parts[0]] = parts[1]
+	return nil
+}
+func (s *stringMapValue) String() string {
+	return fmt.Sprintf("%s", map[string]string(*s))
+}
+
+func (s *stringMapValue) IsCumulative() bool {
+	return true
+}
+
+// -- net.IP Value
+type ipValue net.IP
+
+func newIPValue(p *net.IP) *ipValue {
+	return (*ipValue)(p)
+}
+
+func (i *ipValue) Set(value string) error {
+	if ip := net.ParseIP(value); ip == nil {
+		return fmt.Errorf("'%s' is not an IP address", value)
+	} else {
+		*i = *(*ipValue)(&ip)
+		return nil
+	}
+}
+
+func (i *ipValue) String() string {
+	return (*net.IP)(i).String()
+}
+
+// -- *net.TCPAddr Value
+type tcpAddrValue struct {
+	addr **net.TCPAddr
+}
+
+func newTCPAddrValue(p **net.TCPAddr) *tcpAddrValue {
+	return &tcpAddrValue{p}
+}
+
+func (i *tcpAddrValue) Set(value string) error {
+	if addr, err := net.ResolveTCPAddr("tcp", value); err != nil {
+		return fmt.Errorf("'%s' is not a valid TCP address: %s", value, err)
+	} else {
+		*i.addr = addr
+		return nil
+	}
+}
+
+func (i *tcpAddrValue) String() string {
+	return (*i.addr).String()
+}
+
+// -- existingFile Value
+
+type fileStatValue struct {
+	path      *string
+	predicate func(os.FileInfo) error
+}
+
+func newFileStatValue(p *string, predicate func(os.FileInfo) error) *fileStatValue {
+	return &fileStatValue{
+		path:      p,
+		predicate: predicate,
+	}
+}
+
+func (e *fileStatValue) Set(value string) error {
+	if s, err := os.Stat(value); os.IsNotExist(err) {
+		return fmt.Errorf("path '%s' does not exist", value)
+	} else if err != nil {
+		return err
+	} else if err := e.predicate(s); err != nil {
+		return err
+	}
+	*e.path = value
+	return nil
+}
+
+func (e *fileStatValue) String() string {
+	return *e.path
+}
+
+// -- os.File value
+
+type fileValue struct {
+	f    **os.File
+	flag int
+	perm os.FileMode
+}
+
+func newFileValue(p **os.File, flag int, perm os.FileMode) *fileValue {
+	return &fileValue{p, flag, perm}
+}
+
+func (f *fileValue) Set(value string) error {
+	if fd, err := os.OpenFile(value, f.flag, f.perm); err != nil {
+		return err
+	} else {
+		*f.f = fd
+		return nil
+	}
+}
+
+func (f *fileValue) String() string {
+	if *f.f == nil {
+		return "<nil>"
+	}
+	return (*f.f).Name()
+}
+
+// -- url.URL Value
+type urlValue struct {
+	u **url.URL
+}
+
+func newURLValue(p **url.URL) *urlValue {
+	return &urlValue{p}
+}
+
+func (u *urlValue) Set(value string) error {
+	if url, err := url.Parse(value); err != nil {
+		return fmt.Errorf("invalid URL: %s", err)
+	} else {
+		*u.u = url
+		return nil
+	}
+}
+
+func (u *urlValue) String() string {
+	if *u.u == nil {
+		return "<nil>"
+	}
+	return (*u.u).String()
+}
+
+// -- []*url.URL Value
+type urlListValue []*url.URL
+
+func newURLListValue(p *[]*url.URL) *urlListValue {
+	return (*urlListValue)(p)
+}
+
+func (u *urlListValue) Set(value string) error {
+	if url, err := url.Parse(value); err != nil {
+		return fmt.Errorf("invalid URL: %s", err)
+	} else {
+		*u = append(*u, url)
+		return nil
+	}
+}
+
+func (u *urlListValue) String() string {
+	out := []string{}
+	for _, url := range *u {
+		out = append(out, url.String())
+	}
+	return strings.Join(out, ",")
+}
+
+// A flag whose value must be in a set of options.
+type enumValue struct {
+	value   *string
+	options []string
+}
+
+func newEnumFlag(target **string, options ...string) *enumValue {
+	return &enumValue{
+		value:   *target,
+		options: options,
+	}
+}
+
+func (a *enumValue) String() string {
+	return *a.value
+}
+
+func (a *enumValue) Set(value string) error {
+	for _, v := range a.options {
+		if v == value {
+			*a.value = value
+			return nil
+		}
+	}
+	return fmt.Errorf("enum value must be one of %s, got '%s'", strings.Join(a.options, ","), value)
+}
+
+// -- []string Enum Value
+type enumsValue struct {
+	value   *[]string
+	options []string
+}
+
+func newEnumsFlag(target *[]string, options ...string) *enumsValue {
+	return &enumsValue{
+		value:   target,
+		options: options,
+	}
+}
+
+func (s *enumsValue) Set(value string) error {
+	for _, v := range s.options {
+		if v == value {
+			*s.value = append(*s.value, value)
+			return nil
+		}
+	}
+	return fmt.Errorf("enum value must be one of %s, got '%s'", strings.Join(s.options, ","), value)
+}
+
+func (s *enumsValue) String() string {
+	return strings.Join(*s.value, ",")
+}
+
+func (s *enumsValue) IsCumulative() bool {
+	return true
+}
+
+// -- units.Base2Bytes Value
+type bytesValue units.Base2Bytes
+
+func newBytesValue(p *units.Base2Bytes) *bytesValue {
+	return (*bytesValue)(p)
+}
+
+func (d *bytesValue) Set(s string) error {
+	v, err := units.ParseBase2Bytes(s)
+	*d = bytesValue(v)
+	return err
+}
+
+func (d *bytesValue) Get() interface{} { return units.Base2Bytes(*d) }
+
+func (d *bytesValue) String() string { return (*units.Base2Bytes)(d).String() }
+
+func newExistingFileValue(target *string) *fileStatValue {
+	return newFileStatValue(target, func(s os.FileInfo) error {
+		if s.IsDir() {
+			return fmt.Errorf("'%s' is a directory", s.Name())
+		}
+		return nil
+	})
+}
+
+func newExistingDirValue(target *string) *fileStatValue {
+	return newFileStatValue(target, func(s os.FileInfo) error {
+		if !s.IsDir() {
+			return fmt.Errorf("'%s' is a file", s.Name())
+		}
+		return nil
+	})
+}
+
+func newExistingFileOrDirValue(target *string) *fileStatValue {
+	return newFileStatValue(target, func(s os.FileInfo) error { return nil })
+}
diff --git a/vendor/gopkg.in/mgo.v2/LICENSE b/vendor/gopkg.in/mgo.v2/LICENSE
new file mode 100644
index 00000000..770c7672
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/LICENSE
@@ -0,0 +1,25 @@
+mgo - MongoDB driver for Go
+
+Copyright (c) 2010-2013 - Gustavo Niemeyer <gustavo@niemeyer.net>
+
+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.
diff --git a/vendor/gopkg.in/mgo.v2/Makefile b/vendor/gopkg.in/mgo.v2/Makefile
new file mode 100644
index 00000000..51bee732
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/Makefile
@@ -0,0 +1,5 @@
+startdb:
+	@testdb/setup.sh start
+
+stopdb:
+	@testdb/setup.sh stop
diff --git a/vendor/gopkg.in/mgo.v2/README.md b/vendor/gopkg.in/mgo.v2/README.md
new file mode 100644
index 00000000..f4e452c0
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/README.md
@@ -0,0 +1,4 @@
+The MongoDB driver for Go
+-------------------------
+
+Please go to [http://labix.org/mgo](http://labix.org/mgo) for all project details.
diff --git a/vendor/gopkg.in/mgo.v2/auth.go b/vendor/gopkg.in/mgo.v2/auth.go
new file mode 100644
index 00000000..dc26e52f
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/auth.go
@@ -0,0 +1,467 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"crypto/md5"
+	"crypto/sha1"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"sync"
+
+	"gopkg.in/mgo.v2/bson"
+	"gopkg.in/mgo.v2/internal/scram"
+)
+
+type authCmd struct {
+	Authenticate int
+
+	Nonce string
+	User  string
+	Key   string
+}
+
+type startSaslCmd struct {
+	StartSASL int `bson:"startSasl"`
+}
+
+type authResult struct {
+	ErrMsg string
+	Ok     bool
+}
+
+type getNonceCmd struct {
+	GetNonce int
+}
+
+type getNonceResult struct {
+	Nonce string
+	Err   string "$err"
+	Code  int
+}
+
+type logoutCmd struct {
+	Logout int
+}
+
+type saslCmd struct {
+	Start          int    `bson:"saslStart,omitempty"`
+	Continue       int    `bson:"saslContinue,omitempty"`
+	ConversationId int    `bson:"conversationId,omitempty"`
+	Mechanism      string `bson:"mechanism,omitempty"`
+	Payload        []byte
+}
+
+type saslResult struct {
+	Ok    bool `bson:"ok"`
+	NotOk bool `bson:"code"` // Server <= 2.3.2 returns ok=1 & code>0 on errors (WTF?)
+	Done  bool
+
+	ConversationId int `bson:"conversationId"`
+	Payload        []byte
+	ErrMsg         string
+}
+
+type saslStepper interface {
+	Step(serverData []byte) (clientData []byte, done bool, err error)
+	Close()
+}
+
+func (socket *mongoSocket) getNonce() (nonce string, err error) {
+	socket.Lock()
+	for socket.cachedNonce == "" && socket.dead == nil {
+		debugf("Socket %p to %s: waiting for nonce", socket, socket.addr)
+		socket.gotNonce.Wait()
+	}
+	if socket.cachedNonce == "mongos" {
+		socket.Unlock()
+		return "", errors.New("Can't authenticate with mongos; see http://j.mp/mongos-auth")
+	}
+	debugf("Socket %p to %s: got nonce", socket, socket.addr)
+	nonce, err = socket.cachedNonce, socket.dead
+	socket.cachedNonce = ""
+	socket.Unlock()
+	if err != nil {
+		nonce = ""
+	}
+	return
+}
+
+func (socket *mongoSocket) resetNonce() {
+	debugf("Socket %p to %s: requesting a new nonce", socket, socket.addr)
+	op := &queryOp{}
+	op.query = &getNonceCmd{GetNonce: 1}
+	op.collection = "admin.$cmd"
+	op.limit = -1
+	op.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
+		if err != nil {
+			socket.kill(errors.New("getNonce: "+err.Error()), true)
+			return
+		}
+		result := &getNonceResult{}
+		err = bson.Unmarshal(docData, &result)
+		if err != nil {
+			socket.kill(errors.New("Failed to unmarshal nonce: "+err.Error()), true)
+			return
+		}
+		debugf("Socket %p to %s: nonce unmarshalled: %#v", socket, socket.addr, result)
+		if result.Code == 13390 {
+			// mongos doesn't yet support auth (see http://j.mp/mongos-auth)
+			result.Nonce = "mongos"
+		} else if result.Nonce == "" {
+			var msg string
+			if result.Err != "" {
+				msg = fmt.Sprintf("Got an empty nonce: %s (%d)", result.Err, result.Code)
+			} else {
+				msg = "Got an empty nonce"
+			}
+			socket.kill(errors.New(msg), true)
+			return
+		}
+		socket.Lock()
+		if socket.cachedNonce != "" {
+			socket.Unlock()
+			panic("resetNonce: nonce already cached")
+		}
+		socket.cachedNonce = result.Nonce
+		socket.gotNonce.Signal()
+		socket.Unlock()
+	}
+	err := socket.Query(op)
+	if err != nil {
+		socket.kill(errors.New("resetNonce: "+err.Error()), true)
+	}
+}
+
+func (socket *mongoSocket) Login(cred Credential) error {
+	socket.Lock()
+	if cred.Mechanism == "" && socket.serverInfo.MaxWireVersion >= 3 {
+		cred.Mechanism = "SCRAM-SHA-1"
+	}
+	for _, sockCred := range socket.creds {
+		if sockCred == cred {
+			debugf("Socket %p to %s: login: db=%q user=%q (already logged in)", socket, socket.addr, cred.Source, cred.Username)
+			socket.Unlock()
+			return nil
+		}
+	}
+	if socket.dropLogout(cred) {
+		debugf("Socket %p to %s: login: db=%q user=%q (cached)", socket, socket.addr, cred.Source, cred.Username)
+		socket.creds = append(socket.creds, cred)
+		socket.Unlock()
+		return nil
+	}
+	socket.Unlock()
+
+	debugf("Socket %p to %s: login: db=%q user=%q", socket, socket.addr, cred.Source, cred.Username)
+
+	var err error
+	switch cred.Mechanism {
+	case "", "MONGODB-CR", "MONGO-CR": // Name changed to MONGODB-CR in SERVER-8501.
+		err = socket.loginClassic(cred)
+	case "PLAIN":
+		err = socket.loginPlain(cred)
+	case "MONGODB-X509":
+		err = socket.loginX509(cred)
+	default:
+		// Try SASL for everything else, if it is available.
+		err = socket.loginSASL(cred)
+	}
+
+	if err != nil {
+		debugf("Socket %p to %s: login error: %s", socket, socket.addr, err)
+	} else {
+		debugf("Socket %p to %s: login successful", socket, socket.addr)
+	}
+	return err
+}
+
+func (socket *mongoSocket) loginClassic(cred Credential) error {
+	// Note that this only works properly because this function is
+	// synchronous, which means the nonce won't get reset while we're
+	// using it and any other login requests will block waiting for a
+	// new nonce provided in the defer call below.
+	nonce, err := socket.getNonce()
+	if err != nil {
+		return err
+	}
+	defer socket.resetNonce()
+
+	psum := md5.New()
+	psum.Write([]byte(cred.Username + ":mongo:" + cred.Password))
+
+	ksum := md5.New()
+	ksum.Write([]byte(nonce + cred.Username))
+	ksum.Write([]byte(hex.EncodeToString(psum.Sum(nil))))
+
+	key := hex.EncodeToString(ksum.Sum(nil))
+
+	cmd := authCmd{Authenticate: 1, User: cred.Username, Nonce: nonce, Key: key}
+	res := authResult{}
+	return socket.loginRun(cred.Source, &cmd, &res, func() error {
+		if !res.Ok {
+			return errors.New(res.ErrMsg)
+		}
+		socket.Lock()
+		socket.dropAuth(cred.Source)
+		socket.creds = append(socket.creds, cred)
+		socket.Unlock()
+		return nil
+	})
+}
+
+type authX509Cmd struct {
+	Authenticate int
+	User         string
+	Mechanism    string
+}
+
+func (socket *mongoSocket) loginX509(cred Credential) error {
+	cmd := authX509Cmd{Authenticate: 1, User: cred.Username, Mechanism: "MONGODB-X509"}
+	res := authResult{}
+	return socket.loginRun(cred.Source, &cmd, &res, func() error {
+		if !res.Ok {
+			return errors.New(res.ErrMsg)
+		}
+		socket.Lock()
+		socket.dropAuth(cred.Source)
+		socket.creds = append(socket.creds, cred)
+		socket.Unlock()
+		return nil
+	})
+}
+
+func (socket *mongoSocket) loginPlain(cred Credential) error {
+	cmd := saslCmd{Start: 1, Mechanism: "PLAIN", Payload: []byte("\x00" + cred.Username + "\x00" + cred.Password)}
+	res := authResult{}
+	return socket.loginRun(cred.Source, &cmd, &res, func() error {
+		if !res.Ok {
+			return errors.New(res.ErrMsg)
+		}
+		socket.Lock()
+		socket.dropAuth(cred.Source)
+		socket.creds = append(socket.creds, cred)
+		socket.Unlock()
+		return nil
+	})
+}
+
+func (socket *mongoSocket) loginSASL(cred Credential) error {
+	var sasl saslStepper
+	var err error
+	if cred.Mechanism == "SCRAM-SHA-1" {
+		// SCRAM is handled without external libraries.
+		sasl = saslNewScram(cred)
+	} else if len(cred.ServiceHost) > 0 {
+		sasl, err = saslNew(cred, cred.ServiceHost)
+	} else {
+		sasl, err = saslNew(cred, socket.Server().Addr)
+	}
+	if err != nil {
+		return err
+	}
+	defer sasl.Close()
+
+	// The goal of this logic is to carry a locked socket until the
+	// local SASL step confirms the auth is valid; the socket needs to be
+	// locked so that concurrent action doesn't leave the socket in an
+	// auth state that doesn't reflect the operations that took place.
+	// As a simple case, imagine inverting login=>logout to logout=>login.
+	//
+	// The logic below works because the lock func isn't called concurrently.
+	locked := false
+	lock := func(b bool) {
+		if locked != b {
+			locked = b
+			if b {
+				socket.Lock()
+			} else {
+				socket.Unlock()
+			}
+		}
+	}
+
+	lock(true)
+	defer lock(false)
+
+	start := 1
+	cmd := saslCmd{}
+	res := saslResult{}
+	for {
+		payload, done, err := sasl.Step(res.Payload)
+		if err != nil {
+			return err
+		}
+		if done && res.Done {
+			socket.dropAuth(cred.Source)
+			socket.creds = append(socket.creds, cred)
+			break
+		}
+		lock(false)
+
+		cmd = saslCmd{
+			Start:          start,
+			Continue:       1 - start,
+			ConversationId: res.ConversationId,
+			Mechanism:      cred.Mechanism,
+			Payload:        payload,
+		}
+		start = 0
+		err = socket.loginRun(cred.Source, &cmd, &res, func() error {
+			// See the comment on lock for why this is necessary.
+			lock(true)
+			if !res.Ok || res.NotOk {
+				return fmt.Errorf("server returned error on SASL authentication step: %s", res.ErrMsg)
+			}
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+		if done && res.Done {
+			socket.dropAuth(cred.Source)
+			socket.creds = append(socket.creds, cred)
+			break
+		}
+	}
+
+	return nil
+}
+
+func saslNewScram(cred Credential) *saslScram {
+	credsum := md5.New()
+	credsum.Write([]byte(cred.Username + ":mongo:" + cred.Password))
+	client := scram.NewClient(sha1.New, cred.Username, hex.EncodeToString(credsum.Sum(nil)))
+	return &saslScram{cred: cred, client: client}
+}
+
+type saslScram struct {
+	cred   Credential
+	client *scram.Client
+}
+
+func (s *saslScram) Close() {}
+
+func (s *saslScram) Step(serverData []byte) (clientData []byte, done bool, err error) {
+	more := s.client.Step(serverData)
+	return s.client.Out(), !more, s.client.Err()
+}
+
+func (socket *mongoSocket) loginRun(db string, query, result interface{}, f func() error) error {
+	var mutex sync.Mutex
+	var replyErr error
+	mutex.Lock()
+
+	op := queryOp{}
+	op.query = query
+	op.collection = db + ".$cmd"
+	op.limit = -1
+	op.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
+		defer mutex.Unlock()
+
+		if err != nil {
+			replyErr = err
+			return
+		}
+
+		err = bson.Unmarshal(docData, result)
+		if err != nil {
+			replyErr = err
+		} else {
+			// Must handle this within the read loop for the socket, so
+			// that concurrent login requests are properly ordered.
+			replyErr = f()
+		}
+	}
+
+	err := socket.Query(&op)
+	if err != nil {
+		return err
+	}
+	mutex.Lock() // Wait.
+	return replyErr
+}
+
+func (socket *mongoSocket) Logout(db string) {
+	socket.Lock()
+	cred, found := socket.dropAuth(db)
+	if found {
+		debugf("Socket %p to %s: logout: db=%q (flagged)", socket, socket.addr, db)
+		socket.logout = append(socket.logout, cred)
+	}
+	socket.Unlock()
+}
+
+func (socket *mongoSocket) LogoutAll() {
+	socket.Lock()
+	if l := len(socket.creds); l > 0 {
+		debugf("Socket %p to %s: logout all (flagged %d)", socket, socket.addr, l)
+		socket.logout = append(socket.logout, socket.creds...)
+		socket.creds = socket.creds[0:0]
+	}
+	socket.Unlock()
+}
+
+func (socket *mongoSocket) flushLogout() (ops []interface{}) {
+	socket.Lock()
+	if l := len(socket.logout); l > 0 {
+		debugf("Socket %p to %s: logout all (flushing %d)", socket, socket.addr, l)
+		for i := 0; i != l; i++ {
+			op := queryOp{}
+			op.query = &logoutCmd{1}
+			op.collection = socket.logout[i].Source + ".$cmd"
+			op.limit = -1
+			ops = append(ops, &op)
+		}
+		socket.logout = socket.logout[0:0]
+	}
+	socket.Unlock()
+	return
+}
+
+func (socket *mongoSocket) dropAuth(db string) (cred Credential, found bool) {
+	for i, sockCred := range socket.creds {
+		if sockCred.Source == db {
+			copy(socket.creds[i:], socket.creds[i+1:])
+			socket.creds = socket.creds[:len(socket.creds)-1]
+			return sockCred, true
+		}
+	}
+	return cred, false
+}
+
+func (socket *mongoSocket) dropLogout(cred Credential) (found bool) {
+	for i, sockCred := range socket.logout {
+		if sockCred == cred {
+			copy(socket.logout[i:], socket.logout[i+1:])
+			socket.logout = socket.logout[:len(socket.logout)-1]
+			return true
+		}
+	}
+	return false
+}
diff --git a/vendor/gopkg.in/mgo.v2/bson/LICENSE b/vendor/gopkg.in/mgo.v2/bson/LICENSE
new file mode 100644
index 00000000..89032601
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/bson/LICENSE
@@ -0,0 +1,25 @@
+BSON library for Go
+
+Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+
+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.
diff --git a/vendor/gopkg.in/mgo.v2/bson/bson.go b/vendor/gopkg.in/mgo.v2/bson/bson.go
new file mode 100644
index 00000000..41816b87
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/bson/bson.go
@@ -0,0 +1,705 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+// Package bson is an implementation of the BSON specification for Go:
+//
+//     http://bsonspec.org
+//
+// It was created as part of the mgo MongoDB driver for Go, but is standalone
+// and may be used on its own without the driver.
+package bson
+
+import (
+	"bytes"
+	"crypto/md5"
+	"crypto/rand"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// --------------------------------------------------------------------------
+// The public API.
+
+// A value implementing the bson.Getter interface will have its GetBSON
+// method called when the given value has to be marshalled, and the result
+// of this method will be marshaled in place of the actual object.
+//
+// If GetBSON returns return a non-nil error, the marshalling procedure
+// will stop and error out with the provided value.
+type Getter interface {
+	GetBSON() (interface{}, error)
+}
+
+// A value implementing the bson.Setter interface will receive the BSON
+// value via the SetBSON method during unmarshaling, and the object
+// itself will not be changed as usual.
+//
+// If setting the value works, the method should return nil or alternatively
+// bson.SetZero to set the respective field to its zero value (nil for
+// pointer types). If SetBSON returns a value of type bson.TypeError, the
+// BSON value will be omitted from a map or slice being decoded and the
+// unmarshalling will continue. If it returns any other non-nil error, the
+// unmarshalling procedure will stop and error out with the provided value.
+//
+// This interface is generally useful in pointer receivers, since the method
+// will want to change the receiver. A type field that implements the Setter
+// interface doesn't have to be a pointer, though.
+//
+// Unlike the usual behavior, unmarshalling onto a value that implements a
+// Setter interface will NOT reset the value to its zero state. This allows
+// the value to decide by itself how to be unmarshalled.
+//
+// For example:
+//
+//     type MyString string
+//
+//     func (s *MyString) SetBSON(raw bson.Raw) error {
+//         return raw.Unmarshal(s)
+//     }
+//
+type Setter interface {
+	SetBSON(raw Raw) error
+}
+
+// SetZero may be returned from a SetBSON method to have the value set to
+// its respective zero value. When used in pointer values, this will set the
+// field to nil rather than to the pre-allocated value.
+var SetZero = errors.New("set to zero")
+
+// M is a convenient alias for a map[string]interface{} map, useful for
+// dealing with BSON in a native way.  For instance:
+//
+//     bson.M{"a": 1, "b": true}
+//
+// There's no special handling for this type in addition to what's done anyway
+// for an equivalent map type.  Elements in the map will be dumped in an
+// undefined ordered. See also the bson.D type for an ordered alternative.
+type M map[string]interface{}
+
+// D represents a BSON document containing ordered elements. For example:
+//
+//     bson.D{{"a", 1}, {"b", true}}
+//
+// In some situations, such as when creating indexes for MongoDB, the order in
+// which the elements are defined is important.  If the order is not important,
+// using a map is generally more comfortable. See bson.M and bson.RawD.
+type D []DocElem
+
+// DocElem is an element of the bson.D document representation.
+type DocElem struct {
+	Name  string
+	Value interface{}
+}
+
+// Map returns a map out of the ordered element name/value pairs in d.
+func (d D) Map() (m M) {
+	m = make(M, len(d))
+	for _, item := range d {
+		m[item.Name] = item.Value
+	}
+	return m
+}
+
+// The Raw type represents raw unprocessed BSON documents and elements.
+// Kind is the kind of element as defined per the BSON specification, and
+// Data is the raw unprocessed data for the respective element.
+// Using this type it is possible to unmarshal or marshal values partially.
+//
+// Relevant documentation:
+//
+//     http://bsonspec.org/#/specification
+//
+type Raw struct {
+	Kind byte
+	Data []byte
+}
+
+// RawD represents a BSON document containing raw unprocessed elements.
+// This low-level representation may be useful when lazily processing
+// documents of uncertain content, or when manipulating the raw content
+// documents in general.
+type RawD []RawDocElem
+
+// See the RawD type.
+type RawDocElem struct {
+	Name  string
+	Value Raw
+}
+
+// ObjectId is a unique ID identifying a BSON value. It must be exactly 12 bytes
+// long. MongoDB objects by default have such a property set in their "_id"
+// property.
+//
+// http://www.mongodb.org/display/DOCS/Object+IDs
+type ObjectId string
+
+// ObjectIdHex returns an ObjectId from the provided hex representation.
+// Calling this function with an invalid hex representation will
+// cause a runtime panic. See the IsObjectIdHex function.
+func ObjectIdHex(s string) ObjectId {
+	d, err := hex.DecodeString(s)
+	if err != nil || len(d) != 12 {
+		panic(fmt.Sprintf("Invalid input to ObjectIdHex: %q", s))
+	}
+	return ObjectId(d)
+}
+
+// IsObjectIdHex returns whether s is a valid hex representation of
+// an ObjectId. See the ObjectIdHex function.
+func IsObjectIdHex(s string) bool {
+	if len(s) != 24 {
+		return false
+	}
+	_, err := hex.DecodeString(s)
+	return err == nil
+}
+
+// objectIdCounter is atomically incremented when generating a new ObjectId
+// using NewObjectId() function. It's used as a counter part of an id.
+var objectIdCounter uint32 = 0
+
+// machineId stores machine id generated once and used in subsequent calls
+// to NewObjectId function.
+var machineId = readMachineId()
+
+// readMachineId generates machine id and puts it into the machineId global
+// variable. If this function fails to get the hostname, it will cause
+// a runtime error.
+func readMachineId() []byte {
+	var sum [3]byte
+	id := sum[:]
+	hostname, err1 := os.Hostname()
+	if err1 != nil {
+		_, err2 := io.ReadFull(rand.Reader, id)
+		if err2 != nil {
+			panic(fmt.Errorf("cannot get hostname: %v; %v", err1, err2))
+		}
+		return id
+	}
+	hw := md5.New()
+	hw.Write([]byte(hostname))
+	copy(id, hw.Sum(nil))
+	return id
+}
+
+// NewObjectId returns a new unique ObjectId.
+func NewObjectId() ObjectId {
+	var b [12]byte
+	// Timestamp, 4 bytes, big endian
+	binary.BigEndian.PutUint32(b[:], uint32(time.Now().Unix()))
+	// Machine, first 3 bytes of md5(hostname)
+	b[4] = machineId[0]
+	b[5] = machineId[1]
+	b[6] = machineId[2]
+	// Pid, 2 bytes, specs don't specify endianness, but we use big endian.
+	pid := os.Getpid()
+	b[7] = byte(pid >> 8)
+	b[8] = byte(pid)
+	// Increment, 3 bytes, big endian
+	i := atomic.AddUint32(&objectIdCounter, 1)
+	b[9] = byte(i >> 16)
+	b[10] = byte(i >> 8)
+	b[11] = byte(i)
+	return ObjectId(b[:])
+}
+
+// NewObjectIdWithTime returns a dummy ObjectId with the timestamp part filled
+// with the provided number of seconds from epoch UTC, and all other parts
+// filled with zeroes. It's not safe to insert a document with an id generated
+// by this method, it is useful only for queries to find documents with ids
+// generated before or after the specified timestamp.
+func NewObjectIdWithTime(t time.Time) ObjectId {
+	var b [12]byte
+	binary.BigEndian.PutUint32(b[:4], uint32(t.Unix()))
+	return ObjectId(string(b[:]))
+}
+
+// String returns a hex string representation of the id.
+// Example: ObjectIdHex("4d88e15b60f486e428412dc9").
+func (id ObjectId) String() string {
+	return fmt.Sprintf(`ObjectIdHex("%x")`, string(id))
+}
+
+// Hex returns a hex representation of the ObjectId.
+func (id ObjectId) Hex() string {
+	return hex.EncodeToString([]byte(id))
+}
+
+// MarshalJSON turns a bson.ObjectId into a json.Marshaller.
+func (id ObjectId) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf(`"%x"`, string(id))), nil
+}
+
+var nullBytes = []byte("null")
+
+// UnmarshalJSON turns *bson.ObjectId into a json.Unmarshaller.
+func (id *ObjectId) UnmarshalJSON(data []byte) error {
+	if len(data) == 2 && data[0] == '"' && data[1] == '"' || bytes.Equal(data, nullBytes) {
+		*id = ""
+		return nil
+	}
+	if len(data) != 26 || data[0] != '"' || data[25] != '"' {
+		return errors.New(fmt.Sprintf("Invalid ObjectId in JSON: %s", string(data)))
+	}
+	var buf [12]byte
+	_, err := hex.Decode(buf[:], data[1:25])
+	if err != nil {
+		return errors.New(fmt.Sprintf("Invalid ObjectId in JSON: %s (%s)", string(data), err))
+	}
+	*id = ObjectId(string(buf[:]))
+	return nil
+}
+
+// Valid returns true if id is valid. A valid id must contain exactly 12 bytes.
+func (id ObjectId) Valid() bool {
+	return len(id) == 12
+}
+
+// byteSlice returns byte slice of id from start to end.
+// Calling this function with an invalid id will cause a runtime panic.
+func (id ObjectId) byteSlice(start, end int) []byte {
+	if len(id) != 12 {
+		panic(fmt.Sprintf("Invalid ObjectId: %q", string(id)))
+	}
+	return []byte(string(id)[start:end])
+}
+
+// Time returns the timestamp part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Time() time.Time {
+	// First 4 bytes of ObjectId is 32-bit big-endian seconds from epoch.
+	secs := int64(binary.BigEndian.Uint32(id.byteSlice(0, 4)))
+	return time.Unix(secs, 0)
+}
+
+// Machine returns the 3-byte machine id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Machine() []byte {
+	return id.byteSlice(4, 7)
+}
+
+// Pid returns the process id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Pid() uint16 {
+	return binary.BigEndian.Uint16(id.byteSlice(7, 9))
+}
+
+// Counter returns the incrementing value part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Counter() int32 {
+	b := id.byteSlice(9, 12)
+	// Counter is stored as big-endian 3-byte value
+	return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+}
+
+// The Symbol type is similar to a string and is used in languages with a
+// distinct symbol type.
+type Symbol string
+
+// Now returns the current time with millisecond precision. MongoDB stores
+// timestamps with the same precision, so a Time returned from this method
+// will not change after a roundtrip to the database. That's the only reason
+// why this function exists. Using the time.Now function also works fine
+// otherwise.
+func Now() time.Time {
+	return time.Unix(0, time.Now().UnixNano()/1e6*1e6)
+}
+
+// MongoTimestamp is a special internal type used by MongoDB that for some
+// strange reason has its own datatype defined in BSON.
+type MongoTimestamp int64
+
+type orderKey int64
+
+// MaxKey is a special value that compares higher than all other possible BSON
+// values in a MongoDB database.
+var MaxKey = orderKey(1<<63 - 1)
+
+// MinKey is a special value that compares lower than all other possible BSON
+// values in a MongoDB database.
+var MinKey = orderKey(-1 << 63)
+
+type undefined struct{}
+
+// Undefined represents the undefined BSON value.
+var Undefined undefined
+
+// Binary is a representation for non-standard binary values.  Any kind should
+// work, but the following are known as of this writing:
+//
+//   0x00 - Generic. This is decoded as []byte(data), not Binary{0x00, data}.
+//   0x01 - Function (!?)
+//   0x02 - Obsolete generic.
+//   0x03 - UUID
+//   0x05 - MD5
+//   0x80 - User defined.
+//
+type Binary struct {
+	Kind byte
+	Data []byte
+}
+
+// RegEx represents a regular expression.  The Options field may contain
+// individual characters defining the way in which the pattern should be
+// applied, and must be sorted. Valid options as of this writing are 'i' for
+// case insensitive matching, 'm' for multi-line matching, 'x' for verbose
+// mode, 'l' to make \w, \W, and similar be locale-dependent, 's' for dot-all
+// mode (a '.' matches everything), and 'u' to make \w, \W, and similar match
+// unicode. The value of the Options parameter is not verified before being
+// marshaled into the BSON format.
+type RegEx struct {
+	Pattern string
+	Options string
+}
+
+// JavaScript is a type that holds JavaScript code. If Scope is non-nil, it
+// will be marshaled as a mapping from identifiers to values that may be
+// used when evaluating the provided Code.
+type JavaScript struct {
+	Code  string
+	Scope interface{}
+}
+
+// DBPointer refers to a document id in a namespace.
+//
+// This type is deprecated in the BSON specification and should not be used
+// except for backwards compatibility with ancient applications.
+type DBPointer struct {
+	Namespace string
+	Id        ObjectId
+}
+
+const initialBufferSize = 64
+
+func handleErr(err *error) {
+	if r := recover(); r != nil {
+		if _, ok := r.(runtime.Error); ok {
+			panic(r)
+		} else if _, ok := r.(externalPanic); ok {
+			panic(r)
+		} else if s, ok := r.(string); ok {
+			*err = errors.New(s)
+		} else if e, ok := r.(error); ok {
+			*err = e
+		} else {
+			panic(r)
+		}
+	}
+}
+
+// Marshal serializes the in value, which may be a map or a struct value.
+// In the case of struct values, only exported fields will be serialized.
+// The lowercased field name is used as the key for each exported field,
+// but this behavior may be changed using the respective field tag.
+// The tag may also contain flags to tweak the marshalling behavior for
+// the field. The tag formats accepted are:
+//
+//     "[<key>][,<flag1>[,<flag2>]]"
+//
+//     `(...) bson:"[<key>][,<flag1>[,<flag2>]]" (...)`
+//
+// The following flags are currently supported:
+//
+//     omitempty  Only include the field if it's not set to the zero
+//                value for the type or to empty slices or maps.
+//
+//     minsize    Marshal an int64 value as an int32, if that's feasible
+//                while preserving the numeric value.
+//
+//     inline     Inline the field, which must be a struct or a map,
+//                causing all of its fields or keys to be processed as if
+//                they were part of the outer struct. For maps, keys must
+//                not conflict with the bson keys of other struct fields.
+//
+// Some examples:
+//
+//     type T struct {
+//         A bool
+//         B int    "myb"
+//         C string "myc,omitempty"
+//         D string `bson:",omitempty" json:"jsonkey"`
+//         E int64  ",minsize"
+//         F int64  "myf,omitempty,minsize"
+//     }
+//
+func Marshal(in interface{}) (out []byte, err error) {
+	defer handleErr(&err)
+	e := &encoder{make([]byte, 0, initialBufferSize)}
+	e.addDoc(reflect.ValueOf(in))
+	return e.out, nil
+}
+
+// Unmarshal deserializes data from in into the out value.  The out value
+// must be a map, a pointer to a struct, or a pointer to a bson.D value.
+// The lowercased field name is used as the key for each exported field,
+// but this behavior may be changed using the respective field tag.
+// The tag may also contain flags to tweak the marshalling behavior for
+// the field. The tag formats accepted are:
+//
+//     "[<key>][,<flag1>[,<flag2>]]"
+//
+//     `(...) bson:"[<key>][,<flag1>[,<flag2>]]" (...)`
+//
+// The following flags are currently supported during unmarshal (see the
+// Marshal method for other flags):
+//
+//     inline     Inline the field, which must be a struct or a map.
+//                Inlined structs are handled as if its fields were part
+//                of the outer struct. An inlined map causes keys that do
+//                not match any other struct field to be inserted in the
+//                map rather than being discarded as usual.
+//
+// The target field or element types of out may not necessarily match
+// the BSON values of the provided data.  The following conversions are
+// made automatically:
+//
+// - Numeric types are converted if at least the integer part of the
+//   value would be preserved correctly
+// - Bools are converted to numeric types as 1 or 0
+// - Numeric types are converted to bools as true if not 0 or false otherwise
+// - Binary and string BSON data is converted to a string, array or byte slice
+//
+// If the value would not fit the type and cannot be converted, it's
+// silently skipped.
+//
+// Pointer values are initialized when necessary.
+func Unmarshal(in []byte, out interface{}) (err error) {
+	if raw, ok := out.(*Raw); ok {
+		raw.Kind = 3
+		raw.Data = in
+		return nil
+	}
+	defer handleErr(&err)
+	v := reflect.ValueOf(out)
+	switch v.Kind() {
+	case reflect.Ptr:
+		fallthrough
+	case reflect.Map:
+		d := newDecoder(in)
+		d.readDocTo(v)
+	case reflect.Struct:
+		return errors.New("Unmarshal can't deal with struct values. Use a pointer.")
+	default:
+		return errors.New("Unmarshal needs a map or a pointer to a struct.")
+	}
+	return nil
+}
+
+// Unmarshal deserializes raw into the out value.  If the out value type
+// is not compatible with raw, a *bson.TypeError is returned.
+//
+// See the Unmarshal function documentation for more details on the
+// unmarshalling process.
+func (raw Raw) Unmarshal(out interface{}) (err error) {
+	defer handleErr(&err)
+	v := reflect.ValueOf(out)
+	switch v.Kind() {
+	case reflect.Ptr:
+		v = v.Elem()
+		fallthrough
+	case reflect.Map:
+		d := newDecoder(raw.Data)
+		good := d.readElemTo(v, raw.Kind)
+		if !good {
+			return &TypeError{v.Type(), raw.Kind}
+		}
+	case reflect.Struct:
+		return errors.New("Raw Unmarshal can't deal with struct values. Use a pointer.")
+	default:
+		return errors.New("Raw Unmarshal needs a map or a valid pointer.")
+	}
+	return nil
+}
+
+type TypeError struct {
+	Type reflect.Type
+	Kind byte
+}
+
+func (e *TypeError) Error() string {
+	return fmt.Sprintf("BSON kind 0x%02x isn't compatible with type %s", e.Kind, e.Type.String())
+}
+
+// --------------------------------------------------------------------------
+// Maintain a mapping of keys to structure field indexes
+
+type structInfo struct {
+	FieldsMap  map[string]fieldInfo
+	FieldsList []fieldInfo
+	InlineMap  int
+	Zero       reflect.Value
+}
+
+type fieldInfo struct {
+	Key       string
+	Num       int
+	OmitEmpty bool
+	MinSize   bool
+	Inline    []int
+}
+
+var structMap = make(map[reflect.Type]*structInfo)
+var structMapMutex sync.RWMutex
+
+type externalPanic string
+
+func (e externalPanic) String() string {
+	return string(e)
+}
+
+func getStructInfo(st reflect.Type) (*structInfo, error) {
+	structMapMutex.RLock()
+	sinfo, found := structMap[st]
+	structMapMutex.RUnlock()
+	if found {
+		return sinfo, nil
+	}
+	n := st.NumField()
+	fieldsMap := make(map[string]fieldInfo)
+	fieldsList := make([]fieldInfo, 0, n)
+	inlineMap := -1
+	for i := 0; i != n; i++ {
+		field := st.Field(i)
+		if field.PkgPath != "" {
+			continue // Private field
+		}
+
+		info := fieldInfo{Num: i}
+
+		tag := field.Tag.Get("bson")
+		if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
+			tag = string(field.Tag)
+		}
+		if tag == "-" {
+			continue
+		}
+
+		// XXX Drop this after a few releases.
+		if s := strings.Index(tag, "/"); s >= 0 {
+			recommend := tag[:s]
+			for _, c := range tag[s+1:] {
+				switch c {
+				case 'c':
+					recommend += ",omitempty"
+				case 's':
+					recommend += ",minsize"
+				default:
+					msg := fmt.Sprintf("Unsupported flag %q in tag %q of type %s", string([]byte{uint8(c)}), tag, st)
+					panic(externalPanic(msg))
+				}
+			}
+			msg := fmt.Sprintf("Replace tag %q in field %s of type %s by %q", tag, field.Name, st, recommend)
+			panic(externalPanic(msg))
+		}
+
+		inline := false
+		fields := strings.Split(tag, ",")
+		if len(fields) > 1 {
+			for _, flag := range fields[1:] {
+				switch flag {
+				case "omitempty":
+					info.OmitEmpty = true
+				case "minsize":
+					info.MinSize = true
+				case "inline":
+					inline = true
+				default:
+					msg := fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st)
+					panic(externalPanic(msg))
+				}
+			}
+			tag = fields[0]
+		}
+
+		if inline {
+			switch field.Type.Kind() {
+			case reflect.Map:
+				if inlineMap >= 0 {
+					return nil, errors.New("Multiple ,inline maps in struct " + st.String())
+				}
+				if field.Type.Key() != reflect.TypeOf("") {
+					return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
+				}
+				inlineMap = info.Num
+			case reflect.Struct:
+				sinfo, err := getStructInfo(field.Type)
+				if err != nil {
+					return nil, err
+				}
+				for _, finfo := range sinfo.FieldsList {
+					if _, found := fieldsMap[finfo.Key]; found {
+						msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String()
+						return nil, errors.New(msg)
+					}
+					if finfo.Inline == nil {
+						finfo.Inline = []int{i, finfo.Num}
+					} else {
+						finfo.Inline = append([]int{i}, finfo.Inline...)
+					}
+					fieldsMap[finfo.Key] = finfo
+					fieldsList = append(fieldsList, finfo)
+				}
+			default:
+				panic("Option ,inline needs a struct value or map field")
+			}
+			continue
+		}
+
+		if tag != "" {
+			info.Key = tag
+		} else {
+			info.Key = strings.ToLower(field.Name)
+		}
+
+		if _, found = fieldsMap[info.Key]; found {
+			msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
+			return nil, errors.New(msg)
+		}
+
+		fieldsList = append(fieldsList, info)
+		fieldsMap[info.Key] = info
+	}
+	sinfo = &structInfo{
+		fieldsMap,
+		fieldsList,
+		inlineMap,
+		reflect.New(st).Elem(),
+	}
+	structMapMutex.Lock()
+	structMap[st] = sinfo
+	structMapMutex.Unlock()
+	return sinfo, nil
+}
diff --git a/vendor/gopkg.in/mgo.v2/bson/decode.go b/vendor/gopkg.in/mgo.v2/bson/decode.go
new file mode 100644
index 00000000..bdd2e028
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/bson/decode.go
@@ -0,0 +1,825 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+// gobson - BSON library for Go.
+
+package bson
+
+import (
+	"fmt"
+	"math"
+	"net/url"
+	"reflect"
+	"strconv"
+	"sync"
+	"time"
+)
+
+type decoder struct {
+	in      []byte
+	i       int
+	docType reflect.Type
+}
+
+var typeM = reflect.TypeOf(M{})
+
+func newDecoder(in []byte) *decoder {
+	return &decoder{in, 0, typeM}
+}
+
+// --------------------------------------------------------------------------
+// Some helper functions.
+
+func corrupted() {
+	panic("Document is corrupted")
+}
+
+func settableValueOf(i interface{}) reflect.Value {
+	v := reflect.ValueOf(i)
+	sv := reflect.New(v.Type()).Elem()
+	sv.Set(v)
+	return sv
+}
+
+// --------------------------------------------------------------------------
+// Unmarshaling of documents.
+
+const (
+	setterUnknown = iota
+	setterNone
+	setterType
+	setterAddr
+)
+
+var setterStyles map[reflect.Type]int
+var setterIface reflect.Type
+var setterMutex sync.RWMutex
+
+func init() {
+	var iface Setter
+	setterIface = reflect.TypeOf(&iface).Elem()
+	setterStyles = make(map[reflect.Type]int)
+}
+
+func setterStyle(outt reflect.Type) int {
+	setterMutex.RLock()
+	style := setterStyles[outt]
+	setterMutex.RUnlock()
+	if style == setterUnknown {
+		setterMutex.Lock()
+		defer setterMutex.Unlock()
+		if outt.Implements(setterIface) {
+			setterStyles[outt] = setterType
+		} else if reflect.PtrTo(outt).Implements(setterIface) {
+			setterStyles[outt] = setterAddr
+		} else {
+			setterStyles[outt] = setterNone
+		}
+		style = setterStyles[outt]
+	}
+	return style
+}
+
+func getSetter(outt reflect.Type, out reflect.Value) Setter {
+	style := setterStyle(outt)
+	if style == setterNone {
+		return nil
+	}
+	if style == setterAddr {
+		if !out.CanAddr() {
+			return nil
+		}
+		out = out.Addr()
+	} else if outt.Kind() == reflect.Ptr && out.IsNil() {
+		out.Set(reflect.New(outt.Elem()))
+	}
+	return out.Interface().(Setter)
+}
+
+func clearMap(m reflect.Value) {
+	var none reflect.Value
+	for _, k := range m.MapKeys() {
+		m.SetMapIndex(k, none)
+	}
+}
+
+func (d *decoder) readDocTo(out reflect.Value) {
+	var elemType reflect.Type
+	outt := out.Type()
+	outk := outt.Kind()
+
+	for {
+		if outk == reflect.Ptr && out.IsNil() {
+			out.Set(reflect.New(outt.Elem()))
+		}
+		if setter := getSetter(outt, out); setter != nil {
+			var raw Raw
+			d.readDocTo(reflect.ValueOf(&raw))
+			err := setter.SetBSON(raw)
+			if _, ok := err.(*TypeError); err != nil && !ok {
+				panic(err)
+			}
+			return
+		}
+		if outk == reflect.Ptr {
+			out = out.Elem()
+			outt = out.Type()
+			outk = out.Kind()
+			continue
+		}
+		break
+	}
+
+	var fieldsMap map[string]fieldInfo
+	var inlineMap reflect.Value
+	start := d.i
+
+	origout := out
+	if outk == reflect.Interface {
+		if d.docType.Kind() == reflect.Map {
+			mv := reflect.MakeMap(d.docType)
+			out.Set(mv)
+			out = mv
+		} else {
+			dv := reflect.New(d.docType).Elem()
+			out.Set(dv)
+			out = dv
+		}
+		outt = out.Type()
+		outk = outt.Kind()
+	}
+
+	docType := d.docType
+	keyType := typeString
+	convertKey := false
+	switch outk {
+	case reflect.Map:
+		keyType = outt.Key()
+		if keyType.Kind() != reflect.String {
+			panic("BSON map must have string keys. Got: " + outt.String())
+		}
+		if keyType != typeString {
+			convertKey = true
+		}
+		elemType = outt.Elem()
+		if elemType == typeIface {
+			d.docType = outt
+		}
+		if out.IsNil() {
+			out.Set(reflect.MakeMap(out.Type()))
+		} else if out.Len() > 0 {
+			clearMap(out)
+		}
+	case reflect.Struct:
+		if outt != typeRaw {
+			sinfo, err := getStructInfo(out.Type())
+			if err != nil {
+				panic(err)
+			}
+			fieldsMap = sinfo.FieldsMap
+			out.Set(sinfo.Zero)
+			if sinfo.InlineMap != -1 {
+				inlineMap = out.Field(sinfo.InlineMap)
+				if !inlineMap.IsNil() && inlineMap.Len() > 0 {
+					clearMap(inlineMap)
+				}
+				elemType = inlineMap.Type().Elem()
+				if elemType == typeIface {
+					d.docType = inlineMap.Type()
+				}
+			}
+		}
+	case reflect.Slice:
+		switch outt.Elem() {
+		case typeDocElem:
+			origout.Set(d.readDocElems(outt))
+			return
+		case typeRawDocElem:
+			origout.Set(d.readRawDocElems(outt))
+			return
+		}
+		fallthrough
+	default:
+		panic("Unsupported document type for unmarshalling: " + out.Type().String())
+	}
+
+	end := int(d.readInt32())
+	end += d.i - 4
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	for d.in[d.i] != '\x00' {
+		kind := d.readByte()
+		name := d.readCStr()
+		if d.i >= end {
+			corrupted()
+		}
+
+		switch outk {
+		case reflect.Map:
+			e := reflect.New(elemType).Elem()
+			if d.readElemTo(e, kind) {
+				k := reflect.ValueOf(name)
+				if convertKey {
+					k = k.Convert(keyType)
+				}
+				out.SetMapIndex(k, e)
+			}
+		case reflect.Struct:
+			if outt == typeRaw {
+				d.dropElem(kind)
+			} else {
+				if info, ok := fieldsMap[name]; ok {
+					if info.Inline == nil {
+						d.readElemTo(out.Field(info.Num), kind)
+					} else {
+						d.readElemTo(out.FieldByIndex(info.Inline), kind)
+					}
+				} else if inlineMap.IsValid() {
+					if inlineMap.IsNil() {
+						inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+					}
+					e := reflect.New(elemType).Elem()
+					if d.readElemTo(e, kind) {
+						inlineMap.SetMapIndex(reflect.ValueOf(name), e)
+					}
+				} else {
+					d.dropElem(kind)
+				}
+			}
+		case reflect.Slice:
+		}
+
+		if d.i >= end {
+			corrupted()
+		}
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+	d.docType = docType
+
+	if outt == typeRaw {
+		out.Set(reflect.ValueOf(Raw{0x03, d.in[start:d.i]}))
+	}
+}
+
+func (d *decoder) readArrayDocTo(out reflect.Value) {
+	end := int(d.readInt32())
+	end += d.i - 4
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	i := 0
+	l := out.Len()
+	for d.in[d.i] != '\x00' {
+		if i >= l {
+			panic("Length mismatch on array field")
+		}
+		kind := d.readByte()
+		for d.i < end && d.in[d.i] != '\x00' {
+			d.i++
+		}
+		if d.i >= end {
+			corrupted()
+		}
+		d.i++
+		d.readElemTo(out.Index(i), kind)
+		if d.i >= end {
+			corrupted()
+		}
+		i++
+	}
+	if i != l {
+		panic("Length mismatch on array field")
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+}
+
+func (d *decoder) readSliceDoc(t reflect.Type) interface{} {
+	tmp := make([]reflect.Value, 0, 8)
+	elemType := t.Elem()
+
+	end := int(d.readInt32())
+	end += d.i - 4
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	for d.in[d.i] != '\x00' {
+		kind := d.readByte()
+		for d.i < end && d.in[d.i] != '\x00' {
+			d.i++
+		}
+		if d.i >= end {
+			corrupted()
+		}
+		d.i++
+		e := reflect.New(elemType).Elem()
+		if d.readElemTo(e, kind) {
+			tmp = append(tmp, e)
+		}
+		if d.i >= end {
+			corrupted()
+		}
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+
+	n := len(tmp)
+	slice := reflect.MakeSlice(t, n, n)
+	for i := 0; i != n; i++ {
+		slice.Index(i).Set(tmp[i])
+	}
+	return slice.Interface()
+}
+
+var typeSlice = reflect.TypeOf([]interface{}{})
+var typeIface = typeSlice.Elem()
+
+func (d *decoder) readDocElems(typ reflect.Type) reflect.Value {
+	docType := d.docType
+	d.docType = typ
+	slice := make([]DocElem, 0, 8)
+	d.readDocWith(func(kind byte, name string) {
+		e := DocElem{Name: name}
+		v := reflect.ValueOf(&e.Value)
+		if d.readElemTo(v.Elem(), kind) {
+			slice = append(slice, e)
+		}
+	})
+	slicev := reflect.New(typ).Elem()
+	slicev.Set(reflect.ValueOf(slice))
+	d.docType = docType
+	return slicev
+}
+
+func (d *decoder) readRawDocElems(typ reflect.Type) reflect.Value {
+	docType := d.docType
+	d.docType = typ
+	slice := make([]RawDocElem, 0, 8)
+	d.readDocWith(func(kind byte, name string) {
+		e := RawDocElem{Name: name}
+		v := reflect.ValueOf(&e.Value)
+		if d.readElemTo(v.Elem(), kind) {
+			slice = append(slice, e)
+		}
+	})
+	slicev := reflect.New(typ).Elem()
+	slicev.Set(reflect.ValueOf(slice))
+	d.docType = docType
+	return slicev
+}
+
+func (d *decoder) readDocWith(f func(kind byte, name string)) {
+	end := int(d.readInt32())
+	end += d.i - 4
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	for d.in[d.i] != '\x00' {
+		kind := d.readByte()
+		name := d.readCStr()
+		if d.i >= end {
+			corrupted()
+		}
+		f(kind, name)
+		if d.i >= end {
+			corrupted()
+		}
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+}
+
+// --------------------------------------------------------------------------
+// Unmarshaling of individual elements within a document.
+
+var blackHole = settableValueOf(struct{}{})
+
+func (d *decoder) dropElem(kind byte) {
+	d.readElemTo(blackHole, kind)
+}
+
+// Attempt to decode an element from the document and put it into out.
+// If the types are not compatible, the returned ok value will be
+// false and out will be unchanged.
+func (d *decoder) readElemTo(out reflect.Value, kind byte) (good bool) {
+
+	start := d.i
+
+	if kind == '\x03' {
+		// Delegate unmarshaling of documents.
+		outt := out.Type()
+		outk := out.Kind()
+		switch outk {
+		case reflect.Interface, reflect.Ptr, reflect.Struct, reflect.Map:
+			d.readDocTo(out)
+			return true
+		}
+		if setterStyle(outt) != setterNone {
+			d.readDocTo(out)
+			return true
+		}
+		if outk == reflect.Slice {
+			switch outt.Elem() {
+			case typeDocElem:
+				out.Set(d.readDocElems(outt))
+			case typeRawDocElem:
+				out.Set(d.readRawDocElems(outt))
+			}
+			return true
+		}
+		d.readDocTo(blackHole)
+		return true
+	}
+
+	var in interface{}
+
+	switch kind {
+	case 0x01: // Float64
+		in = d.readFloat64()
+	case 0x02: // UTF-8 string
+		in = d.readStr()
+	case 0x03: // Document
+		panic("Can't happen. Handled above.")
+	case 0x04: // Array
+		outt := out.Type()
+		if setterStyle(outt) != setterNone {
+			// Skip the value so its data is handed to the setter below.
+			d.dropElem(kind)
+			break
+		}
+		for outt.Kind() == reflect.Ptr {
+			outt = outt.Elem()
+		}
+		switch outt.Kind() {
+		case reflect.Array:
+			d.readArrayDocTo(out)
+			return true
+		case reflect.Slice:
+			in = d.readSliceDoc(outt)
+		default:
+			in = d.readSliceDoc(typeSlice)
+		}
+	case 0x05: // Binary
+		b := d.readBinary()
+		if b.Kind == 0x00 || b.Kind == 0x02 {
+			in = b.Data
+		} else {
+			in = b
+		}
+	case 0x06: // Undefined (obsolete, but still seen in the wild)
+		in = Undefined
+	case 0x07: // ObjectId
+		in = ObjectId(d.readBytes(12))
+	case 0x08: // Bool
+		in = d.readBool()
+	case 0x09: // Timestamp
+		// MongoDB handles timestamps as milliseconds.
+		i := d.readInt64()
+		if i == -62135596800000 {
+			in = time.Time{} // In UTC for convenience.
+		} else {
+			in = time.Unix(i/1e3, i%1e3*1e6)
+		}
+	case 0x0A: // Nil
+		in = nil
+	case 0x0B: // RegEx
+		in = d.readRegEx()
+	case 0x0C:
+		in = DBPointer{Namespace: d.readStr(), Id: ObjectId(d.readBytes(12))}
+	case 0x0D: // JavaScript without scope
+		in = JavaScript{Code: d.readStr()}
+	case 0x0E: // Symbol
+		in = Symbol(d.readStr())
+	case 0x0F: // JavaScript with scope
+		d.i += 4 // Skip length
+		js := JavaScript{d.readStr(), make(M)}
+		d.readDocTo(reflect.ValueOf(js.Scope))
+		in = js
+	case 0x10: // Int32
+		in = int(d.readInt32())
+	case 0x11: // Mongo-specific timestamp
+		in = MongoTimestamp(d.readInt64())
+	case 0x12: // Int64
+		in = d.readInt64()
+	case 0x7F: // Max key
+		in = MaxKey
+	case 0xFF: // Min key
+		in = MinKey
+	default:
+		panic(fmt.Sprintf("Unknown element kind (0x%02X)", kind))
+	}
+
+	outt := out.Type()
+
+	if outt == typeRaw {
+		out.Set(reflect.ValueOf(Raw{kind, d.in[start:d.i]}))
+		return true
+	}
+
+	if setter := getSetter(outt, out); setter != nil {
+		err := setter.SetBSON(Raw{kind, d.in[start:d.i]})
+		if err == SetZero {
+			out.Set(reflect.Zero(outt))
+			return true
+		}
+		if err == nil {
+			return true
+		}
+		if _, ok := err.(*TypeError); !ok {
+			panic(err)
+		}
+		return false
+	}
+
+	if in == nil {
+		out.Set(reflect.Zero(outt))
+		return true
+	}
+
+	outk := outt.Kind()
+
+	// Dereference and initialize pointer if necessary.
+	first := true
+	for outk == reflect.Ptr {
+		if !out.IsNil() {
+			out = out.Elem()
+		} else {
+			elem := reflect.New(outt.Elem())
+			if first {
+				// Only set if value is compatible.
+				first = false
+				defer func(out, elem reflect.Value) {
+					if good {
+						out.Set(elem)
+					}
+				}(out, elem)
+			} else {
+				out.Set(elem)
+			}
+			out = elem
+		}
+		outt = out.Type()
+		outk = outt.Kind()
+	}
+
+	inv := reflect.ValueOf(in)
+	if outt == inv.Type() {
+		out.Set(inv)
+		return true
+	}
+
+	switch outk {
+	case reflect.Interface:
+		out.Set(inv)
+		return true
+	case reflect.String:
+		switch inv.Kind() {
+		case reflect.String:
+			out.SetString(inv.String())
+			return true
+		case reflect.Slice:
+			if b, ok := in.([]byte); ok {
+				out.SetString(string(b))
+				return true
+			}
+		case reflect.Int, reflect.Int64:
+			if outt == typeJSONNumber {
+				out.SetString(strconv.FormatInt(inv.Int(), 10))
+				return true
+			}
+		case reflect.Float64:
+			if outt == typeJSONNumber {
+				out.SetString(strconv.FormatFloat(inv.Float(), 'f', -1, 64))
+				return true
+			}
+		}
+	case reflect.Slice, reflect.Array:
+		// Remember, array (0x04) slices are built with the correct
+		// element type.  If we are here, must be a cross BSON kind
+		// conversion (e.g. 0x05 unmarshalling on string).
+		if outt.Elem().Kind() != reflect.Uint8 {
+			break
+		}
+		switch inv.Kind() {
+		case reflect.String:
+			slice := []byte(inv.String())
+			out.Set(reflect.ValueOf(slice))
+			return true
+		case reflect.Slice:
+			switch outt.Kind() {
+			case reflect.Array:
+				reflect.Copy(out, inv)
+			case reflect.Slice:
+				out.SetBytes(inv.Bytes())
+			}
+			return true
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		switch inv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetInt(inv.Int())
+			return true
+		case reflect.Float32, reflect.Float64:
+			out.SetInt(int64(inv.Float()))
+			return true
+		case reflect.Bool:
+			if inv.Bool() {
+				out.SetInt(1)
+			} else {
+				out.SetInt(0)
+			}
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("can't happen: no uint types in BSON (!?)")
+		}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		switch inv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetUint(uint64(inv.Int()))
+			return true
+		case reflect.Float32, reflect.Float64:
+			out.SetUint(uint64(inv.Float()))
+			return true
+		case reflect.Bool:
+			if inv.Bool() {
+				out.SetUint(1)
+			} else {
+				out.SetUint(0)
+			}
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON.")
+		}
+	case reflect.Float32, reflect.Float64:
+		switch inv.Kind() {
+		case reflect.Float32, reflect.Float64:
+			out.SetFloat(inv.Float())
+			return true
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetFloat(float64(inv.Int()))
+			return true
+		case reflect.Bool:
+			if inv.Bool() {
+				out.SetFloat(1)
+			} else {
+				out.SetFloat(0)
+			}
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON?")
+		}
+	case reflect.Bool:
+		switch inv.Kind() {
+		case reflect.Bool:
+			out.SetBool(inv.Bool())
+			return true
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetBool(inv.Int() != 0)
+			return true
+		case reflect.Float32, reflect.Float64:
+			out.SetBool(inv.Float() != 0)
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON?")
+		}
+	case reflect.Struct:
+		if outt == typeURL && inv.Kind() == reflect.String {
+			u, err := url.Parse(inv.String())
+			if err != nil {
+				panic(err)
+			}
+			out.Set(reflect.ValueOf(u).Elem())
+			return true
+		}
+	}
+
+	return false
+}
+
+// --------------------------------------------------------------------------
+// Parsers of basic types.
+
+func (d *decoder) readRegEx() RegEx {
+	re := RegEx{}
+	re.Pattern = d.readCStr()
+	re.Options = d.readCStr()
+	return re
+}
+
+func (d *decoder) readBinary() Binary {
+	l := d.readInt32()
+	b := Binary{}
+	b.Kind = d.readByte()
+	b.Data = d.readBytes(l)
+	if b.Kind == 0x02 && len(b.Data) >= 4 {
+		// Weird obsolete format with redundant length.
+		b.Data = b.Data[4:]
+	}
+	return b
+}
+
+func (d *decoder) readStr() string {
+	l := d.readInt32()
+	b := d.readBytes(l - 1)
+	if d.readByte() != '\x00' {
+		corrupted()
+	}
+	return string(b)
+}
+
+func (d *decoder) readCStr() string {
+	start := d.i
+	end := start
+	l := len(d.in)
+	for ; end != l; end++ {
+		if d.in[end] == '\x00' {
+			break
+		}
+	}
+	d.i = end + 1
+	if d.i > l {
+		corrupted()
+	}
+	return string(d.in[start:end])
+}
+
+func (d *decoder) readBool() bool {
+	if d.readByte() == 1 {
+		return true
+	}
+	return false
+}
+
+func (d *decoder) readFloat64() float64 {
+	return math.Float64frombits(uint64(d.readInt64()))
+}
+
+func (d *decoder) readInt32() int32 {
+	b := d.readBytes(4)
+	return int32((uint32(b[0]) << 0) |
+		(uint32(b[1]) << 8) |
+		(uint32(b[2]) << 16) |
+		(uint32(b[3]) << 24))
+}
+
+func (d *decoder) readInt64() int64 {
+	b := d.readBytes(8)
+	return int64((uint64(b[0]) << 0) |
+		(uint64(b[1]) << 8) |
+		(uint64(b[2]) << 16) |
+		(uint64(b[3]) << 24) |
+		(uint64(b[4]) << 32) |
+		(uint64(b[5]) << 40) |
+		(uint64(b[6]) << 48) |
+		(uint64(b[7]) << 56))
+}
+
+func (d *decoder) readByte() byte {
+	i := d.i
+	d.i++
+	if d.i > len(d.in) {
+		corrupted()
+	}
+	return d.in[i]
+}
+
+func (d *decoder) readBytes(length int32) []byte {
+	start := d.i
+	d.i += int(length)
+	if d.i > len(d.in) {
+		corrupted()
+	}
+	return d.in[start : start+int(length)]
+}
diff --git a/vendor/gopkg.in/mgo.v2/bson/encode.go b/vendor/gopkg.in/mgo.v2/bson/encode.go
new file mode 100644
index 00000000..e1015091
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/bson/encode.go
@@ -0,0 +1,503 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+// gobson - BSON library for Go.
+
+package bson
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"net/url"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+// --------------------------------------------------------------------------
+// Some internal infrastructure.
+
+var (
+	typeBinary         = reflect.TypeOf(Binary{})
+	typeObjectId       = reflect.TypeOf(ObjectId(""))
+	typeDBPointer      = reflect.TypeOf(DBPointer{"", ObjectId("")})
+	typeSymbol         = reflect.TypeOf(Symbol(""))
+	typeMongoTimestamp = reflect.TypeOf(MongoTimestamp(0))
+	typeOrderKey       = reflect.TypeOf(MinKey)
+	typeDocElem        = reflect.TypeOf(DocElem{})
+	typeRawDocElem     = reflect.TypeOf(RawDocElem{})
+	typeRaw            = reflect.TypeOf(Raw{})
+	typeURL            = reflect.TypeOf(url.URL{})
+	typeTime           = reflect.TypeOf(time.Time{})
+	typeString         = reflect.TypeOf("")
+	typeJSONNumber     = reflect.TypeOf(json.Number(""))
+)
+
+const itoaCacheSize = 32
+
+var itoaCache []string
+
+func init() {
+	itoaCache = make([]string, itoaCacheSize)
+	for i := 0; i != itoaCacheSize; i++ {
+		itoaCache[i] = strconv.Itoa(i)
+	}
+}
+
+func itoa(i int) string {
+	if i < itoaCacheSize {
+		return itoaCache[i]
+	}
+	return strconv.Itoa(i)
+}
+
+// --------------------------------------------------------------------------
+// Marshaling of the document value itself.
+
+type encoder struct {
+	out []byte
+}
+
+func (e *encoder) addDoc(v reflect.Value) {
+	for {
+		if vi, ok := v.Interface().(Getter); ok {
+			getv, err := vi.GetBSON()
+			if err != nil {
+				panic(err)
+			}
+			v = reflect.ValueOf(getv)
+			continue
+		}
+		if v.Kind() == reflect.Ptr {
+			v = v.Elem()
+			continue
+		}
+		break
+	}
+
+	if v.Type() == typeRaw {
+		raw := v.Interface().(Raw)
+		if raw.Kind != 0x03 && raw.Kind != 0x00 {
+			panic("Attempted to unmarshal Raw kind " + strconv.Itoa(int(raw.Kind)) + " as a document")
+		}
+		e.addBytes(raw.Data...)
+		return
+	}
+
+	start := e.reserveInt32()
+
+	switch v.Kind() {
+	case reflect.Map:
+		e.addMap(v)
+	case reflect.Struct:
+		e.addStruct(v)
+	case reflect.Array, reflect.Slice:
+		e.addSlice(v)
+	default:
+		panic("Can't marshal " + v.Type().String() + " as a BSON document")
+	}
+
+	e.addBytes(0)
+	e.setInt32(start, int32(len(e.out)-start))
+}
+
+func (e *encoder) addMap(v reflect.Value) {
+	for _, k := range v.MapKeys() {
+		e.addElem(k.String(), v.MapIndex(k), false)
+	}
+}
+
+func (e *encoder) addStruct(v reflect.Value) {
+	sinfo, err := getStructInfo(v.Type())
+	if err != nil {
+		panic(err)
+	}
+	var value reflect.Value
+	if sinfo.InlineMap >= 0 {
+		m := v.Field(sinfo.InlineMap)
+		if m.Len() > 0 {
+			for _, k := range m.MapKeys() {
+				ks := k.String()
+				if _, found := sinfo.FieldsMap[ks]; found {
+					panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", ks))
+				}
+				e.addElem(ks, m.MapIndex(k), false)
+			}
+		}
+	}
+	for _, info := range sinfo.FieldsList {
+		if info.Inline == nil {
+			value = v.Field(info.Num)
+		} else {
+			value = v.FieldByIndex(info.Inline)
+		}
+		if info.OmitEmpty && isZero(value) {
+			continue
+		}
+		e.addElem(info.Key, value, info.MinSize)
+	}
+}
+
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.String:
+		return len(v.String()) == 0
+	case reflect.Ptr, reflect.Interface:
+		return v.IsNil()
+	case reflect.Slice:
+		return v.Len() == 0
+	case reflect.Map:
+		return v.Len() == 0
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Struct:
+		vt := v.Type()
+		if vt == typeTime {
+			return v.Interface().(time.Time).IsZero()
+		}
+		for i := 0; i < v.NumField(); i++ {
+			if vt.Field(i).PkgPath != "" {
+				continue // Private field
+			}
+			if !isZero(v.Field(i)) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+func (e *encoder) addSlice(v reflect.Value) {
+	vi := v.Interface()
+	if d, ok := vi.(D); ok {
+		for _, elem := range d {
+			e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+		}
+		return
+	}
+	if d, ok := vi.(RawD); ok {
+		for _, elem := range d {
+			e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+		}
+		return
+	}
+	l := v.Len()
+	et := v.Type().Elem()
+	if et == typeDocElem {
+		for i := 0; i < l; i++ {
+			elem := v.Index(i).Interface().(DocElem)
+			e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+		}
+		return
+	}
+	if et == typeRawDocElem {
+		for i := 0; i < l; i++ {
+			elem := v.Index(i).Interface().(RawDocElem)
+			e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+		}
+		return
+	}
+	for i := 0; i < l; i++ {
+		e.addElem(itoa(i), v.Index(i), false)
+	}
+}
+
+// --------------------------------------------------------------------------
+// Marshaling of elements in a document.
+
+func (e *encoder) addElemName(kind byte, name string) {
+	e.addBytes(kind)
+	e.addBytes([]byte(name)...)
+	e.addBytes(0)
+}
+
+func (e *encoder) addElem(name string, v reflect.Value, minSize bool) {
+
+	if !v.IsValid() {
+		e.addElemName('\x0A', name)
+		return
+	}
+
+	if getter, ok := v.Interface().(Getter); ok {
+		getv, err := getter.GetBSON()
+		if err != nil {
+			panic(err)
+		}
+		e.addElem(name, reflect.ValueOf(getv), minSize)
+		return
+	}
+
+	switch v.Kind() {
+
+	case reflect.Interface:
+		e.addElem(name, v.Elem(), minSize)
+
+	case reflect.Ptr:
+		e.addElem(name, v.Elem(), minSize)
+
+	case reflect.String:
+		s := v.String()
+		switch v.Type() {
+		case typeObjectId:
+			if len(s) != 12 {
+				panic("ObjectIDs must be exactly 12 bytes long (got " +
+					strconv.Itoa(len(s)) + ")")
+			}
+			e.addElemName('\x07', name)
+			e.addBytes([]byte(s)...)
+		case typeSymbol:
+			e.addElemName('\x0E', name)
+			e.addStr(s)
+		case typeJSONNumber:
+			n := v.Interface().(json.Number)
+			if i, err := n.Int64(); err == nil {
+				e.addElemName('\x12', name)
+				e.addInt64(i)
+			} else if f, err := n.Float64(); err == nil {
+				e.addElemName('\x01', name)
+				e.addFloat64(f)
+			} else {
+				panic("failed to convert json.Number to a number: " + s)
+			}
+		default:
+			e.addElemName('\x02', name)
+			e.addStr(s)
+		}
+
+	case reflect.Float32, reflect.Float64:
+		e.addElemName('\x01', name)
+		e.addFloat64(v.Float())
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		u := v.Uint()
+		if int64(u) < 0 {
+			panic("BSON has no uint64 type, and value is too large to fit correctly in an int64")
+		} else if u <= math.MaxInt32 && (minSize || v.Kind() <= reflect.Uint32) {
+			e.addElemName('\x10', name)
+			e.addInt32(int32(u))
+		} else {
+			e.addElemName('\x12', name)
+			e.addInt64(int64(u))
+		}
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		switch v.Type() {
+		case typeMongoTimestamp:
+			e.addElemName('\x11', name)
+			e.addInt64(v.Int())
+
+		case typeOrderKey:
+			if v.Int() == int64(MaxKey) {
+				e.addElemName('\x7F', name)
+			} else {
+				e.addElemName('\xFF', name)
+			}
+
+		default:
+			i := v.Int()
+			if (minSize || v.Type().Kind() != reflect.Int64) && i >= math.MinInt32 && i <= math.MaxInt32 {
+				// It fits into an int32, encode as such.
+				e.addElemName('\x10', name)
+				e.addInt32(int32(i))
+			} else {
+				e.addElemName('\x12', name)
+				e.addInt64(i)
+			}
+		}
+
+	case reflect.Bool:
+		e.addElemName('\x08', name)
+		if v.Bool() {
+			e.addBytes(1)
+		} else {
+			e.addBytes(0)
+		}
+
+	case reflect.Map:
+		e.addElemName('\x03', name)
+		e.addDoc(v)
+
+	case reflect.Slice:
+		vt := v.Type()
+		et := vt.Elem()
+		if et.Kind() == reflect.Uint8 {
+			e.addElemName('\x05', name)
+			e.addBinary('\x00', v.Bytes())
+		} else if et == typeDocElem || et == typeRawDocElem {
+			e.addElemName('\x03', name)
+			e.addDoc(v)
+		} else {
+			e.addElemName('\x04', name)
+			e.addDoc(v)
+		}
+
+	case reflect.Array:
+		et := v.Type().Elem()
+		if et.Kind() == reflect.Uint8 {
+			e.addElemName('\x05', name)
+			if v.CanAddr() {
+				e.addBinary('\x00', v.Slice(0, v.Len()).Interface().([]byte))
+			} else {
+				n := v.Len()
+				e.addInt32(int32(n))
+				e.addBytes('\x00')
+				for i := 0; i < n; i++ {
+					el := v.Index(i)
+					e.addBytes(byte(el.Uint()))
+				}
+			}
+		} else {
+			e.addElemName('\x04', name)
+			e.addDoc(v)
+		}
+
+	case reflect.Struct:
+		switch s := v.Interface().(type) {
+
+		case Raw:
+			kind := s.Kind
+			if kind == 0x00 {
+				kind = 0x03
+			}
+			e.addElemName(kind, name)
+			e.addBytes(s.Data...)
+
+		case Binary:
+			e.addElemName('\x05', name)
+			e.addBinary(s.Kind, s.Data)
+
+		case DBPointer:
+			e.addElemName('\x0C', name)
+			e.addStr(s.Namespace)
+			if len(s.Id) != 12 {
+				panic("ObjectIDs must be exactly 12 bytes long (got " +
+					strconv.Itoa(len(s.Id)) + ")")
+			}
+			e.addBytes([]byte(s.Id)...)
+
+		case RegEx:
+			e.addElemName('\x0B', name)
+			e.addCStr(s.Pattern)
+			e.addCStr(s.Options)
+
+		case JavaScript:
+			if s.Scope == nil {
+				e.addElemName('\x0D', name)
+				e.addStr(s.Code)
+			} else {
+				e.addElemName('\x0F', name)
+				start := e.reserveInt32()
+				e.addStr(s.Code)
+				e.addDoc(reflect.ValueOf(s.Scope))
+				e.setInt32(start, int32(len(e.out)-start))
+			}
+
+		case time.Time:
+			// MongoDB handles timestamps as milliseconds.
+			e.addElemName('\x09', name)
+			e.addInt64(s.Unix()*1000 + int64(s.Nanosecond()/1e6))
+
+		case url.URL:
+			e.addElemName('\x02', name)
+			e.addStr(s.String())
+
+		case undefined:
+			e.addElemName('\x06', name)
+
+		default:
+			e.addElemName('\x03', name)
+			e.addDoc(v)
+		}
+
+	default:
+		panic("Can't marshal " + v.Type().String() + " in a BSON document")
+	}
+}
+
+// --------------------------------------------------------------------------
+// Marshaling of base types.
+
+func (e *encoder) addBinary(subtype byte, v []byte) {
+	if subtype == 0x02 {
+		// Wonder how that brilliant idea came to life. Obsolete, luckily.
+		e.addInt32(int32(len(v) + 4))
+		e.addBytes(subtype)
+		e.addInt32(int32(len(v)))
+	} else {
+		e.addInt32(int32(len(v)))
+		e.addBytes(subtype)
+	}
+	e.addBytes(v...)
+}
+
+func (e *encoder) addStr(v string) {
+	e.addInt32(int32(len(v) + 1))
+	e.addCStr(v)
+}
+
+func (e *encoder) addCStr(v string) {
+	e.addBytes([]byte(v)...)
+	e.addBytes(0)
+}
+
+func (e *encoder) reserveInt32() (pos int) {
+	pos = len(e.out)
+	e.addBytes(0, 0, 0, 0)
+	return pos
+}
+
+func (e *encoder) setInt32(pos int, v int32) {
+	e.out[pos+0] = byte(v)
+	e.out[pos+1] = byte(v >> 8)
+	e.out[pos+2] = byte(v >> 16)
+	e.out[pos+3] = byte(v >> 24)
+}
+
+func (e *encoder) addInt32(v int32) {
+	u := uint32(v)
+	e.addBytes(byte(u), byte(u>>8), byte(u>>16), byte(u>>24))
+}
+
+func (e *encoder) addInt64(v int64) {
+	u := uint64(v)
+	e.addBytes(byte(u), byte(u>>8), byte(u>>16), byte(u>>24),
+		byte(u>>32), byte(u>>40), byte(u>>48), byte(u>>56))
+}
+
+func (e *encoder) addFloat64(v float64) {
+	e.addInt64(int64(math.Float64bits(v)))
+}
+
+func (e *encoder) addBytes(v ...byte) {
+	e.out = append(e.out, v...)
+}
diff --git a/vendor/gopkg.in/mgo.v2/bulk.go b/vendor/gopkg.in/mgo.v2/bulk.go
new file mode 100644
index 00000000..23f45085
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/bulk.go
@@ -0,0 +1,71 @@
+package mgo
+
+// Bulk represents an operation that can be prepared with several
+// orthogonal changes before being delivered to the server.
+//
+// WARNING: This API is still experimental.
+//
+// Relevant documentation:
+//
+//   http://blog.mongodb.org/post/84922794768/mongodbs-new-bulk-api
+//
+type Bulk struct {
+	c       *Collection
+	ordered bool
+	inserts []interface{}
+}
+
+// BulkError holds an error returned from running a Bulk operation.
+//
+// TODO: This is private for the moment, until we understand exactly how
+//       to report these multi-errors in a useful and convenient way.
+type bulkError struct {
+	err error
+}
+
+// BulkResult holds the results for a bulk operation.
+type BulkResult struct {
+	// Be conservative while we understand exactly how to report these
+	// results in a useful and convenient way, and also how to emulate
+	// them with prior servers.
+	private bool
+}
+
+func (e *bulkError) Error() string {
+	return e.err.Error()
+}
+
+// Bulk returns a value to prepare the execution of a bulk operation.
+//
+// WARNING: This API is still experimental.
+//
+func (c *Collection) Bulk() *Bulk {
+	return &Bulk{c: c, ordered: true}
+}
+
+// Unordered puts the bulk operation in unordered mode.
+//
+// In unordered mode the indvidual operations may be sent
+// out of order, which means latter operations may proceed
+// even if prior ones have failed.
+func (b *Bulk) Unordered() {
+	b.ordered = false
+}
+
+// Insert queues up the provided documents for insertion.
+func (b *Bulk) Insert(docs ...interface{}) {
+	b.inserts = append(b.inserts, docs...)
+}
+
+// Run runs all the operations queued up.
+func (b *Bulk) Run() (*BulkResult, error) {
+	op := &insertOp{b.c.FullName, b.inserts, 0}
+	if !b.ordered {
+		op.flags = 1 // ContinueOnError
+	}
+	_, err := b.c.writeQuery(op)
+	if err != nil {
+		return nil, &bulkError{err}
+	}
+	return &BulkResult{}, nil
+}
diff --git a/vendor/gopkg.in/mgo.v2/cluster.go b/vendor/gopkg.in/mgo.v2/cluster.go
new file mode 100644
index 00000000..55bb7bbc
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/cluster.go
@@ -0,0 +1,632 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"sync"
+	"time"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+// ---------------------------------------------------------------------------
+// Mongo cluster encapsulation.
+//
+// A cluster enables the communication with one or more servers participating
+// in a mongo cluster.  This works with individual servers, a replica set,
+// a replica pair, one or multiple mongos routers, etc.
+
+type mongoCluster struct {
+	sync.RWMutex
+	serverSynced sync.Cond
+	userSeeds    []string
+	dynaSeeds    []string
+	servers      mongoServers
+	masters      mongoServers
+	references   int
+	syncing      bool
+	direct       bool
+	failFast     bool
+	syncCount    uint
+	setName      string
+	cachedIndex  map[string]bool
+	sync         chan bool
+	dial         dialer
+}
+
+func newCluster(userSeeds []string, direct, failFast bool, dial dialer, setName string) *mongoCluster {
+	cluster := &mongoCluster{
+		userSeeds:  userSeeds,
+		references: 1,
+		direct:     direct,
+		failFast:   failFast,
+		dial:       dial,
+		setName:    setName,
+	}
+	cluster.serverSynced.L = cluster.RWMutex.RLocker()
+	cluster.sync = make(chan bool, 1)
+	stats.cluster(+1)
+	go cluster.syncServersLoop()
+	return cluster
+}
+
+// Acquire increases the reference count for the cluster.
+func (cluster *mongoCluster) Acquire() {
+	cluster.Lock()
+	cluster.references++
+	debugf("Cluster %p acquired (refs=%d)", cluster, cluster.references)
+	cluster.Unlock()
+}
+
+// Release decreases the reference count for the cluster. Once
+// it reaches zero, all servers will be closed.
+func (cluster *mongoCluster) Release() {
+	cluster.Lock()
+	if cluster.references == 0 {
+		panic("cluster.Release() with references == 0")
+	}
+	cluster.references--
+	debugf("Cluster %p released (refs=%d)", cluster, cluster.references)
+	if cluster.references == 0 {
+		for _, server := range cluster.servers.Slice() {
+			server.Close()
+		}
+		// Wake up the sync loop so it can die.
+		cluster.syncServers()
+		stats.cluster(-1)
+	}
+	cluster.Unlock()
+}
+
+func (cluster *mongoCluster) LiveServers() (servers []string) {
+	cluster.RLock()
+	for _, serv := range cluster.servers.Slice() {
+		servers = append(servers, serv.Addr)
+	}
+	cluster.RUnlock()
+	return servers
+}
+
+func (cluster *mongoCluster) removeServer(server *mongoServer) {
+	cluster.Lock()
+	cluster.masters.Remove(server)
+	other := cluster.servers.Remove(server)
+	cluster.Unlock()
+	if other != nil {
+		other.Close()
+		log("Removed server ", server.Addr, " from cluster.")
+	}
+	server.Close()
+}
+
+type isMasterResult struct {
+	IsMaster       bool
+	Secondary      bool
+	Primary        string
+	Hosts          []string
+	Passives       []string
+	Tags           bson.D
+	Msg            string
+	SetName        string `bson:"setName"`
+	MaxWireVersion int    `bson:"maxWireVersion"`
+}
+
+func (cluster *mongoCluster) isMaster(socket *mongoSocket, result *isMasterResult) error {
+	// Monotonic let's it talk to a slave and still hold the socket.
+	session := newSession(Monotonic, cluster, 10*time.Second)
+	session.setSocket(socket)
+	err := session.Run("ismaster", result)
+	session.Close()
+	return err
+}
+
+type possibleTimeout interface {
+	Timeout() bool
+}
+
+var syncSocketTimeout = 5 * time.Second
+
+func (cluster *mongoCluster) syncServer(server *mongoServer) (info *mongoServerInfo, hosts []string, err error) {
+	var syncTimeout time.Duration
+	if raceDetector {
+		// This variable is only ever touched by tests.
+		globalMutex.Lock()
+		syncTimeout = syncSocketTimeout
+		globalMutex.Unlock()
+	} else {
+		syncTimeout = syncSocketTimeout
+	}
+
+	addr := server.Addr
+	log("SYNC Processing ", addr, "...")
+
+	// Retry a few times to avoid knocking a server down for a hiccup.
+	var result isMasterResult
+	var tryerr error
+	for retry := 0; ; retry++ {
+		if retry == 3 || retry == 1 && cluster.failFast {
+			return nil, nil, tryerr
+		}
+		if retry > 0 {
+			// Don't abuse the server needlessly if there's something actually wrong.
+			if err, ok := tryerr.(possibleTimeout); ok && err.Timeout() {
+				// Give a chance for waiters to timeout as well.
+				cluster.serverSynced.Broadcast()
+			}
+			time.Sleep(syncShortDelay)
+		}
+
+		// It's not clear what would be a good timeout here. Is it
+		// better to wait longer or to retry?
+		socket, _, err := server.AcquireSocket(0, syncTimeout)
+		if err != nil {
+			tryerr = err
+			logf("SYNC Failed to get socket to %s: %v", addr, err)
+			continue
+		}
+		err = cluster.isMaster(socket, &result)
+		socket.Release()
+		if err != nil {
+			tryerr = err
+			logf("SYNC Command 'ismaster' to %s failed: %v", addr, err)
+			continue
+		}
+		debugf("SYNC Result of 'ismaster' from %s: %#v", addr, result)
+		break
+	}
+
+	if cluster.setName != "" && result.SetName != cluster.setName {
+		logf("SYNC Server %s is not a member of replica set %q", addr, cluster.setName)
+		return nil, nil, fmt.Errorf("server %s is not a member of replica set %q", addr, cluster.setName)
+	}
+
+	if result.IsMaster {
+		debugf("SYNC %s is a master.", addr)
+		if !server.info.Master {
+			// Made an incorrect assumption above, so fix stats.
+			stats.conn(-1, false)
+			stats.conn(+1, true)
+		}
+	} else if result.Secondary {
+		debugf("SYNC %s is a slave.", addr)
+	} else if cluster.direct {
+		logf("SYNC %s in unknown state. Pretending it's a slave due to direct connection.", addr)
+	} else {
+		logf("SYNC %s is neither a master nor a slave.", addr)
+		// Let stats track it as whatever was known before.
+		return nil, nil, errors.New(addr + " is not a master nor slave")
+	}
+
+	info = &mongoServerInfo{
+		Master:         result.IsMaster,
+		Mongos:         result.Msg == "isdbgrid",
+		Tags:           result.Tags,
+		SetName:        result.SetName,
+		MaxWireVersion: result.MaxWireVersion,
+	}
+
+	hosts = make([]string, 0, 1+len(result.Hosts)+len(result.Passives))
+	if result.Primary != "" {
+		// First in the list to speed up master discovery.
+		hosts = append(hosts, result.Primary)
+	}
+	hosts = append(hosts, result.Hosts...)
+	hosts = append(hosts, result.Passives...)
+
+	debugf("SYNC %s knows about the following peers: %#v", addr, hosts)
+	return info, hosts, nil
+}
+
+type syncKind bool
+
+const (
+	completeSync syncKind = true
+	partialSync  syncKind = false
+)
+
+func (cluster *mongoCluster) addServer(server *mongoServer, info *mongoServerInfo, syncKind syncKind) {
+	cluster.Lock()
+	current := cluster.servers.Search(server.ResolvedAddr)
+	if current == nil {
+		if syncKind == partialSync {
+			cluster.Unlock()
+			server.Close()
+			log("SYNC Discarding unknown server ", server.Addr, " due to partial sync.")
+			return
+		}
+		cluster.servers.Add(server)
+		if info.Master {
+			cluster.masters.Add(server)
+			log("SYNC Adding ", server.Addr, " to cluster as a master.")
+		} else {
+			log("SYNC Adding ", server.Addr, " to cluster as a slave.")
+		}
+	} else {
+		if server != current {
+			panic("addServer attempting to add duplicated server")
+		}
+		if server.Info().Master != info.Master {
+			if info.Master {
+				log("SYNC Server ", server.Addr, " is now a master.")
+				cluster.masters.Add(server)
+			} else {
+				log("SYNC Server ", server.Addr, " is now a slave.")
+				cluster.masters.Remove(server)
+			}
+		}
+	}
+	server.SetInfo(info)
+	debugf("SYNC Broadcasting availability of server %s", server.Addr)
+	cluster.serverSynced.Broadcast()
+	cluster.Unlock()
+}
+
+func (cluster *mongoCluster) getKnownAddrs() []string {
+	cluster.RLock()
+	max := len(cluster.userSeeds) + len(cluster.dynaSeeds) + cluster.servers.Len()
+	seen := make(map[string]bool, max)
+	known := make([]string, 0, max)
+
+	add := func(addr string) {
+		if _, found := seen[addr]; !found {
+			seen[addr] = true
+			known = append(known, addr)
+		}
+	}
+
+	for _, addr := range cluster.userSeeds {
+		add(addr)
+	}
+	for _, addr := range cluster.dynaSeeds {
+		add(addr)
+	}
+	for _, serv := range cluster.servers.Slice() {
+		add(serv.Addr)
+	}
+	cluster.RUnlock()
+
+	return known
+}
+
+// syncServers injects a value into the cluster.sync channel to force
+// an iteration of the syncServersLoop function.
+func (cluster *mongoCluster) syncServers() {
+	select {
+	case cluster.sync <- true:
+	default:
+	}
+}
+
+// How long to wait for a checkup of the cluster topology if nothing
+// else kicks a synchronization before that.
+const syncServersDelay = 30 * time.Second
+const syncShortDelay = 500 * time.Millisecond
+
+// syncServersLoop loops while the cluster is alive to keep its idea of
+// the server topology up-to-date. It must be called just once from
+// newCluster.  The loop iterates once syncServersDelay has passed, or
+// if somebody injects a value into the cluster.sync channel to force a
+// synchronization.  A loop iteration will contact all servers in
+// parallel, ask them about known peers and their own role within the
+// cluster, and then attempt to do the same with all the peers
+// retrieved.
+func (cluster *mongoCluster) syncServersLoop() {
+	for {
+		debugf("SYNC Cluster %p is starting a sync loop iteration.", cluster)
+
+		cluster.Lock()
+		if cluster.references == 0 {
+			cluster.Unlock()
+			break
+		}
+		cluster.references++ // Keep alive while syncing.
+		direct := cluster.direct
+		cluster.Unlock()
+
+		cluster.syncServersIteration(direct)
+
+		// We just synchronized, so consume any outstanding requests.
+		select {
+		case <-cluster.sync:
+		default:
+		}
+
+		cluster.Release()
+
+		// Hold off before allowing another sync. No point in
+		// burning CPU looking for down servers.
+		if !cluster.failFast {
+			time.Sleep(syncShortDelay)
+		}
+
+		cluster.Lock()
+		if cluster.references == 0 {
+			cluster.Unlock()
+			break
+		}
+		cluster.syncCount++
+		// Poke all waiters so they have a chance to timeout or
+		// restart syncing if they wish to.
+		cluster.serverSynced.Broadcast()
+		// Check if we have to restart immediately either way.
+		restart := !direct && cluster.masters.Empty() || cluster.servers.Empty()
+		cluster.Unlock()
+
+		if restart {
+			log("SYNC No masters found. Will synchronize again.")
+			time.Sleep(syncShortDelay)
+			continue
+		}
+
+		debugf("SYNC Cluster %p waiting for next requested or scheduled sync.", cluster)
+
+		// Hold off until somebody explicitly requests a synchronization
+		// or it's time to check for a cluster topology change again.
+		select {
+		case <-cluster.sync:
+		case <-time.After(syncServersDelay):
+		}
+	}
+	debugf("SYNC Cluster %p is stopping its sync loop.", cluster)
+}
+
+func (cluster *mongoCluster) server(addr string, tcpaddr *net.TCPAddr) *mongoServer {
+	cluster.RLock()
+	server := cluster.servers.Search(tcpaddr.String())
+	cluster.RUnlock()
+	if server != nil {
+		return server
+	}
+	return newServer(addr, tcpaddr, cluster.sync, cluster.dial)
+}
+
+func resolveAddr(addr string) (*net.TCPAddr, error) {
+	// This hack allows having a timeout on resolution.
+	conn, err := net.DialTimeout("udp", addr, 10*time.Second)
+	if err != nil {
+		log("SYNC Failed to resolve server address: ", addr)
+		return nil, errors.New("failed to resolve server address: " + addr)
+	}
+	tcpaddr := (*net.TCPAddr)(conn.RemoteAddr().(*net.UDPAddr))
+	conn.Close()
+	if tcpaddr.String() != addr {
+		debug("SYNC Address ", addr, " resolved as ", tcpaddr.String())
+	}
+	return tcpaddr, nil
+}
+
+type pendingAdd struct {
+	server *mongoServer
+	info   *mongoServerInfo
+}
+
+func (cluster *mongoCluster) syncServersIteration(direct bool) {
+	log("SYNC Starting full topology synchronization...")
+
+	var wg sync.WaitGroup
+	var m sync.Mutex
+	notYetAdded := make(map[string]pendingAdd)
+	addIfFound := make(map[string]bool)
+	seen := make(map[string]bool)
+	syncKind := partialSync
+
+	var spawnSync func(addr string, byMaster bool)
+	spawnSync = func(addr string, byMaster bool) {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			tcpaddr, err := resolveAddr(addr)
+			if err != nil {
+				log("SYNC Failed to start sync of ", addr, ": ", err.Error())
+				return
+			}
+			resolvedAddr := tcpaddr.String()
+
+			m.Lock()
+			if byMaster {
+				if pending, ok := notYetAdded[resolvedAddr]; ok {
+					delete(notYetAdded, resolvedAddr)
+					m.Unlock()
+					cluster.addServer(pending.server, pending.info, completeSync)
+					return
+				}
+				addIfFound[resolvedAddr] = true
+			}
+			if seen[resolvedAddr] {
+				m.Unlock()
+				return
+			}
+			seen[resolvedAddr] = true
+			m.Unlock()
+
+			server := cluster.server(addr, tcpaddr)
+			info, hosts, err := cluster.syncServer(server)
+			if err != nil {
+				cluster.removeServer(server)
+				return
+			}
+
+			m.Lock()
+			add := direct || info.Master || addIfFound[resolvedAddr]
+			if add {
+				syncKind = completeSync
+			} else {
+				notYetAdded[resolvedAddr] = pendingAdd{server, info}
+			}
+			m.Unlock()
+			if add {
+				cluster.addServer(server, info, completeSync)
+			}
+			if !direct {
+				for _, addr := range hosts {
+					spawnSync(addr, info.Master)
+				}
+			}
+		}()
+	}
+
+	knownAddrs := cluster.getKnownAddrs()
+	for _, addr := range knownAddrs {
+		spawnSync(addr, false)
+	}
+	wg.Wait()
+
+	if syncKind == completeSync {
+		logf("SYNC Synchronization was complete (got data from primary).")
+		for _, pending := range notYetAdded {
+			cluster.removeServer(pending.server)
+		}
+	} else {
+		logf("SYNC Synchronization was partial (cannot talk to primary).")
+		for _, pending := range notYetAdded {
+			cluster.addServer(pending.server, pending.info, partialSync)
+		}
+	}
+
+	cluster.Lock()
+	ml := cluster.masters.Len()
+	logf("SYNC Synchronization completed: %d master(s) and %d slave(s) alive.", ml, cluster.servers.Len()-ml)
+
+	// Update dynamic seeds, but only if we have any good servers. Otherwise,
+	// leave them alone for better chances of a successful sync in the future.
+	if syncKind == completeSync {
+		dynaSeeds := make([]string, cluster.servers.Len())
+		for i, server := range cluster.servers.Slice() {
+			dynaSeeds[i] = server.Addr
+		}
+		cluster.dynaSeeds = dynaSeeds
+		debugf("SYNC New dynamic seeds: %#v\n", dynaSeeds)
+	}
+	cluster.Unlock()
+}
+
+// AcquireSocket returns a socket to a server in the cluster.  If slaveOk is
+// true, it will attempt to return a socket to a slave server.  If it is
+// false, the socket will necessarily be to a master server.
+func (cluster *mongoCluster) AcquireSocket(slaveOk bool, syncTimeout time.Duration, socketTimeout time.Duration, serverTags []bson.D, poolLimit int) (s *mongoSocket, err error) {
+	var started time.Time
+	var syncCount uint
+	warnedLimit := false
+	for {
+		cluster.RLock()
+		for {
+			ml := cluster.masters.Len()
+			sl := cluster.servers.Len()
+			debugf("Cluster has %d known masters and %d known slaves.", ml, sl-ml)
+			if ml > 0 || slaveOk && sl > 0 {
+				break
+			}
+			if started.IsZero() {
+				// Initialize after fast path above.
+				started = time.Now()
+				syncCount = cluster.syncCount
+			} else if syncTimeout != 0 && started.Before(time.Now().Add(-syncTimeout)) || cluster.failFast && cluster.syncCount != syncCount {
+				cluster.RUnlock()
+				return nil, errors.New("no reachable servers")
+			}
+			log("Waiting for servers to synchronize...")
+			cluster.syncServers()
+
+			// Remember: this will release and reacquire the lock.
+			cluster.serverSynced.Wait()
+		}
+
+		var server *mongoServer
+		if slaveOk {
+			server = cluster.servers.BestFit(serverTags)
+		} else {
+			server = cluster.masters.BestFit(nil)
+		}
+		cluster.RUnlock()
+
+		if server == nil {
+			// Must have failed the requested tags. Sleep to avoid spinning.
+			time.Sleep(1e8)
+			continue
+		}
+
+		s, abended, err := server.AcquireSocket(poolLimit, socketTimeout)
+		if err == errPoolLimit {
+			if !warnedLimit {
+				warnedLimit = true
+				log("WARNING: Per-server connection limit reached.")
+			}
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+		if err != nil {
+			cluster.removeServer(server)
+			cluster.syncServers()
+			continue
+		}
+		if abended && !slaveOk {
+			var result isMasterResult
+			err := cluster.isMaster(s, &result)
+			if err != nil || !result.IsMaster {
+				logf("Cannot confirm server %s as master (%v)", server.Addr, err)
+				s.Release()
+				cluster.syncServers()
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+		}
+		return s, nil
+	}
+	panic("unreached")
+}
+
+func (cluster *mongoCluster) CacheIndex(cacheKey string, exists bool) {
+	cluster.Lock()
+	if cluster.cachedIndex == nil {
+		cluster.cachedIndex = make(map[string]bool)
+	}
+	if exists {
+		cluster.cachedIndex[cacheKey] = true
+	} else {
+		delete(cluster.cachedIndex, cacheKey)
+	}
+	cluster.Unlock()
+}
+
+func (cluster *mongoCluster) HasCachedIndex(cacheKey string) (result bool) {
+	cluster.RLock()
+	if cluster.cachedIndex != nil {
+		result = cluster.cachedIndex[cacheKey]
+	}
+	cluster.RUnlock()
+	return
+}
+
+func (cluster *mongoCluster) ResetIndexCache() {
+	cluster.Lock()
+	cluster.cachedIndex = make(map[string]bool)
+	cluster.Unlock()
+}
diff --git a/vendor/gopkg.in/mgo.v2/doc.go b/vendor/gopkg.in/mgo.v2/doc.go
new file mode 100644
index 00000000..9316c555
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/doc.go
@@ -0,0 +1,31 @@
+// Package mgo offers a rich MongoDB driver for Go.
+//
+// Details about the mgo project (pronounced as "mango") are found
+// in its web page:
+//
+//     http://labix.org/mgo
+//
+// Usage of the driver revolves around the concept of sessions.  To
+// get started, obtain a session using the Dial function:
+//
+//     session, err := mgo.Dial(url)
+//
+// This will establish one or more connections with the cluster of
+// servers defined by the url parameter.  From then on, the cluster
+// may be queried with multiple consistency rules (see SetMode) and
+// documents retrieved with statements such as:
+//
+//     c := session.DB(database).C(collection)
+//     err := c.Find(query).One(&result)
+//
+// New sessions are typically created by calling session.Copy on the
+// initial session obtained at dial time. These new sessions will share
+// the same cluster information and connection cache, and may be easily
+// handed into other methods and functions for organizing logic.
+// Every session created must have its Close method called at the end
+// of its life time, so its resources may be put back in the pool or
+// collected, depending on the case.
+//
+// For more details, see the documentation for the types and methods.
+//
+package mgo
diff --git a/vendor/gopkg.in/mgo.v2/gridfs.go b/vendor/gopkg.in/mgo.v2/gridfs.go
new file mode 100644
index 00000000..54b3dd50
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/gridfs.go
@@ -0,0 +1,755 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"errors"
+	"hash"
+	"io"
+	"os"
+	"sync"
+	"time"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+type GridFS struct {
+	Files  *Collection
+	Chunks *Collection
+}
+
+type gfsFileMode int
+
+const (
+	gfsClosed  gfsFileMode = 0
+	gfsReading gfsFileMode = 1
+	gfsWriting gfsFileMode = 2
+)
+
+type GridFile struct {
+	m    sync.Mutex
+	c    sync.Cond
+	gfs  *GridFS
+	mode gfsFileMode
+	err  error
+
+	chunk  int
+	offset int64
+
+	wpending int
+	wbuf     []byte
+	wsum     hash.Hash
+
+	rbuf   []byte
+	rcache *gfsCachedChunk
+
+	doc gfsFile
+}
+
+type gfsFile struct {
+	Id          interface{} "_id"
+	ChunkSize   int         "chunkSize"
+	UploadDate  time.Time   "uploadDate"
+	Length      int64       ",minsize"
+	MD5         string
+	Filename    string    ",omitempty"
+	ContentType string    "contentType,omitempty"
+	Metadata    *bson.Raw ",omitempty"
+}
+
+type gfsChunk struct {
+	Id      interface{} "_id"
+	FilesId interface{} "files_id"
+	N       int
+	Data    []byte
+}
+
+type gfsCachedChunk struct {
+	wait sync.Mutex
+	n    int
+	data []byte
+	err  error
+}
+
+func newGridFS(db *Database, prefix string) *GridFS {
+	return &GridFS{db.C(prefix + ".files"), db.C(prefix + ".chunks")}
+}
+
+func (gfs *GridFS) newFile() *GridFile {
+	file := &GridFile{gfs: gfs}
+	file.c.L = &file.m
+	//runtime.SetFinalizer(file, finalizeFile)
+	return file
+}
+
+func finalizeFile(file *GridFile) {
+	file.Close()
+}
+
+// Create creates a new file with the provided name in the GridFS.  If the file
+// name already exists, a new version will be inserted with an up-to-date
+// uploadDate that will cause it to be atomically visible to the Open and
+// OpenId methods.  If the file name is not important, an empty name may be
+// provided and the file Id used instead.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+//
+// A simple example inserting a new file:
+//
+//     func check(err error) {
+//         if err != nil {
+//             panic(err.String())
+//         }
+//     }
+//     file, err := db.GridFS("fs").Create("myfile.txt")
+//     check(err)
+//     n, err := file.Write([]byte("Hello world!"))
+//     check(err)
+//     err = file.Close()
+//     check(err)
+//     fmt.Printf("%d bytes written\n", n)
+//
+// The io.Writer interface is implemented by *GridFile and may be used to
+// help on the file creation.  For example:
+//
+//     file, err := db.GridFS("fs").Create("myfile.txt")
+//     check(err)
+//     messages, err := os.Open("/var/log/messages")
+//     check(err)
+//     defer messages.Close()
+//     err = io.Copy(file, messages)
+//     check(err)
+//     err = file.Close()
+//     check(err)
+//
+func (gfs *GridFS) Create(name string) (file *GridFile, err error) {
+	file = gfs.newFile()
+	file.mode = gfsWriting
+	file.wsum = md5.New()
+	file.doc = gfsFile{Id: bson.NewObjectId(), ChunkSize: 255 * 1024, Filename: name}
+	return
+}
+
+// OpenId returns the file with the provided id, for reading.
+// If the file isn't found, err will be set to mgo.ErrNotFound.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+//
+// The following example will print the first 8192 bytes from the file:
+//
+//     func check(err error) {
+//         if err != nil {
+//             panic(err.String())
+//         }
+//     }
+//     file, err := db.GridFS("fs").OpenId(objid)
+//     check(err)
+//     b := make([]byte, 8192)
+//     n, err := file.Read(b)
+//     check(err)
+//     fmt.Println(string(b))
+//     check(err)
+//     err = file.Close()
+//     check(err)
+//     fmt.Printf("%d bytes read\n", n)
+//
+// The io.Reader interface is implemented by *GridFile and may be used to
+// deal with it.  As an example, the following snippet will dump the whole
+// file into the standard output:
+//
+//     file, err := db.GridFS("fs").OpenId(objid)
+//     check(err)
+//     err = io.Copy(os.Stdout, file)
+//     check(err)
+//     err = file.Close()
+//     check(err)
+//
+func (gfs *GridFS) OpenId(id interface{}) (file *GridFile, err error) {
+	var doc gfsFile
+	err = gfs.Files.Find(bson.M{"_id": id}).One(&doc)
+	if err != nil {
+		return
+	}
+	file = gfs.newFile()
+	file.mode = gfsReading
+	file.doc = doc
+	return
+}
+
+// Open returns the most recently uploaded file with the provided
+// name, for reading. If the file isn't found, err will be set
+// to mgo.ErrNotFound.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+//
+// The following example will print the first 8192 bytes from the file:
+//
+//     file, err := db.GridFS("fs").Open("myfile.txt")
+//     check(err)
+//     b := make([]byte, 8192)
+//     n, err := file.Read(b)
+//     check(err)
+//     fmt.Println(string(b))
+//     check(err)
+//     err = file.Close()
+//     check(err)
+//     fmt.Printf("%d bytes read\n", n)
+//
+// The io.Reader interface is implemented by *GridFile and may be used to
+// deal with it.  As an example, the following snippet will dump the whole
+// file into the standard output:
+//
+//     file, err := db.GridFS("fs").Open("myfile.txt")
+//     check(err)
+//     err = io.Copy(os.Stdout, file)
+//     check(err)
+//     err = file.Close()
+//     check(err)
+//
+func (gfs *GridFS) Open(name string) (file *GridFile, err error) {
+	var doc gfsFile
+	err = gfs.Files.Find(bson.M{"filename": name}).Sort("-uploadDate").One(&doc)
+	if err != nil {
+		return
+	}
+	file = gfs.newFile()
+	file.mode = gfsReading
+	file.doc = doc
+	return
+}
+
+// OpenNext opens the next file from iter for reading, sets *file to it,
+// and returns true on the success case. If no more documents are available
+// on iter or an error occurred, *file is set to nil and the result is false.
+// Errors will be available via iter.Err().
+//
+// The iter parameter must be an iterator on the GridFS files collection.
+// Using the GridFS.Find method is an easy way to obtain such an iterator,
+// but any iterator on the collection will work.
+//
+// If the provided *file is non-nil, OpenNext will close it before attempting
+// to iterate to the next element. This means that in a loop one only
+// has to worry about closing files when breaking out of the loop early
+// (break, return, or panic).
+//
+// For example:
+//
+//     gfs := db.GridFS("fs")
+//     query := gfs.Find(nil).Sort("filename")
+//     iter := query.Iter()
+//     var f *mgo.GridFile
+//     for gfs.OpenNext(iter, &f) {
+//         fmt.Printf("Filename: %s\n", f.Name())
+//     }
+//     if iter.Close() != nil {
+//         panic(iter.Close())
+//     }
+//
+func (gfs *GridFS) OpenNext(iter *Iter, file **GridFile) bool {
+	if *file != nil {
+		// Ignoring the error here shouldn't be a big deal
+		// as we're reading the file and the loop iteration
+		// for this file is finished.
+		_ = (*file).Close()
+	}
+	var doc gfsFile
+	if !iter.Next(&doc) {
+		*file = nil
+		return false
+	}
+	f := gfs.newFile()
+	f.mode = gfsReading
+	f.doc = doc
+	*file = f
+	return true
+}
+
+// Find runs query on GridFS's files collection and returns
+// the resulting Query.
+//
+// This logic:
+//
+//     gfs := db.GridFS("fs")
+//     iter := gfs.Find(nil).Iter()
+//
+// Is equivalent to:
+//
+//     files := db.C("fs" + ".files")
+//     iter := files.Find(nil).Iter()
+//
+func (gfs *GridFS) Find(query interface{}) *Query {
+	return gfs.Files.Find(query)
+}
+
+// RemoveId deletes the file with the provided id from the GridFS.
+func (gfs *GridFS) RemoveId(id interface{}) error {
+	err := gfs.Files.Remove(bson.M{"_id": id})
+	if err != nil {
+		return err
+	}
+	_, err = gfs.Chunks.RemoveAll(bson.D{{"files_id", id}})
+	return err
+}
+
+type gfsDocId struct {
+	Id interface{} "_id"
+}
+
+// Remove deletes all files with the provided name from the GridFS.
+func (gfs *GridFS) Remove(name string) (err error) {
+	iter := gfs.Files.Find(bson.M{"filename": name}).Select(bson.M{"_id": 1}).Iter()
+	var doc gfsDocId
+	for iter.Next(&doc) {
+		if e := gfs.RemoveId(doc.Id); e != nil {
+			err = e
+		}
+	}
+	if err == nil {
+		err = iter.Close()
+	}
+	return err
+}
+
+func (file *GridFile) assertMode(mode gfsFileMode) {
+	switch file.mode {
+	case mode:
+		return
+	case gfsWriting:
+		panic("GridFile is open for writing")
+	case gfsReading:
+		panic("GridFile is open for reading")
+	case gfsClosed:
+		panic("GridFile is closed")
+	default:
+		panic("internal error: missing GridFile mode")
+	}
+}
+
+// SetChunkSize sets size of saved chunks.  Once the file is written to, it
+// will be split in blocks of that size and each block saved into an
+// independent chunk document.  The default chunk size is 256kb.
+//
+// It is a runtime error to call this function once the file has started
+// being written to.
+func (file *GridFile) SetChunkSize(bytes int) {
+	file.assertMode(gfsWriting)
+	debugf("GridFile %p: setting chunk size to %d", file, bytes)
+	file.m.Lock()
+	file.doc.ChunkSize = bytes
+	file.m.Unlock()
+}
+
+// Id returns the current file Id.
+func (file *GridFile) Id() interface{} {
+	return file.doc.Id
+}
+
+// SetId changes the current file Id.
+//
+// It is a runtime error to call this function once the file has started
+// being written to, or when the file is not open for writing.
+func (file *GridFile) SetId(id interface{}) {
+	file.assertMode(gfsWriting)
+	file.m.Lock()
+	file.doc.Id = id
+	file.m.Unlock()
+}
+
+// Name returns the optional file name.  An empty string will be returned
+// in case it is unset.
+func (file *GridFile) Name() string {
+	return file.doc.Filename
+}
+
+// SetName changes the optional file name.  An empty string may be used to
+// unset it.
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetName(name string) {
+	file.assertMode(gfsWriting)
+	file.m.Lock()
+	file.doc.Filename = name
+	file.m.Unlock()
+}
+
+// ContentType returns the optional file content type.  An empty string will be
+// returned in case it is unset.
+func (file *GridFile) ContentType() string {
+	return file.doc.ContentType
+}
+
+// ContentType changes the optional file content type.  An empty string may be
+// used to unset it.
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetContentType(ctype string) {
+	file.assertMode(gfsWriting)
+	file.m.Lock()
+	file.doc.ContentType = ctype
+	file.m.Unlock()
+}
+
+// GetMeta unmarshals the optional "metadata" field associated with the
+// file into the result parameter. The meaning of keys under that field
+// is user-defined. For example:
+//
+//     result := struct{ INode int }{}
+//     err = file.GetMeta(&result)
+//     if err != nil {
+//         panic(err.String())
+//     }
+//     fmt.Printf("inode: %d\n", result.INode)
+//
+func (file *GridFile) GetMeta(result interface{}) (err error) {
+	file.m.Lock()
+	if file.doc.Metadata != nil {
+		err = bson.Unmarshal(file.doc.Metadata.Data, result)
+	}
+	file.m.Unlock()
+	return
+}
+
+// SetMeta changes the optional "metadata" field associated with the
+// file. The meaning of keys under that field is user-defined.
+// For example:
+//
+//     file.SetMeta(bson.M{"inode": inode})
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetMeta(metadata interface{}) {
+	file.assertMode(gfsWriting)
+	data, err := bson.Marshal(metadata)
+	file.m.Lock()
+	if err != nil && file.err == nil {
+		file.err = err
+	} else {
+		file.doc.Metadata = &bson.Raw{Data: data}
+	}
+	file.m.Unlock()
+}
+
+// Size returns the file size in bytes.
+func (file *GridFile) Size() (bytes int64) {
+	file.m.Lock()
+	bytes = file.doc.Length
+	file.m.Unlock()
+	return
+}
+
+// MD5 returns the file MD5 as a hex-encoded string.
+func (file *GridFile) MD5() (md5 string) {
+	return file.doc.MD5
+}
+
+// UploadDate returns the file upload time.
+func (file *GridFile) UploadDate() time.Time {
+	return file.doc.UploadDate
+}
+
+// SetUploadDate changes the file upload time.
+//
+// It is a runtime error to call this function when the file is not open
+// for writing.
+func (file *GridFile) SetUploadDate(t time.Time) {
+	file.assertMode(gfsWriting)
+	file.m.Lock()
+	file.doc.UploadDate = t
+	file.m.Unlock()
+}
+
+// Close flushes any pending changes in case the file is being written
+// to, waits for any background operations to finish, and closes the file.
+//
+// It's important to Close files whether they are being written to
+// or read from, and to check the err result to ensure the operation
+// completed successfully.
+func (file *GridFile) Close() (err error) {
+	file.m.Lock()
+	defer file.m.Unlock()
+	if file.mode == gfsWriting {
+		if len(file.wbuf) > 0 && file.err == nil {
+			file.insertChunk(file.wbuf)
+			file.wbuf = file.wbuf[0:0]
+		}
+		file.completeWrite()
+	} else if file.mode == gfsReading && file.rcache != nil {
+		file.rcache.wait.Lock()
+		file.rcache = nil
+	}
+	file.mode = gfsClosed
+	debugf("GridFile %p: closed", file)
+	return file.err
+}
+
+func (file *GridFile) completeWrite() {
+	for file.wpending > 0 {
+		debugf("GridFile %p: waiting for %d pending chunks to complete file write", file, file.wpending)
+		file.c.Wait()
+	}
+	if file.err == nil {
+		hexsum := hex.EncodeToString(file.wsum.Sum(nil))
+		if file.doc.UploadDate.IsZero() {
+			file.doc.UploadDate = bson.Now()
+		}
+		file.doc.MD5 = hexsum
+		file.err = file.gfs.Files.Insert(file.doc)
+		file.gfs.Chunks.EnsureIndexKey("files_id", "n")
+	}
+	if file.err != nil {
+		file.gfs.Chunks.RemoveAll(bson.D{{"files_id", file.doc.Id}})
+	}
+}
+
+// Abort cancels an in-progress write, preventing the file from being
+// automically created and ensuring previously written chunks are
+// removed when the file is closed.
+//
+// It is a runtime error to call Abort when the file was not opened
+// for writing.
+func (file *GridFile) Abort() {
+	if file.mode != gfsWriting {
+		panic("file.Abort must be called on file opened for writing")
+	}
+	file.err = errors.New("write aborted")
+}
+
+// Write writes the provided data to the file and returns the
+// number of bytes written and an error in case something
+// wrong happened.
+//
+// The file will internally cache the data so that all but the last
+// chunk sent to the database have the size defined by SetChunkSize.
+// This also means that errors may be deferred until a future call
+// to Write or Close.
+//
+// The parameters and behavior of this function turn the file
+// into an io.Writer.
+func (file *GridFile) Write(data []byte) (n int, err error) {
+	file.assertMode(gfsWriting)
+	file.m.Lock()
+	debugf("GridFile %p: writing %d bytes", file, len(data))
+	defer file.m.Unlock()
+
+	if file.err != nil {
+		return 0, file.err
+	}
+
+	n = len(data)
+	file.doc.Length += int64(n)
+	chunkSize := file.doc.ChunkSize
+
+	if len(file.wbuf)+len(data) < chunkSize {
+		file.wbuf = append(file.wbuf, data...)
+		return
+	}
+
+	// First, flush file.wbuf complementing with data.
+	if len(file.wbuf) > 0 {
+		missing := chunkSize - len(file.wbuf)
+		if missing > len(data) {
+			missing = len(data)
+		}
+		file.wbuf = append(file.wbuf, data[:missing]...)
+		data = data[missing:]
+		file.insertChunk(file.wbuf)
+		file.wbuf = file.wbuf[0:0]
+	}
+
+	// Then, flush all chunks from data without copying.
+	for len(data) > chunkSize {
+		size := chunkSize
+		if size > len(data) {
+			size = len(data)
+		}
+		file.insertChunk(data[:size])
+		data = data[size:]
+	}
+
+	// And append the rest for a future call.
+	file.wbuf = append(file.wbuf, data...)
+
+	return n, file.err
+}
+
+func (file *GridFile) insertChunk(data []byte) {
+	n := file.chunk
+	file.chunk++
+	debugf("GridFile %p: adding to checksum: %q", file, string(data))
+	file.wsum.Write(data)
+
+	for file.doc.ChunkSize*file.wpending >= 1024*1024 {
+		// Hold on.. we got a MB pending.
+		file.c.Wait()
+		if file.err != nil {
+			return
+		}
+	}
+
+	file.wpending++
+
+	debugf("GridFile %p: inserting chunk %d with %d bytes", file, n, len(data))
+
+	// We may not own the memory of data, so rather than
+	// simply copying it, we'll marshal the document ahead of time.
+	data, err := bson.Marshal(gfsChunk{bson.NewObjectId(), file.doc.Id, n, data})
+	if err != nil {
+		file.err = err
+		return
+	}
+
+	go func() {
+		err := file.gfs.Chunks.Insert(bson.Raw{Data: data})
+		file.m.Lock()
+		file.wpending--
+		if err != nil && file.err == nil {
+			file.err = err
+		}
+		file.c.Broadcast()
+		file.m.Unlock()
+	}()
+}
+
+// Seek sets the offset for the next Read or Write on file to
+// offset, interpreted according to whence: 0 means relative to
+// the origin of the file, 1 means relative to the current offset,
+// and 2 means relative to the end. It returns the new offset and
+// an error, if any.
+func (file *GridFile) Seek(offset int64, whence int) (pos int64, err error) {
+	file.m.Lock()
+	debugf("GridFile %p: seeking for %s (whence=%d)", file, offset, whence)
+	defer file.m.Unlock()
+	switch whence {
+	case os.SEEK_SET:
+	case os.SEEK_CUR:
+		offset += file.offset
+	case os.SEEK_END:
+		offset += file.doc.Length
+	default:
+		panic("unsupported whence value")
+	}
+	if offset > file.doc.Length {
+		return file.offset, errors.New("seek past end of file")
+	}
+	if offset == file.doc.Length {
+		// If we're seeking to the end of the file,
+		// no need to read anything. This enables
+		// a client to find the size of the file using only the
+		// io.ReadSeeker interface with low overhead.
+		file.offset = offset
+		return file.offset, nil
+	}
+	chunk := int(offset / int64(file.doc.ChunkSize))
+	if chunk+1 == file.chunk && offset >= file.offset {
+		file.rbuf = file.rbuf[int(offset-file.offset):]
+		file.offset = offset
+		return file.offset, nil
+	}
+	file.offset = offset
+	file.chunk = chunk
+	file.rbuf = nil
+	file.rbuf, err = file.getChunk()
+	if err == nil {
+		file.rbuf = file.rbuf[int(file.offset-int64(chunk)*int64(file.doc.ChunkSize)):]
+	}
+	return file.offset, err
+}
+
+// Read reads into b the next available data from the file and
+// returns the number of bytes written and an error in case
+// something wrong happened.  At the end of the file, n will
+// be zero and err will be set to os.EOF.
+//
+// The parameters and behavior of this function turn the file
+// into an io.Reader.
+func (file *GridFile) Read(b []byte) (n int, err error) {
+	file.assertMode(gfsReading)
+	file.m.Lock()
+	debugf("GridFile %p: reading at offset %d into buffer of length %d", file, file.offset, len(b))
+	defer file.m.Unlock()
+	if file.offset == file.doc.Length {
+		return 0, io.EOF
+	}
+	for err == nil {
+		i := copy(b, file.rbuf)
+		n += i
+		file.offset += int64(i)
+		file.rbuf = file.rbuf[i:]
+		if i == len(b) || file.offset == file.doc.Length {
+			break
+		}
+		b = b[i:]
+		file.rbuf, err = file.getChunk()
+	}
+	return n, err
+}
+
+func (file *GridFile) getChunk() (data []byte, err error) {
+	cache := file.rcache
+	file.rcache = nil
+	if cache != nil && cache.n == file.chunk {
+		debugf("GridFile %p: Getting chunk %d from cache", file, file.chunk)
+		cache.wait.Lock()
+		data, err = cache.data, cache.err
+	} else {
+		debugf("GridFile %p: Fetching chunk %d", file, file.chunk)
+		var doc gfsChunk
+		err = file.gfs.Chunks.Find(bson.D{{"files_id", file.doc.Id}, {"n", file.chunk}}).One(&doc)
+		data = doc.Data
+	}
+	file.chunk++
+	if int64(file.chunk)*int64(file.doc.ChunkSize) < file.doc.Length {
+		// Read the next one in background.
+		cache = &gfsCachedChunk{n: file.chunk}
+		cache.wait.Lock()
+		debugf("GridFile %p: Scheduling chunk %d for background caching", file, file.chunk)
+		// Clone the session to avoid having it closed in between.
+		chunks := file.gfs.Chunks
+		session := chunks.Database.Session.Clone()
+		go func(id interface{}, n int) {
+			defer session.Close()
+			chunks = chunks.With(session)
+			var doc gfsChunk
+			cache.err = chunks.Find(bson.D{{"files_id", id}, {"n", n}}).One(&doc)
+			cache.data = doc.Data
+			cache.wait.Unlock()
+		}(file.doc.Id, file.chunk)
+		file.rcache = cache
+	}
+	debugf("Returning err: %#v", err)
+	return
+}
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sasl.c b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl.c
new file mode 100644
index 00000000..8be0bc45
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl.c
@@ -0,0 +1,77 @@
+// +build !windows
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sasl/sasl.h>
+
+static int mgo_sasl_simple(void *context, int id, const char **result, unsigned int *len)
+{
+	if (!result) {
+		return SASL_BADPARAM;
+	}
+	switch (id) {
+	case SASL_CB_USER:
+		*result = (char *)context;
+		break;
+	case SASL_CB_AUTHNAME:
+		*result = (char *)context;
+		break;
+	case SASL_CB_LANGUAGE:
+		*result = NULL;
+		break;
+	default:
+		return SASL_BADPARAM;
+	}
+	if (len) {
+		*len = *result ? strlen(*result) : 0;
+	}
+	return SASL_OK;
+}
+
+typedef int (*callback)(void);
+
+static int mgo_sasl_secret(sasl_conn_t *conn, void *context, int id, sasl_secret_t **result)
+{
+	if (!conn || !result || id != SASL_CB_PASS) {
+		return SASL_BADPARAM;
+	}
+	*result = (sasl_secret_t *)context;
+	return SASL_OK;
+}
+
+sasl_callback_t *mgo_sasl_callbacks(const char *username, const char *password)
+{
+	sasl_callback_t *cb = malloc(4 * sizeof(sasl_callback_t));
+	int n = 0;
+
+	size_t len = strlen(password);
+	sasl_secret_t *secret = (sasl_secret_t*)malloc(sizeof(sasl_secret_t) + len);
+	if (!secret) {
+		free(cb);
+		return NULL;
+	}
+	strcpy((char *)secret->data, password);
+	secret->len = len;
+
+	cb[n].id = SASL_CB_PASS;
+	cb[n].proc = (callback)&mgo_sasl_secret;
+	cb[n].context = secret;
+	n++;
+
+	cb[n].id = SASL_CB_USER;
+	cb[n].proc = (callback)&mgo_sasl_simple;
+	cb[n].context = (char*)username;
+	n++;
+
+	cb[n].id = SASL_CB_AUTHNAME;
+	cb[n].proc = (callback)&mgo_sasl_simple;
+	cb[n].context = (char*)username;
+	n++;
+
+	cb[n].id = SASL_CB_LIST_END;
+	cb[n].proc = NULL;
+	cb[n].context = NULL;
+
+	return cb;
+}
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sasl.go b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl.go
new file mode 100644
index 00000000..8375dddf
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl.go
@@ -0,0 +1,138 @@
+// Package sasl is an implementation detail of the mgo package.
+//
+// This package is not meant to be used by itself.
+//
+
+// +build !windows
+
+package sasl
+
+// #cgo LDFLAGS: -lsasl2
+//
+// struct sasl_conn {};
+//
+// #include <stdlib.h>
+// #include <sasl/sasl.h>
+//
+// sasl_callback_t *mgo_sasl_callbacks(const char *username, const char *password);
+//
+import "C"
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"unsafe"
+)
+
+type saslStepper interface {
+	Step(serverData []byte) (clientData []byte, done bool, err error)
+	Close()
+}
+
+type saslSession struct {
+	conn *C.sasl_conn_t
+	step int
+	mech string
+
+	cstrings  []*C.char
+	callbacks *C.sasl_callback_t
+}
+
+var initError error
+var initOnce sync.Once
+
+func initSASL() {
+	rc := C.sasl_client_init(nil)
+	if rc != C.SASL_OK {
+		initError = saslError(rc, nil, "cannot initialize SASL library")
+	}
+}
+
+func New(username, password, mechanism, service, host string) (saslStepper, error) {
+	initOnce.Do(initSASL)
+	if initError != nil {
+		return nil, initError
+	}
+
+	ss := &saslSession{mech: mechanism}
+	if service == "" {
+		service = "mongodb"
+	}
+	if i := strings.Index(host, ":"); i >= 0 {
+		host = host[:i]
+	}
+	ss.callbacks = C.mgo_sasl_callbacks(ss.cstr(username), ss.cstr(password))
+	rc := C.sasl_client_new(ss.cstr(service), ss.cstr(host), nil, nil, ss.callbacks, 0, &ss.conn)
+	if rc != C.SASL_OK {
+		ss.Close()
+		return nil, saslError(rc, nil, "cannot create new SASL client")
+	}
+	return ss, nil
+}
+
+func (ss *saslSession) cstr(s string) *C.char {
+	cstr := C.CString(s)
+	ss.cstrings = append(ss.cstrings, cstr)
+	return cstr
+}
+
+func (ss *saslSession) Close() {
+	for _, cstr := range ss.cstrings {
+		C.free(unsafe.Pointer(cstr))
+	}
+	ss.cstrings = nil
+
+	if ss.callbacks != nil {
+		C.free(unsafe.Pointer(ss.callbacks))
+	}
+
+	// The documentation of SASL dispose makes it clear that this should only
+	// be done when the connection is done, not when the authentication phase
+	// is done, because an encryption layer may have been negotiated.
+	// Even then, we'll do this for now, because it's simpler and prevents
+	// keeping track of this state for every socket. If it breaks, we'll fix it.
+	C.sasl_dispose(&ss.conn)
+}
+
+func (ss *saslSession) Step(serverData []byte) (clientData []byte, done bool, err error) {
+	ss.step++
+	if ss.step > 10 {
+		return nil, false, fmt.Errorf("too many SASL steps without authentication")
+	}
+	var cclientData *C.char
+	var cclientDataLen C.uint
+	var rc C.int
+	if ss.step == 1 {
+		var mechanism *C.char // ignored - must match cred
+		rc = C.sasl_client_start(ss.conn, ss.cstr(ss.mech), nil, &cclientData, &cclientDataLen, &mechanism)
+	} else {
+		var cserverData *C.char
+		var cserverDataLen C.uint
+		if len(serverData) > 0 {
+			cserverData = (*C.char)(unsafe.Pointer(&serverData[0]))
+			cserverDataLen = C.uint(len(serverData))
+		}
+		rc = C.sasl_client_step(ss.conn, cserverData, cserverDataLen, nil, &cclientData, &cclientDataLen)
+	}
+	if cclientData != nil && cclientDataLen > 0 {
+		clientData = C.GoBytes(unsafe.Pointer(cclientData), C.int(cclientDataLen))
+	}
+	if rc == C.SASL_OK {
+		return clientData, true, nil
+	}
+	if rc == C.SASL_CONTINUE {
+		return clientData, false, nil
+	}
+	return nil, false, saslError(rc, ss.conn, "cannot establish SASL session")
+}
+
+func saslError(rc C.int, conn *C.sasl_conn_t, msg string) error {
+	var detail string
+	if conn == nil {
+		detail = C.GoString(C.sasl_errstring(rc, nil, nil))
+	} else {
+		detail = C.GoString(C.sasl_errdetail(conn))
+	}
+	return fmt.Errorf(msg + ": " + detail)
+}
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.c b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.c
new file mode 100644
index 00000000..dd6a88ab
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.c
@@ -0,0 +1,118 @@
+#include "sasl_windows.h"
+
+static const LPSTR SSPI_PACKAGE_NAME = "kerberos";
+
+SECURITY_STATUS SEC_ENTRY sspi_acquire_credentials_handle(CredHandle *cred_handle, char *username, char *password, char *domain)
+{
+	SEC_WINNT_AUTH_IDENTITY auth_identity;
+	SECURITY_INTEGER ignored;
+
+	auth_identity.Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;
+	auth_identity.User = (LPSTR) username;
+	auth_identity.UserLength = strlen(username);
+	auth_identity.Password = (LPSTR) password;
+	auth_identity.PasswordLength = strlen(password);
+	auth_identity.Domain = (LPSTR) domain;
+	auth_identity.DomainLength = strlen(domain);
+	return call_sspi_acquire_credentials_handle(NULL, SSPI_PACKAGE_NAME, SECPKG_CRED_OUTBOUND, NULL, &auth_identity, NULL, NULL, cred_handle, &ignored);
+}
+
+int sspi_step(CredHandle *cred_handle, int has_context, CtxtHandle *context, PVOID *buffer, ULONG *buffer_length, char *target)
+{
+	SecBufferDesc inbuf;
+	SecBuffer in_bufs[1];
+	SecBufferDesc outbuf;
+	SecBuffer out_bufs[1];
+
+	if (has_context > 0) {
+		// If we already have a context, we now have data to send.
+		// Put this data in an inbuf.
+		inbuf.ulVersion = SECBUFFER_VERSION;
+		inbuf.cBuffers = 1;
+		inbuf.pBuffers = in_bufs;
+		in_bufs[0].pvBuffer = *buffer;
+		in_bufs[0].cbBuffer = *buffer_length;
+		in_bufs[0].BufferType = SECBUFFER_TOKEN;
+	}
+
+	outbuf.ulVersion = SECBUFFER_VERSION;
+	outbuf.cBuffers = 1;
+	outbuf.pBuffers = out_bufs;
+	out_bufs[0].pvBuffer = NULL;
+	out_bufs[0].cbBuffer = 0;
+	out_bufs[0].BufferType = SECBUFFER_TOKEN;
+
+	ULONG context_attr = 0;
+
+	int ret = call_sspi_initialize_security_context(cred_handle,
+	          has_context > 0 ? context : NULL,
+	          (LPSTR) target,
+	          ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_MUTUAL_AUTH,
+	          0,
+	          SECURITY_NETWORK_DREP,
+	          has_context > 0 ? &inbuf : NULL,
+	          0,
+	          context,
+	          &outbuf,
+	          &context_attr,
+	          NULL);
+
+	*buffer = malloc(out_bufs[0].cbBuffer);
+	*buffer_length = out_bufs[0].cbBuffer;
+	memcpy(*buffer, out_bufs[0].pvBuffer, *buffer_length);
+
+	return ret;
+}
+
+int sspi_send_client_authz_id(CtxtHandle *context, PVOID *buffer, ULONG *buffer_length, char *user_plus_realm)
+{
+	SecPkgContext_Sizes sizes;
+	SECURITY_STATUS status = call_sspi_query_context_attributes(context, SECPKG_ATTR_SIZES, &sizes);
+
+	if (status != SEC_E_OK) {
+		return status;
+	}
+
+	size_t user_plus_realm_length = strlen(user_plus_realm);
+	int msgSize = 4 + user_plus_realm_length;
+	char *msg = malloc((sizes.cbSecurityTrailer + msgSize + sizes.cbBlockSize) * sizeof(char));
+	msg[sizes.cbSecurityTrailer + 0] = 1;
+	msg[sizes.cbSecurityTrailer + 1] = 0;
+	msg[sizes.cbSecurityTrailer + 2] = 0;
+	msg[sizes.cbSecurityTrailer + 3] = 0;
+	memcpy(&msg[sizes.cbSecurityTrailer + 4], user_plus_realm, user_plus_realm_length);
+
+	SecBuffer wrapBufs[3];
+	SecBufferDesc wrapBufDesc;
+	wrapBufDesc.cBuffers = 3;
+	wrapBufDesc.pBuffers = wrapBufs;
+	wrapBufDesc.ulVersion = SECBUFFER_VERSION;
+
+	wrapBufs[0].cbBuffer = sizes.cbSecurityTrailer;
+	wrapBufs[0].BufferType = SECBUFFER_TOKEN;
+	wrapBufs[0].pvBuffer = msg;
+
+	wrapBufs[1].cbBuffer = msgSize;
+	wrapBufs[1].BufferType = SECBUFFER_DATA;
+	wrapBufs[1].pvBuffer = msg + sizes.cbSecurityTrailer;
+
+	wrapBufs[2].cbBuffer = sizes.cbBlockSize;
+	wrapBufs[2].BufferType = SECBUFFER_PADDING;
+	wrapBufs[2].pvBuffer = msg + sizes.cbSecurityTrailer + msgSize;
+
+	status = call_sspi_encrypt_message(context, SECQOP_WRAP_NO_ENCRYPT, &wrapBufDesc, 0);
+	if (status != SEC_E_OK) {
+		free(msg);
+		return status;
+	}
+
+	*buffer_length = wrapBufs[0].cbBuffer + wrapBufs[1].cbBuffer + wrapBufs[2].cbBuffer;
+	*buffer = malloc(*buffer_length);
+
+	memcpy(*buffer, wrapBufs[0].pvBuffer, wrapBufs[0].cbBuffer);
+	memcpy(*buffer + wrapBufs[0].cbBuffer, wrapBufs[1].pvBuffer, wrapBufs[1].cbBuffer);
+	memcpy(*buffer + wrapBufs[0].cbBuffer + wrapBufs[1].cbBuffer, wrapBufs[2].pvBuffer, wrapBufs[2].cbBuffer);
+
+	free(msg);
+	return SEC_E_OK;
+}
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.go b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.go
new file mode 100644
index 00000000..3302cfe0
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.go
@@ -0,0 +1,140 @@
+package sasl
+
+// #include "sasl_windows.h"
+import "C"
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"unsafe"
+)
+
+type saslStepper interface {
+	Step(serverData []byte) (clientData []byte, done bool, err error)
+	Close()
+}
+
+type saslSession struct {
+	// Credentials
+	mech          string
+	service       string
+	host          string
+	userPlusRealm string
+	target        string
+	domain        string
+
+	// Internal state
+	authComplete bool
+	errored      bool
+	step         int
+
+	// C internal state
+	credHandle C.CredHandle
+	context    C.CtxtHandle
+	hasContext C.int
+
+	// Keep track of pointers we need to explicitly free
+	stringsToFree []*C.char
+}
+
+var initError error
+var initOnce sync.Once
+
+func initSSPI() {
+	rc := C.load_secur32_dll()
+	if rc != 0 {
+		initError = fmt.Errorf("Error loading libraries: %v", rc)
+	}
+}
+
+func New(username, password, mechanism, service, host string) (saslStepper, error) {
+	initOnce.Do(initSSPI)
+	ss := &saslSession{mech: mechanism, hasContext: 0, userPlusRealm: username}
+	if service == "" {
+		service = "mongodb"
+	}
+	if i := strings.Index(host, ":"); i >= 0 {
+		host = host[:i]
+	}
+	ss.service = service
+	ss.host = host
+
+	usernameComponents := strings.Split(username, "@")
+	if len(usernameComponents) < 2 {
+		return nil, fmt.Errorf("Username '%v' doesn't contain a realm!", username)
+	}
+	user := usernameComponents[0]
+	ss.domain = usernameComponents[1]
+	ss.target = fmt.Sprintf("%s/%s", ss.service, ss.host)
+
+	var status C.SECURITY_STATUS
+	// Step 0: call AcquireCredentialsHandle to get a nice SSPI CredHandle
+	if len(password) > 0 {
+		status = C.sspi_acquire_credentials_handle(&ss.credHandle, ss.cstr(user), ss.cstr(password), ss.cstr(ss.domain))
+	} else {
+		status = C.sspi_acquire_credentials_handle(&ss.credHandle, ss.cstr(user), nil, ss.cstr(ss.domain))
+	}
+	if status != C.SEC_E_OK {
+		ss.errored = true
+		return nil, fmt.Errorf("Couldn't create new SSPI client, error code %v", status)
+	}
+	return ss, nil
+}
+
+func (ss *saslSession) cstr(s string) *C.char {
+	cstr := C.CString(s)
+	ss.stringsToFree = append(ss.stringsToFree, cstr)
+	return cstr
+}
+
+func (ss *saslSession) Close() {
+	for _, cstr := range ss.stringsToFree {
+		C.free(unsafe.Pointer(cstr))
+	}
+}
+
+func (ss *saslSession) Step(serverData []byte) (clientData []byte, done bool, err error) {
+	ss.step++
+	if ss.step > 10 {
+		return nil, false, fmt.Errorf("too many SSPI steps without authentication")
+	}
+	var buffer C.PVOID
+	var bufferLength C.ULONG
+	if len(serverData) > 0 {
+		buffer = (C.PVOID)(unsafe.Pointer(&serverData[0]))
+		bufferLength = C.ULONG(len(serverData))
+	}
+	var status C.int
+	if ss.authComplete {
+		// Step 3: last bit of magic to use the correct server credentials
+		status = C.sspi_send_client_authz_id(&ss.context, &buffer, &bufferLength, ss.cstr(ss.userPlusRealm))
+	} else {
+		// Step 1 + Step 2: set up security context with the server and TGT
+		status = C.sspi_step(&ss.credHandle, ss.hasContext, &ss.context, &buffer, &bufferLength, ss.cstr(ss.target))
+	}
+	if buffer != C.PVOID(nil) {
+		defer C.free(unsafe.Pointer(buffer))
+	}
+	if status != C.SEC_E_OK && status != C.SEC_I_CONTINUE_NEEDED {
+		ss.errored = true
+		return nil, false, ss.handleSSPIErrorCode(status)
+	}
+
+	clientData = C.GoBytes(unsafe.Pointer(buffer), C.int(bufferLength))
+	if status == C.SEC_E_OK {
+		ss.authComplete = true
+		return clientData, true, nil
+	} else {
+		ss.hasContext = 1
+		return clientData, false, nil
+	}
+}
+
+func (ss *saslSession) handleSSPIErrorCode(code C.int) error {
+	switch {
+	case code == C.SEC_E_TARGET_UNKNOWN:
+		return fmt.Errorf("Target %v@%v not found", ss.target, ss.domain)
+	}
+	return fmt.Errorf("Unknown error doing step %v, error code %v", ss.step, code)
+}
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.h b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.h
new file mode 100644
index 00000000..94321b20
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sasl_windows.h
@@ -0,0 +1,7 @@
+#include <windows.h>
+
+#include "sspi_windows.h"
+
+SECURITY_STATUS SEC_ENTRY sspi_acquire_credentials_handle(CredHandle* cred_handle, char* username, char* password, char* domain);
+int sspi_step(CredHandle* cred_handle, int has_context, CtxtHandle* context, PVOID* buffer, ULONG* buffer_length, char* target);
+int sspi_send_client_authz_id(CtxtHandle* context, PVOID* buffer, ULONG* buffer_length, char* user_plus_realm);
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sspi_windows.c b/vendor/gopkg.in/mgo.v2/internal/sasl/sspi_windows.c
new file mode 100644
index 00000000..63f9a6f8
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sspi_windows.c
@@ -0,0 +1,96 @@
+// Code adapted from the NodeJS kerberos library:
+// 
+//   https://github.com/christkv/kerberos/tree/master/lib/win32/kerberos_sspi.c
+//
+// Under the terms of the Apache License, Version 2.0:
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+#include <stdlib.h>
+
+#include "sspi_windows.h"
+
+static HINSTANCE sspi_secur32_dll = NULL;
+
+int load_secur32_dll()
+{
+	sspi_secur32_dll = LoadLibrary("secur32.dll");
+	if (sspi_secur32_dll == NULL) {
+		return GetLastError();
+	}
+	return 0;
+}
+
+SECURITY_STATUS SEC_ENTRY call_sspi_encrypt_message(PCtxtHandle phContext, unsigned long fQOP, PSecBufferDesc pMessage, unsigned long MessageSeqNo)
+{
+	if (sspi_secur32_dll == NULL) {
+		return -1;
+	}
+	encryptMessage_fn pfn_encryptMessage = (encryptMessage_fn) GetProcAddress(sspi_secur32_dll, "EncryptMessage");
+	if (!pfn_encryptMessage) {
+		return -2;
+	}
+	return (*pfn_encryptMessage)(phContext, fQOP, pMessage, MessageSeqNo);
+}
+
+SECURITY_STATUS SEC_ENTRY call_sspi_acquire_credentials_handle(
+	LPSTR pszPrincipal, LPSTR pszPackage, unsigned long fCredentialUse,
+        void *pvLogonId, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
+        PCredHandle phCredential, PTimeStamp ptsExpiry)
+{
+	if (sspi_secur32_dll == NULL) {
+		return -1;
+	}
+	acquireCredentialsHandle_fn pfn_acquireCredentialsHandle;
+#ifdef _UNICODE
+	pfn_acquireCredentialsHandle = (acquireCredentialsHandle_fn) GetProcAddress(sspi_secur32_dll, "AcquireCredentialsHandleW");
+#else
+	pfn_acquireCredentialsHandle = (acquireCredentialsHandle_fn) GetProcAddress(sspi_secur32_dll, "AcquireCredentialsHandleA");
+#endif
+	if (!pfn_acquireCredentialsHandle) {
+		return -2;
+	}
+	return (*pfn_acquireCredentialsHandle)(
+		pszPrincipal, pszPackage, fCredentialUse, pvLogonId, pAuthData,
+	        pGetKeyFn, pvGetKeyArgument, phCredential, ptsExpiry);
+}
+
+SECURITY_STATUS SEC_ENTRY call_sspi_initialize_security_context(
+	PCredHandle phCredential, PCtxtHandle phContext, LPSTR pszTargetName,
+	unsigned long fContextReq, unsigned long Reserved1, unsigned long TargetDataRep,
+	PSecBufferDesc pInput, unsigned long Reserved2, PCtxtHandle phNewContext,
+	PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry)
+{
+	if (sspi_secur32_dll == NULL) {
+		return -1;
+	}
+	initializeSecurityContext_fn pfn_initializeSecurityContext;
+#ifdef _UNICODE
+	pfn_initializeSecurityContext = (initializeSecurityContext_fn) GetProcAddress(sspi_secur32_dll, "InitializeSecurityContextW");
+#else
+	pfn_initializeSecurityContext = (initializeSecurityContext_fn) GetProcAddress(sspi_secur32_dll, "InitializeSecurityContextA");
+#endif
+	if (!pfn_initializeSecurityContext) {
+		return -2;
+	}
+	return (*pfn_initializeSecurityContext)(
+		phCredential, phContext, pszTargetName, fContextReq, Reserved1, TargetDataRep,
+		pInput, Reserved2, phNewContext, pOutput, pfContextAttr, ptsExpiry);
+}
+
+SECURITY_STATUS SEC_ENTRY call_sspi_query_context_attributes(PCtxtHandle phContext, unsigned long ulAttribute, void *pBuffer)
+{
+	if (sspi_secur32_dll == NULL) {
+		return -1;
+	}
+	queryContextAttributes_fn pfn_queryContextAttributes;
+#ifdef _UNICODE
+	pfn_queryContextAttributes = (queryContextAttributes_fn) GetProcAddress(sspi_secur32_dll, "QueryContextAttributesW");
+#else
+	pfn_queryContextAttributes = (queryContextAttributes_fn) GetProcAddress(sspi_secur32_dll, "QueryContextAttributesA");
+#endif
+	if (!pfn_queryContextAttributes) {
+		return -2;
+	}
+	return (*pfn_queryContextAttributes)(phContext, ulAttribute, pBuffer);
+}
diff --git a/vendor/gopkg.in/mgo.v2/internal/sasl/sspi_windows.h b/vendor/gopkg.in/mgo.v2/internal/sasl/sspi_windows.h
new file mode 100644
index 00000000..d2832703
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/sasl/sspi_windows.h
@@ -0,0 +1,70 @@
+// Code adapted from the NodeJS kerberos library:
+// 
+//   https://github.com/christkv/kerberos/tree/master/lib/win32/kerberos_sspi.h
+//
+// Under the terms of the Apache License, Version 2.0:
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+#ifndef SSPI_WINDOWS_H
+#define SSPI_WINDOWS_H
+
+#define SECURITY_WIN32 1
+
+#include <windows.h>
+#include <sspi.h>
+
+int load_secur32_dll();
+
+SECURITY_STATUS SEC_ENTRY call_sspi_encrypt_message(PCtxtHandle phContext, unsigned long fQOP, PSecBufferDesc pMessage, unsigned long MessageSeqNo);
+
+typedef DWORD (WINAPI *encryptMessage_fn)(PCtxtHandle phContext, ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo);
+
+SECURITY_STATUS SEC_ENTRY call_sspi_acquire_credentials_handle(
+    LPSTR pszPrincipal,             // Name of principal
+    LPSTR pszPackage,               // Name of package
+    unsigned long fCredentialUse,   // Flags indicating use
+    void *pvLogonId,                // Pointer to logon ID
+    void *pAuthData,                // Package specific data
+    SEC_GET_KEY_FN pGetKeyFn,       // Pointer to GetKey() func
+    void *pvGetKeyArgument,         // Value to pass to GetKey()
+    PCredHandle phCredential,       // (out) Cred Handle
+    PTimeStamp ptsExpiry            // (out) Lifetime (optional)
+);
+
+typedef DWORD (WINAPI *acquireCredentialsHandle_fn)(
+    LPSTR pszPrincipal, LPSTR pszPackage, unsigned long fCredentialUse,
+    void *pvLogonId, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
+    PCredHandle phCredential, PTimeStamp ptsExpiry
+);
+
+SECURITY_STATUS SEC_ENTRY call_sspi_initialize_security_context(
+    PCredHandle phCredential,       // Cred to base context
+    PCtxtHandle phContext,          // Existing context (OPT)
+    LPSTR pszTargetName,            // Name of target
+    unsigned long fContextReq,      // Context Requirements
+    unsigned long Reserved1,        // Reserved, MBZ
+    unsigned long TargetDataRep,    // Data rep of target
+    PSecBufferDesc pInput,          // Input Buffers
+    unsigned long Reserved2,        // Reserved, MBZ
+    PCtxtHandle phNewContext,       // (out) New Context handle
+    PSecBufferDesc pOutput,         // (inout) Output Buffers
+    unsigned long *pfContextAttr,   // (out) Context attrs
+    PTimeStamp ptsExpiry            // (out) Life span (OPT)
+);
+
+typedef DWORD (WINAPI *initializeSecurityContext_fn)(
+    PCredHandle phCredential, PCtxtHandle phContext, LPSTR pszTargetName, unsigned long fContextReq,
+    unsigned long Reserved1, unsigned long TargetDataRep, PSecBufferDesc pInput, unsigned long Reserved2,
+    PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry);
+
+SECURITY_STATUS SEC_ENTRY call_sspi_query_context_attributes(
+    PCtxtHandle phContext,          // Context to query
+    unsigned long ulAttribute,      // Attribute to query
+    void *pBuffer                   // Buffer for attributes
+);
+
+typedef DWORD (WINAPI *queryContextAttributes_fn)(
+    PCtxtHandle phContext, unsigned long ulAttribute, void *pBuffer);
+
+#endif // SSPI_WINDOWS_H
diff --git a/vendor/gopkg.in/mgo.v2/internal/scram/scram.go b/vendor/gopkg.in/mgo.v2/internal/scram/scram.go
new file mode 100644
index 00000000..80cda913
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/internal/scram/scram.go
@@ -0,0 +1,266 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2014 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+// Pacakage scram implements a SCRAM-{SHA-1,etc} client per RFC5802.
+//
+// http://tools.ietf.org/html/rfc5802
+//
+package scram
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"hash"
+	"strconv"
+	"strings"
+)
+
+// Client implements a SCRAM-* client (SCRAM-SHA-1, SCRAM-SHA-256, etc).
+//
+// A Client may be used within a SASL conversation with logic resembling:
+//
+//    var in []byte
+//    var client = scram.NewClient(sha1.New, user, pass)
+//    for client.Step(in) {
+//            out := client.Out()
+//            // send out to server
+//            in := serverOut
+//    }
+//    if client.Err() != nil {
+//            // auth failed
+//    }
+//
+type Client struct {
+	newHash func() hash.Hash
+
+	user string
+	pass string
+	step int
+	out  bytes.Buffer
+	err  error
+
+	clientNonce []byte
+	serverNonce []byte
+	saltedPass  []byte
+	authMsg     bytes.Buffer
+}
+
+// NewClient returns a new SCRAM-* client with the provided hash algorithm.
+//
+// For SCRAM-SHA-1, for example, use:
+//
+//    client := scram.NewClient(sha1.New, user, pass)
+//
+func NewClient(newHash func() hash.Hash, user, pass string) *Client {
+	c := &Client{
+		newHash: newHash,
+		user:    user,
+		pass:    pass,
+	}
+	c.out.Grow(256)
+	c.authMsg.Grow(256)
+	return c
+}
+
+// Out returns the data to be sent to the server in the current step.
+func (c *Client) Out() []byte {
+	if c.out.Len() == 0 {
+		return nil
+	}
+	return c.out.Bytes()
+}
+
+// Err returns the error that ocurred, or nil if there were no errors.
+func (c *Client) Err() error {
+	return c.err
+}
+
+// SetNonce sets the client nonce to the provided value.
+// If not set, the nonce is generated automatically out of crypto/rand on the first step.
+func (c *Client) SetNonce(nonce []byte) {
+	c.clientNonce = nonce
+}
+
+var escaper = strings.NewReplacer("=", "=3D", ",", "=2C")
+
+// Step processes the incoming data from the server and makes the
+// next round of data for the server available via Client.Out.
+// Step returns false if there are no errors and more data is
+// still expected.
+func (c *Client) Step(in []byte) bool {
+	c.out.Reset()
+	if c.step > 2 || c.err != nil {
+		return false
+	}
+	c.step++
+	switch c.step {
+	case 1:
+		c.err = c.step1(in)
+	case 2:
+		c.err = c.step2(in)
+	case 3:
+		c.err = c.step3(in)
+	}
+	return c.step > 2 || c.err != nil
+}
+
+func (c *Client) step1(in []byte) error {
+	if len(c.clientNonce) == 0 {
+		const nonceLen = 6
+		buf := make([]byte, nonceLen + b64.EncodedLen(nonceLen))
+		if _, err := rand.Read(buf[:nonceLen]); err != nil {
+			return fmt.Errorf("cannot read random SCRAM-SHA-1 nonce from operating system: %v", err)
+		}
+		c.clientNonce = buf[nonceLen:]
+		b64.Encode(c.clientNonce, buf[:nonceLen])
+	}
+	c.authMsg.WriteString("n=")
+	escaper.WriteString(&c.authMsg, c.user)
+	c.authMsg.WriteString(",r=")
+	c.authMsg.Write(c.clientNonce)
+
+	c.out.WriteString("n,,")
+	c.out.Write(c.authMsg.Bytes())
+	return nil
+}
+
+var b64 = base64.StdEncoding
+
+func (c *Client) step2(in []byte) error {
+	c.authMsg.WriteByte(',')
+	c.authMsg.Write(in)
+
+	fields := bytes.Split(in, []byte(","))
+	if len(fields) != 3 {
+		return fmt.Errorf("expected 3 fields in first SCRAM-SHA-1 server message, got %d: %q", len(fields), in)
+	}
+	if !bytes.HasPrefix(fields[0], []byte("r=")) || len(fields[0]) < 2 {
+		return fmt.Errorf("server sent an invalid SCRAM-SHA-1 nonce: %q", fields[0])
+	}
+	if !bytes.HasPrefix(fields[1], []byte("s=")) || len(fields[1]) < 6 {
+		return fmt.Errorf("server sent an invalid SCRAM-SHA-1 salt: %q", fields[1])
+	}
+	if !bytes.HasPrefix(fields[2], []byte("i=")) || len(fields[2]) < 6 {
+		return fmt.Errorf("server sent an invalid SCRAM-SHA-1 iteration count: %q", fields[2])
+	}
+
+	c.serverNonce = fields[0][2:]
+	if !bytes.HasPrefix(c.serverNonce, c.clientNonce) {
+		return fmt.Errorf("server SCRAM-SHA-1 nonce is not prefixed by client nonce: got %q, want %q+\"...\"", c.serverNonce, c.clientNonce)
+	}
+
+	salt := make([]byte, b64.DecodedLen(len(fields[1][2:])))
+	n, err := b64.Decode(salt, fields[1][2:])
+	if err != nil {
+		return fmt.Errorf("cannot decode SCRAM-SHA-1 salt sent by server: %q", fields[1])
+	}
+	salt = salt[:n]
+	iterCount, err := strconv.Atoi(string(fields[2][2:]))
+	if err != nil {
+		return fmt.Errorf("server sent an invalid SCRAM-SHA-1 iteration count: %q", fields[2])
+	}
+	c.saltPassword(salt, iterCount)
+
+	c.authMsg.WriteString(",c=biws,r=")
+	c.authMsg.Write(c.serverNonce)
+
+	c.out.WriteString("c=biws,r=")
+	c.out.Write(c.serverNonce)
+	c.out.WriteString(",p=")
+	c.out.Write(c.clientProof())
+	return nil
+}
+
+func (c *Client) step3(in []byte) error {
+	var isv, ise bool
+	var fields = bytes.Split(in, []byte(","))
+	if len(fields) == 1 {
+		isv = bytes.HasPrefix(fields[0], []byte("v="))
+		ise = bytes.HasPrefix(fields[0], []byte("e="))
+	}
+	if ise {
+		return fmt.Errorf("SCRAM-SHA-1 authentication error: %s", fields[0][2:])
+	} else if !isv {
+		return fmt.Errorf("unsupported SCRAM-SHA-1 final message from server: %q", in)
+	}
+	if !bytes.Equal(c.serverSignature(), fields[0][2:]) {
+		return fmt.Errorf("cannot authenticate SCRAM-SHA-1 server signature: %q", fields[0][2:])
+	}
+	return nil
+}
+
+func (c *Client) saltPassword(salt []byte, iterCount int) {
+	mac := hmac.New(c.newHash, []byte(c.pass))
+	mac.Write(salt)
+	mac.Write([]byte{0, 0, 0, 1})
+	ui := mac.Sum(nil)
+	hi := make([]byte, len(ui))
+	copy(hi, ui)
+	for i := 1; i < iterCount; i++ {
+		mac.Reset()
+		mac.Write(ui)
+		mac.Sum(ui[:0])
+		for j, b := range ui {
+			hi[j] ^= b
+		}
+	}
+	c.saltedPass = hi
+}
+
+func (c *Client) clientProof() []byte {
+	mac := hmac.New(c.newHash, c.saltedPass)
+	mac.Write([]byte("Client Key"))
+	clientKey := mac.Sum(nil)
+	hash := c.newHash()
+	hash.Write(clientKey)
+	storedKey := hash.Sum(nil)
+	mac = hmac.New(c.newHash, storedKey)
+	mac.Write(c.authMsg.Bytes())
+	clientProof := mac.Sum(nil)
+	for i, b := range clientKey {
+		clientProof[i] ^= b
+	}
+	clientProof64 := make([]byte, b64.EncodedLen(len(clientProof)))
+	b64.Encode(clientProof64, clientProof)
+	return clientProof64
+}
+
+func (c *Client) serverSignature() []byte {
+	mac := hmac.New(c.newHash, c.saltedPass)
+	mac.Write([]byte("Server Key"))
+	serverKey := mac.Sum(nil)
+
+	mac = hmac.New(c.newHash, serverKey)
+	mac.Write(c.authMsg.Bytes())
+	serverSignature := mac.Sum(nil)
+
+	encoded := make([]byte, b64.EncodedLen(len(serverSignature)))
+	b64.Encode(encoded, serverSignature)
+	return encoded
+}
diff --git a/vendor/gopkg.in/mgo.v2/log.go b/vendor/gopkg.in/mgo.v2/log.go
new file mode 100644
index 00000000..53eb4237
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/log.go
@@ -0,0 +1,133 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"fmt"
+	"sync"
+)
+
+// ---------------------------------------------------------------------------
+// Logging integration.
+
+// Avoid importing the log type information unnecessarily.  There's a small cost
+// associated with using an interface rather than the type.  Depending on how
+// often the logger is plugged in, it would be worth using the type instead.
+type log_Logger interface {
+	Output(calldepth int, s string) error
+}
+
+var (
+	globalLogger log_Logger
+	globalDebug  bool
+	globalMutex  sync.Mutex
+)
+
+// RACE WARNING: There are known data races when logging, which are manually
+// silenced when the race detector is in use. These data races won't be
+// observed in typical use, because logging is supposed to be set up once when
+// the application starts. Having raceDetector as a constant, the compiler
+// should elide the locks altogether in actual use.
+
+// Specify the *log.Logger object where log messages should be sent to.
+func SetLogger(logger log_Logger) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	globalLogger = logger
+}
+
+// Enable the delivery of debug messages to the logger.  Only meaningful
+// if a logger is also set.
+func SetDebug(debug bool) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	globalDebug = debug
+}
+
+func log(v ...interface{}) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if globalLogger != nil {
+		globalLogger.Output(2, fmt.Sprint(v...))
+	}
+}
+
+func logln(v ...interface{}) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if globalLogger != nil {
+		globalLogger.Output(2, fmt.Sprintln(v...))
+	}
+}
+
+func logf(format string, v ...interface{}) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if globalLogger != nil {
+		globalLogger.Output(2, fmt.Sprintf(format, v...))
+	}
+}
+
+func debug(v ...interface{}) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if globalDebug && globalLogger != nil {
+		globalLogger.Output(2, fmt.Sprint(v...))
+	}
+}
+
+func debugln(v ...interface{}) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if globalDebug && globalLogger != nil {
+		globalLogger.Output(2, fmt.Sprintln(v...))
+	}
+}
+
+func debugf(format string, v ...interface{}) {
+	if raceDetector {
+		globalMutex.Lock()
+		defer globalMutex.Unlock()
+	}
+	if globalDebug && globalLogger != nil {
+		globalLogger.Output(2, fmt.Sprintf(format, v...))
+	}
+}
diff --git a/vendor/gopkg.in/mgo.v2/queue.go b/vendor/gopkg.in/mgo.v2/queue.go
new file mode 100644
index 00000000..e9245de7
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/queue.go
@@ -0,0 +1,91 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+type queue struct {
+	elems               []interface{}
+	nelems, popi, pushi int
+}
+
+func (q *queue) Len() int {
+	return q.nelems
+}
+
+func (q *queue) Push(elem interface{}) {
+	//debugf("Pushing(pushi=%d popi=%d cap=%d): %#v\n",
+	//       q.pushi, q.popi, len(q.elems), elem)
+	if q.nelems == len(q.elems) {
+		q.expand()
+	}
+	q.elems[q.pushi] = elem
+	q.nelems++
+	q.pushi = (q.pushi + 1) % len(q.elems)
+	//debugf(" Pushed(pushi=%d popi=%d cap=%d): %#v\n",
+	//       q.pushi, q.popi, len(q.elems), elem)
+}
+
+func (q *queue) Pop() (elem interface{}) {
+	//debugf("Popping(pushi=%d popi=%d cap=%d)\n",
+	//       q.pushi, q.popi, len(q.elems))
+	if q.nelems == 0 {
+		return nil
+	}
+	elem = q.elems[q.popi]
+	q.elems[q.popi] = nil // Help GC.
+	q.nelems--
+	q.popi = (q.popi + 1) % len(q.elems)
+	//debugf(" Popped(pushi=%d popi=%d cap=%d): %#v\n",
+	//       q.pushi, q.popi, len(q.elems), elem)
+	return elem
+}
+
+func (q *queue) expand() {
+	curcap := len(q.elems)
+	var newcap int
+	if curcap == 0 {
+		newcap = 8
+	} else if curcap < 1024 {
+		newcap = curcap * 2
+	} else {
+		newcap = curcap + (curcap / 4)
+	}
+	elems := make([]interface{}, newcap)
+
+	if q.popi == 0 {
+		copy(elems, q.elems)
+		q.pushi = curcap
+	} else {
+		newpopi := newcap - (curcap - q.popi)
+		copy(elems, q.elems[:q.popi])
+		copy(elems[newpopi:], q.elems[q.popi:])
+		q.popi = newpopi
+	}
+	for i := range q.elems {
+		q.elems[i] = nil // Help GC.
+	}
+	q.elems = elems
+}
diff --git a/vendor/gopkg.in/mgo.v2/raceoff.go b/vendor/gopkg.in/mgo.v2/raceoff.go
new file mode 100644
index 00000000..e60b1414
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/raceoff.go
@@ -0,0 +1,5 @@
+// +build !race
+
+package mgo
+
+const raceDetector = false
diff --git a/vendor/gopkg.in/mgo.v2/raceon.go b/vendor/gopkg.in/mgo.v2/raceon.go
new file mode 100644
index 00000000..737b08ec
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/raceon.go
@@ -0,0 +1,5 @@
+// +build race
+
+package mgo
+
+const raceDetector = true
diff --git a/vendor/gopkg.in/mgo.v2/saslimpl.go b/vendor/gopkg.in/mgo.v2/saslimpl.go
new file mode 100644
index 00000000..0d25f25c
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/saslimpl.go
@@ -0,0 +1,11 @@
+//+build sasl
+
+package mgo
+
+import (
+	"gopkg.in/mgo.v2/internal/sasl"
+)
+
+func saslNew(cred Credential, host string) (saslStepper, error) {
+	return sasl.New(cred.Username, cred.Password, cred.Mechanism, cred.Service, host)
+}
diff --git a/vendor/gopkg.in/mgo.v2/saslstub.go b/vendor/gopkg.in/mgo.v2/saslstub.go
new file mode 100644
index 00000000..6e9e3098
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/saslstub.go
@@ -0,0 +1,11 @@
+//+build !sasl
+
+package mgo
+
+import (
+	"fmt"
+)
+
+func saslNew(cred Credential, host string) (saslStepper, error) {
+	return nil, fmt.Errorf("SASL support not enabled during build (-tags sasl)")
+}
diff --git a/vendor/gopkg.in/mgo.v2/server.go b/vendor/gopkg.in/mgo.v2/server.go
new file mode 100644
index 00000000..d5086a29
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/server.go
@@ -0,0 +1,448 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"errors"
+	"net"
+	"sort"
+	"sync"
+	"time"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+// ---------------------------------------------------------------------------
+// Mongo server encapsulation.
+
+type mongoServer struct {
+	sync.RWMutex
+	Addr          string
+	ResolvedAddr  string
+	tcpaddr       *net.TCPAddr
+	unusedSockets []*mongoSocket
+	liveSockets   []*mongoSocket
+	closed        bool
+	abended       bool
+	sync          chan bool
+	dial          dialer
+	pingValue     time.Duration
+	pingIndex     int
+	pingCount     uint32
+	pingWindow    [6]time.Duration
+	info          *mongoServerInfo
+}
+
+type dialer struct {
+	old func(addr net.Addr) (net.Conn, error)
+	new func(addr *ServerAddr) (net.Conn, error)
+}
+
+func (dial dialer) isSet() bool {
+	return dial.old != nil || dial.new != nil
+}
+
+type mongoServerInfo struct {
+	Master         bool
+	Mongos         bool
+	Tags           bson.D
+	MaxWireVersion int
+	SetName        string
+}
+
+var defaultServerInfo mongoServerInfo
+
+func newServer(addr string, tcpaddr *net.TCPAddr, sync chan bool, dial dialer) *mongoServer {
+	server := &mongoServer{
+		Addr:         addr,
+		ResolvedAddr: tcpaddr.String(),
+		tcpaddr:      tcpaddr,
+		sync:         sync,
+		dial:         dial,
+		info:         &defaultServerInfo,
+	}
+	// Once so the server gets a ping value, then loop in background.
+	server.pinger(false)
+	go server.pinger(true)
+	return server
+}
+
+var errPoolLimit = errors.New("per-server connection limit reached")
+var errServerClosed = errors.New("server was closed")
+
+// AcquireSocket returns a socket for communicating with the server.
+// This will attempt to reuse an old connection, if one is available. Otherwise,
+// it will establish a new one. The returned socket is owned by the call site,
+// and will return to the cache when the socket has its Release method called
+// the same number of times as AcquireSocket + Acquire were called for it.
+// If the poolLimit argument is greater than zero and the number of sockets in
+// use in this server is greater than the provided limit, errPoolLimit is
+// returned.
+func (server *mongoServer) AcquireSocket(poolLimit int, timeout time.Duration) (socket *mongoSocket, abended bool, err error) {
+	for {
+		server.Lock()
+		abended = server.abended
+		if server.closed {
+			server.Unlock()
+			return nil, abended, errServerClosed
+		}
+		n := len(server.unusedSockets)
+		if poolLimit > 0 && len(server.liveSockets)-n >= poolLimit {
+			server.Unlock()
+			return nil, false, errPoolLimit
+		}
+		if n > 0 {
+			socket = server.unusedSockets[n-1]
+			server.unusedSockets[n-1] = nil // Help GC.
+			server.unusedSockets = server.unusedSockets[:n-1]
+			info := server.info
+			server.Unlock()
+			err = socket.InitialAcquire(info, timeout)
+			if err != nil {
+				continue
+			}
+		} else {
+			server.Unlock()
+			socket, err = server.Connect(timeout)
+			if err == nil {
+				server.Lock()
+				// We've waited for the Connect, see if we got
+				// closed in the meantime
+				if server.closed {
+					server.Unlock()
+					socket.Release()
+					socket.Close()
+					return nil, abended, errServerClosed
+				}
+				server.liveSockets = append(server.liveSockets, socket)
+				server.Unlock()
+			}
+		}
+		return
+	}
+	panic("unreachable")
+}
+
+// Connect establishes a new connection to the server. This should
+// generally be done through server.AcquireSocket().
+func (server *mongoServer) Connect(timeout time.Duration) (*mongoSocket, error) {
+	server.RLock()
+	master := server.info.Master
+	dial := server.dial
+	server.RUnlock()
+
+	logf("Establishing new connection to %s (timeout=%s)...", server.Addr, timeout)
+	var conn net.Conn
+	var err error
+	switch {
+	case !dial.isSet():
+		// Cannot do this because it lacks timeout support. :-(
+		//conn, err = net.DialTCP("tcp", nil, server.tcpaddr)
+		conn, err = net.DialTimeout("tcp", server.ResolvedAddr, timeout)
+	case dial.old != nil:
+		conn, err = dial.old(server.tcpaddr)
+	case dial.new != nil:
+		conn, err = dial.new(&ServerAddr{server.Addr, server.tcpaddr})
+	default:
+		panic("dialer is set, but both dial.old and dial.new are nil")
+	}
+	if err != nil {
+		logf("Connection to %s failed: %v", server.Addr, err.Error())
+		return nil, err
+	}
+	logf("Connection to %s established.", server.Addr)
+
+	stats.conn(+1, master)
+	return newSocket(server, conn, timeout), nil
+}
+
+// Close forces closing all sockets that are alive, whether
+// they're currently in use or not.
+func (server *mongoServer) Close() {
+	server.Lock()
+	server.closed = true
+	liveSockets := server.liveSockets
+	unusedSockets := server.unusedSockets
+	server.liveSockets = nil
+	server.unusedSockets = nil
+	server.Unlock()
+	logf("Connections to %s closing (%d live sockets).", server.Addr, len(liveSockets))
+	for i, s := range liveSockets {
+		s.Close()
+		liveSockets[i] = nil
+	}
+	for i := range unusedSockets {
+		unusedSockets[i] = nil
+	}
+}
+
+// RecycleSocket puts socket back into the unused cache.
+func (server *mongoServer) RecycleSocket(socket *mongoSocket) {
+	server.Lock()
+	if !server.closed {
+		server.unusedSockets = append(server.unusedSockets, socket)
+	}
+	server.Unlock()
+}
+
+func removeSocket(sockets []*mongoSocket, socket *mongoSocket) []*mongoSocket {
+	for i, s := range sockets {
+		if s == socket {
+			copy(sockets[i:], sockets[i+1:])
+			n := len(sockets) - 1
+			sockets[n] = nil
+			sockets = sockets[:n]
+			break
+		}
+	}
+	return sockets
+}
+
+// AbendSocket notifies the server that the given socket has terminated
+// abnormally, and thus should be discarded rather than cached.
+func (server *mongoServer) AbendSocket(socket *mongoSocket) {
+	server.Lock()
+	server.abended = true
+	if server.closed {
+		server.Unlock()
+		return
+	}
+	server.liveSockets = removeSocket(server.liveSockets, socket)
+	server.unusedSockets = removeSocket(server.unusedSockets, socket)
+	server.Unlock()
+	// Maybe just a timeout, but suggest a cluster sync up just in case.
+	select {
+	case server.sync <- true:
+	default:
+	}
+}
+
+func (server *mongoServer) SetInfo(info *mongoServerInfo) {
+	server.Lock()
+	server.info = info
+	server.Unlock()
+}
+
+func (server *mongoServer) Info() *mongoServerInfo {
+	server.Lock()
+	info := server.info
+	server.Unlock()
+	return info
+}
+
+func (server *mongoServer) hasTags(serverTags []bson.D) bool {
+NextTagSet:
+	for _, tags := range serverTags {
+	NextReqTag:
+		for _, req := range tags {
+			for _, has := range server.info.Tags {
+				if req.Name == has.Name {
+					if req.Value == has.Value {
+						continue NextReqTag
+					}
+					continue NextTagSet
+				}
+			}
+			continue NextTagSet
+		}
+		return true
+	}
+	return false
+}
+
+var pingDelay = 5 * time.Second
+
+func (server *mongoServer) pinger(loop bool) {
+	var delay time.Duration
+	if raceDetector {
+		// This variable is only ever touched by tests.
+		globalMutex.Lock()
+		delay = pingDelay
+		globalMutex.Unlock()
+	} else {
+		delay = pingDelay
+	}
+	op := queryOp{
+		collection: "admin.$cmd",
+		query:      bson.D{{"ping", 1}},
+		flags:      flagSlaveOk,
+		limit:      -1,
+	}
+	for {
+		if loop {
+			time.Sleep(delay)
+		}
+		op := op
+		socket, _, err := server.AcquireSocket(0, 3*delay)
+		if err == nil {
+			start := time.Now()
+			_, _ = socket.SimpleQuery(&op)
+			delay := time.Now().Sub(start)
+
+			server.pingWindow[server.pingIndex] = delay
+			server.pingIndex = (server.pingIndex + 1) % len(server.pingWindow)
+			server.pingCount++
+			var max time.Duration
+			for i := 0; i < len(server.pingWindow) && uint32(i) < server.pingCount; i++ {
+				if server.pingWindow[i] > max {
+					max = server.pingWindow[i]
+				}
+			}
+			socket.Release()
+			server.Lock()
+			if server.closed {
+				loop = false
+			}
+			server.pingValue = max
+			server.Unlock()
+			logf("Ping for %s is %d ms", server.Addr, max/time.Millisecond)
+		} else if err == errServerClosed {
+			return
+		}
+		if !loop {
+			return
+		}
+	}
+}
+
+type mongoServerSlice []*mongoServer
+
+func (s mongoServerSlice) Len() int {
+	return len(s)
+}
+
+func (s mongoServerSlice) Less(i, j int) bool {
+	return s[i].ResolvedAddr < s[j].ResolvedAddr
+}
+
+func (s mongoServerSlice) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s mongoServerSlice) Sort() {
+	sort.Sort(s)
+}
+
+func (s mongoServerSlice) Search(resolvedAddr string) (i int, ok bool) {
+	n := len(s)
+	i = sort.Search(n, func(i int) bool {
+		return s[i].ResolvedAddr >= resolvedAddr
+	})
+	return i, i != n && s[i].ResolvedAddr == resolvedAddr
+}
+
+type mongoServers struct {
+	slice mongoServerSlice
+}
+
+func (servers *mongoServers) Search(resolvedAddr string) (server *mongoServer) {
+	if i, ok := servers.slice.Search(resolvedAddr); ok {
+		return servers.slice[i]
+	}
+	return nil
+}
+
+func (servers *mongoServers) Add(server *mongoServer) {
+	servers.slice = append(servers.slice, server)
+	servers.slice.Sort()
+}
+
+func (servers *mongoServers) Remove(other *mongoServer) (server *mongoServer) {
+	if i, found := servers.slice.Search(other.ResolvedAddr); found {
+		server = servers.slice[i]
+		copy(servers.slice[i:], servers.slice[i+1:])
+		n := len(servers.slice) - 1
+		servers.slice[n] = nil // Help GC.
+		servers.slice = servers.slice[:n]
+	}
+	return
+}
+
+func (servers *mongoServers) Slice() []*mongoServer {
+	return ([]*mongoServer)(servers.slice)
+}
+
+func (servers *mongoServers) Get(i int) *mongoServer {
+	return servers.slice[i]
+}
+
+func (servers *mongoServers) Len() int {
+	return len(servers.slice)
+}
+
+func (servers *mongoServers) Empty() bool {
+	return len(servers.slice) == 0
+}
+
+// BestFit returns the best guess of what would be the most interesting
+// server to perform operations on at this point in time.
+func (servers *mongoServers) BestFit(serverTags []bson.D) *mongoServer {
+	var best *mongoServer
+	for _, next := range servers.slice {
+		if best == nil {
+			best = next
+			best.RLock()
+			if serverTags != nil && !next.info.Mongos && !best.hasTags(serverTags) {
+				best.RUnlock()
+				best = nil
+			}
+			continue
+		}
+		next.RLock()
+		swap := false
+		switch {
+		case serverTags != nil && !next.info.Mongos && !next.hasTags(serverTags):
+			// Must have requested tags.
+		case next.info.Master != best.info.Master:
+			// Prefer slaves.
+			swap = best.info.Master
+		case absDuration(next.pingValue-best.pingValue) > 15*time.Millisecond:
+			// Prefer nearest server.
+			swap = next.pingValue < best.pingValue
+		case len(next.liveSockets)-len(next.unusedSockets) < len(best.liveSockets)-len(best.unusedSockets):
+			// Prefer servers with less connections.
+			swap = true
+		}
+		if swap {
+			best.RUnlock()
+			best = next
+		} else {
+			next.RUnlock()
+		}
+	}
+	if best != nil {
+		best.RUnlock()
+	}
+	return best
+}
+
+func absDuration(d time.Duration) time.Duration {
+	if d < 0 {
+		return -d
+	}
+	return d
+}
diff --git a/vendor/gopkg.in/mgo.v2/session.go b/vendor/gopkg.in/mgo.v2/session.go
new file mode 100644
index 00000000..cc986866
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/session.go
@@ -0,0 +1,4222 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math"
+	"net"
+	"net/url"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+type mode int
+
+const (
+	Eventual  mode = 0
+	Monotonic mode = 1
+	Strong    mode = 2
+)
+
+// When changing the Session type, check if newSession and copySession
+// need to be updated too.
+
+type Session struct {
+	m            sync.RWMutex
+	cluster_     *mongoCluster
+	slaveSocket  *mongoSocket
+	masterSocket *mongoSocket
+	slaveOk      bool
+	consistency  mode
+	queryConfig  query
+	safeOp       *queryOp
+	syncTimeout  time.Duration
+	sockTimeout  time.Duration
+	defaultdb    string
+	sourcedb     string
+	dialCred     *Credential
+	creds        []Credential
+	poolLimit    int
+}
+
+type Database struct {
+	Session *Session
+	Name    string
+}
+
+type Collection struct {
+	Database *Database
+	Name     string // "collection"
+	FullName string // "db.collection"
+}
+
+type Query struct {
+	m       sync.Mutex
+	session *Session
+	query   // Enables default settings in session.
+}
+
+type query struct {
+	op       queryOp
+	prefetch float64
+	limit    int32
+}
+
+type getLastError struct {
+	CmdName  int         "getLastError,omitempty"
+	W        interface{} "w,omitempty"
+	WTimeout int         "wtimeout,omitempty"
+	FSync    bool        "fsync,omitempty"
+	J        bool        "j,omitempty"
+}
+
+type Iter struct {
+	m              sync.Mutex
+	gotReply       sync.Cond
+	session        *Session
+	server         *mongoServer
+	docData        queue
+	err            error
+	op             getMoreOp
+	prefetch       float64
+	limit          int32
+	docsToReceive  int
+	docsBeforeMore int
+	timeout        time.Duration
+	timedout       bool
+}
+
+var (
+	ErrNotFound = errors.New("not found")
+	ErrCursor   = errors.New("invalid cursor")
+)
+
+const defaultPrefetch = 0.25
+
+// Dial establishes a new session to the cluster identified by the given seed
+// server(s). The session will enable communication with all of the servers in
+// the cluster, so the seed servers are used only to find out about the cluster
+// topology.
+//
+// Dial will timeout after 10 seconds if a server isn't reached. The returned
+// session will timeout operations after one minute by default if servers
+// aren't available. To customize the timeout, see DialWithTimeout,
+// SetSyncTimeout, and SetSocketTimeout.
+//
+// This method is generally called just once for a given cluster.  Further
+// sessions to the same cluster are then established using the New or Copy
+// methods on the obtained session. This will make them share the underlying
+// cluster, and manage the pool of connections appropriately.
+//
+// Once the session is not useful anymore, Close must be called to release the
+// resources appropriately.
+//
+// The seed servers must be provided in the following format:
+//
+//     [mongodb://][user:pass@]host1[:port1][,host2[:port2],...][/database][?options]
+//
+// For example, it may be as simple as:
+//
+//     localhost
+//
+// Or more involved like:
+//
+//     mongodb://myuser:mypass@localhost:40001,otherhost:40001/mydb
+//
+// If the port number is not provided for a server, it defaults to 27017.
+//
+// The username and password provided in the URL will be used to authenticate
+// into the database named after the slash at the end of the host names, or
+// into the "admin" database if none is provided.  The authentication information
+// will persist in sessions obtained through the New method as well.
+//
+// The following connection options are supported after the question mark:
+//
+//     connect=direct
+//
+//         Disables the automatic replica set server discovery logic, and
+//         forces the use of servers provided only (even if secondaries).
+//         Note that to talk to a secondary the consistency requirements
+//         must be relaxed to Monotonic or Eventual via SetMode.
+//
+//
+//     authSource=<db>
+//
+//         Informs the database used to establish credentials and privileges
+//         with a MongoDB server. Defaults to the database name provided via
+//         the URL path, and "admin" if that's unset.
+//
+//
+//     authMechanism=<mechanism>
+//
+//        Defines the protocol for credential negotiation. Defaults to "MONGODB-CR",
+//        which is the default username/password challenge-response mechanism.
+//
+//
+//     gssapiServiceName=<name>
+//
+//        Defines the service name to use when authenticating with the GSSAPI
+//        mechanism. Defaults to "mongodb".
+//
+//     maxPoolSize=<limit>
+//
+//        Defines the per-server socket pool limit. Defaults to 4096.
+//        See Session.SetPoolLimit for details.
+//
+//
+// Relevant documentation:
+//
+//     http://docs.mongodb.org/manual/reference/connection-string/
+//
+func Dial(url string) (*Session, error) {
+	session, err := DialWithTimeout(url, 10*time.Second)
+	if err == nil {
+		session.SetSyncTimeout(1 * time.Minute)
+		session.SetSocketTimeout(1 * time.Minute)
+	}
+	return session, err
+}
+
+// DialWithTimeout works like Dial, but uses timeout as the amount of time to
+// wait for a server to respond when first connecting and also on follow up
+// operations in the session. If timeout is zero, the call may block
+// forever waiting for a connection to be made.
+//
+// See SetSyncTimeout for customizing the timeout for the session.
+func DialWithTimeout(url string, timeout time.Duration) (*Session, error) {
+	info, err := ParseURL(url)
+	if err != nil {
+		return nil, err
+	}
+	info.Timeout = timeout
+	return DialWithInfo(info)
+}
+
+// ParseURL parses a MongoDB URL as accepted by the Dial function and returns
+// a value suitable for providing into DialWithInfo.
+//
+// See Dial for more details on the format of url.
+func ParseURL(url string) (*DialInfo, error) {
+	uinfo, err := extractURL(url)
+	if err != nil {
+		return nil, err
+	}
+	direct := false
+	mechanism := ""
+	service := ""
+	source := ""
+	setName := ""
+	poolLimit := 0
+	for k, v := range uinfo.options {
+		switch k {
+		case "authSource":
+			source = v
+		case "authMechanism":
+			mechanism = v
+		case "gssapiServiceName":
+			service = v
+		case "replicaSet":
+			setName = v
+		case "maxPoolSize":
+			poolLimit, err = strconv.Atoi(v)
+			if err != nil {
+				return nil, errors.New("bad value for maxPoolSize: " + v)
+			}
+		case "connect":
+			if v == "direct" {
+				direct = true
+				break
+			}
+			if v == "replicaSet" {
+				break
+			}
+			fallthrough
+		default:
+			return nil, errors.New("unsupported connection URL option: " + k + "=" + v)
+		}
+	}
+	info := DialInfo{
+		Addrs:          uinfo.addrs,
+		Direct:         direct,
+		Database:       uinfo.db,
+		Username:       uinfo.user,
+		Password:       uinfo.pass,
+		Mechanism:      mechanism,
+		Service:        service,
+		Source:         source,
+		PoolLimit:      poolLimit,
+		ReplicaSetName: setName,
+	}
+	return &info, nil
+}
+
+// DialInfo holds options for establishing a session with a MongoDB cluster.
+// To use a URL, see the Dial function.
+type DialInfo struct {
+	// Addrs holds the addresses for the seed servers.
+	Addrs []string
+
+	// Direct informs whether to establish connections only with the
+	// specified seed servers, or to obtain information for the whole
+	// cluster and establish connections with further servers too.
+	Direct bool
+
+	// Timeout is the amount of time to wait for a server to respond when
+	// first connecting and on follow up operations in the session. If
+	// timeout is zero, the call may block forever waiting for a connection
+	// to be established.
+	Timeout time.Duration
+
+	// FailFast will cause connection and query attempts to fail faster when
+	// the server is unavailable, instead of retrying until the configured
+	// timeout period. Note that an unavailable server may silently drop
+	// packets instead of rejecting them, in which case it's impossible to
+	// distinguish it from a slow server, so the timeout stays relevant.
+	FailFast bool
+
+	// Database is the default database name used when the Session.DB method
+	// is called with an empty name, and is also used during the intial
+	// authentication if Source is unset.
+	Database string
+
+	// ReplicaSetName, if specified, will prevent the obtained session from
+	// communicating with any server which is not part of a replica set
+	// with the given name. The default is to communicate with any server
+	// specified or discovered via the servers contacted.
+	ReplicaSetName string
+
+	// Source is the database used to establish credentials and privileges
+	// with a MongoDB server. Defaults to the value of Database, if that is
+	// set, or "admin" otherwise.
+	Source string
+
+	// Service defines the service name to use when authenticating with the GSSAPI
+	// mechanism. Defaults to "mongodb".
+	Service string
+
+	// ServiceHost defines which hostname to use when authenticating
+	// with the GSSAPI mechanism. If not specified, defaults to the MongoDB
+	// server's address.
+	ServiceHost string
+
+	// Mechanism defines the protocol for credential negotiation.
+	// Defaults to "MONGODB-CR".
+	Mechanism string
+
+	// Username and Password inform the credentials for the initial authentication
+	// done on the database defined by the Source field. See Session.Login.
+	Username string
+	Password string
+
+	// PoolLimit defines the per-server socket pool limit. Defaults to 4096.
+	// See Session.SetPoolLimit for details.
+	PoolLimit int
+
+	// DialServer optionally specifies the dial function for establishing
+	// connections with the MongoDB servers.
+	DialServer func(addr *ServerAddr) (net.Conn, error)
+
+	// WARNING: This field is obsolete. See DialServer above.
+	Dial func(addr net.Addr) (net.Conn, error)
+}
+
+// ServerAddr represents the address for establishing a connection to an
+// individual MongoDB server.
+type ServerAddr struct {
+	str string
+	tcp *net.TCPAddr
+}
+
+// String returns the address that was provided for the server before resolution.
+func (addr *ServerAddr) String() string {
+	return addr.str
+}
+
+// TCPAddr returns the resolved TCP address for the server.
+func (addr *ServerAddr) TCPAddr() *net.TCPAddr {
+	return addr.tcp
+}
+
+// DialWithInfo establishes a new session to the cluster identified by info.
+func DialWithInfo(info *DialInfo) (*Session, error) {
+	addrs := make([]string, len(info.Addrs))
+	for i, addr := range info.Addrs {
+		p := strings.LastIndexAny(addr, "]:")
+		if p == -1 || addr[p] != ':' {
+			// XXX This is untested. The test suite doesn't use the standard port.
+			addr += ":27017"
+		}
+		addrs[i] = addr
+	}
+	cluster := newCluster(addrs, info.Direct, info.FailFast, dialer{info.Dial, info.DialServer}, info.ReplicaSetName)
+	session := newSession(Eventual, cluster, info.Timeout)
+	session.defaultdb = info.Database
+	if session.defaultdb == "" {
+		session.defaultdb = "test"
+	}
+	session.sourcedb = info.Source
+	if session.sourcedb == "" {
+		session.sourcedb = info.Database
+		if session.sourcedb == "" {
+			session.sourcedb = "admin"
+		}
+	}
+	if info.Username != "" {
+		source := session.sourcedb
+		if info.Source == "" &&
+			(info.Mechanism == "GSSAPI" || info.Mechanism == "PLAIN" || info.Mechanism == "MONGODB-X509") {
+			source = "$external"
+		}
+		session.dialCred = &Credential{
+			Username:    info.Username,
+			Password:    info.Password,
+			Mechanism:   info.Mechanism,
+			Service:     info.Service,
+			ServiceHost: info.ServiceHost,
+			Source:      source,
+		}
+		session.creds = []Credential{*session.dialCred}
+	}
+	if info.PoolLimit > 0 {
+		session.poolLimit = info.PoolLimit
+	}
+	cluster.Release()
+
+	// People get confused when we return a session that is not actually
+	// established to any servers yet (e.g. what if url was wrong). So,
+	// ping the server to ensure there's someone there, and abort if it
+	// fails.
+	if err := session.Ping(); err != nil {
+		session.Close()
+		return nil, err
+	}
+	session.SetMode(Strong, true)
+	return session, nil
+}
+
+func isOptSep(c rune) bool {
+	return c == ';' || c == '&'
+}
+
+type urlInfo struct {
+	addrs   []string
+	user    string
+	pass    string
+	db      string
+	options map[string]string
+}
+
+func extractURL(s string) (*urlInfo, error) {
+	if strings.HasPrefix(s, "mongodb://") {
+		s = s[10:]
+	}
+	info := &urlInfo{options: make(map[string]string)}
+	if c := strings.Index(s, "?"); c != -1 {
+		for _, pair := range strings.FieldsFunc(s[c+1:], isOptSep) {
+			l := strings.SplitN(pair, "=", 2)
+			if len(l) != 2 || l[0] == "" || l[1] == "" {
+				return nil, errors.New("connection option must be key=value: " + pair)
+			}
+			info.options[l[0]] = l[1]
+		}
+		s = s[:c]
+	}
+	if c := strings.Index(s, "@"); c != -1 {
+		pair := strings.SplitN(s[:c], ":", 2)
+		if len(pair) > 2 || pair[0] == "" {
+			return nil, errors.New("credentials must be provided as user:pass@host")
+		}
+		var err error
+		info.user, err = url.QueryUnescape(pair[0])
+		if err != nil {
+			return nil, fmt.Errorf("cannot unescape username in URL: %q", pair[0])
+		}
+		if len(pair) > 1 {
+			info.pass, err = url.QueryUnescape(pair[1])
+			if err != nil {
+				return nil, fmt.Errorf("cannot unescape password in URL")
+			}
+		}
+		s = s[c+1:]
+	}
+	if c := strings.Index(s, "/"); c != -1 {
+		info.db = s[c+1:]
+		s = s[:c]
+	}
+	info.addrs = strings.Split(s, ",")
+	return info, nil
+}
+
+func newSession(consistency mode, cluster *mongoCluster, timeout time.Duration) (session *Session) {
+	cluster.Acquire()
+	session = &Session{
+		cluster_:    cluster,
+		syncTimeout: timeout,
+		sockTimeout: timeout,
+		poolLimit:   4096,
+	}
+	debugf("New session %p on cluster %p", session, cluster)
+	session.SetMode(consistency, true)
+	session.SetSafe(&Safe{})
+	session.queryConfig.prefetch = defaultPrefetch
+	return session
+}
+
+func copySession(session *Session, keepCreds bool) (s *Session) {
+	cluster := session.cluster()
+	cluster.Acquire()
+	if session.masterSocket != nil {
+		session.masterSocket.Acquire()
+	}
+	if session.slaveSocket != nil {
+		session.slaveSocket.Acquire()
+	}
+	var creds []Credential
+	if keepCreds {
+		creds = make([]Credential, len(session.creds))
+		copy(creds, session.creds)
+	} else if session.dialCred != nil {
+		creds = []Credential{*session.dialCred}
+	}
+	scopy := *session
+	scopy.m = sync.RWMutex{}
+	scopy.creds = creds
+	s = &scopy
+	debugf("New session %p on cluster %p (copy from %p)", s, cluster, session)
+	return s
+}
+
+// LiveServers returns a list of server addresses which are
+// currently known to be alive.
+func (s *Session) LiveServers() (addrs []string) {
+	s.m.RLock()
+	addrs = s.cluster().LiveServers()
+	s.m.RUnlock()
+	return addrs
+}
+
+// DB returns a value representing the named database. If name
+// is empty, the database name provided in the dialed URL is
+// used instead. If that is also empty, "test" is used as a
+// fallback in a way equivalent to the mongo shell.
+//
+// Creating this value is a very lightweight operation, and
+// involves no network communication.
+func (s *Session) DB(name string) *Database {
+	if name == "" {
+		name = s.defaultdb
+	}
+	return &Database{s, name}
+}
+
+// C returns a value representing the named collection.
+//
+// Creating this value is a very lightweight operation, and
+// involves no network communication.
+func (db *Database) C(name string) *Collection {
+	return &Collection{db, name, db.Name + "." + name}
+}
+
+// With returns a copy of db that uses session s.
+func (db *Database) With(s *Session) *Database {
+	newdb := *db
+	newdb.Session = s
+	return &newdb
+}
+
+// With returns a copy of c that uses session s.
+func (c *Collection) With(s *Session) *Collection {
+	newdb := *c.Database
+	newdb.Session = s
+	newc := *c
+	newc.Database = &newdb
+	return &newc
+}
+
+// GridFS returns a GridFS value representing collections in db that
+// follow the standard GridFS specification.
+// The provided prefix (sometimes known as root) will determine which
+// collections to use, and is usually set to "fs" when there is a
+// single GridFS in the database.
+//
+// See the GridFS Create, Open, and OpenId methods for more details.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/GridFS
+//     http://www.mongodb.org/display/DOCS/GridFS+Tools
+//     http://www.mongodb.org/display/DOCS/GridFS+Specification
+//
+func (db *Database) GridFS(prefix string) *GridFS {
+	return newGridFS(db, prefix)
+}
+
+// Run issues the provided command on the db database and unmarshals
+// its result in the respective argument. The cmd argument may be either
+// a string with the command name itself, in which case an empty document of
+// the form bson.M{cmd: 1} will be used, or it may be a full command document.
+//
+// Note that MongoDB considers the first marshalled key as the command
+// name, so when providing a command with options, it's important to
+// use an ordering-preserving document, such as a struct value or an
+// instance of bson.D.  For instance:
+//
+//     db.Run(bson.D{{"create", "mycollection"}, {"size", 1024}})
+//
+// For privilleged commands typically run on the "admin" database, see
+// the Run method in the Session type.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Commands
+//     http://www.mongodb.org/display/DOCS/List+of+Database+CommandSkips
+//
+func (db *Database) Run(cmd interface{}, result interface{}) error {
+	socket, err := db.Session.acquireSocket(true)
+	if err != nil {
+		return err
+	}
+	defer socket.Release()
+
+	// This is an optimized form of db.C("$cmd").Find(cmd).One(result).
+	return db.run(socket, cmd, result)
+}
+
+// Credential holds details to authenticate with a MongoDB server.
+type Credential struct {
+	// Username and Password hold the basic details for authentication.
+	// Password is optional with some authentication mechanisms.
+	Username string
+	Password string
+
+	// Source is the database used to establish credentials and privileges
+	// with a MongoDB server. Defaults to the default database provided
+	// during dial, or "admin" if that was unset.
+	Source string
+
+	// Service defines the service name to use when authenticating with the GSSAPI
+	// mechanism. Defaults to "mongodb".
+	Service string
+
+	// ServiceHost defines which hostname to use when authenticating
+	// with the GSSAPI mechanism. If not specified, defaults to the MongoDB
+	// server's address.
+	ServiceHost string
+
+	// Mechanism defines the protocol for credential negotiation.
+	// Defaults to "MONGODB-CR".
+	Mechanism string
+}
+
+// Login authenticates with MongoDB using the provided credential.  The
+// authentication is valid for the whole session and will stay valid until
+// Logout is explicitly called for the same database, or the session is
+// closed.
+func (db *Database) Login(user, pass string) error {
+	return db.Session.Login(&Credential{Username: user, Password: pass, Source: db.Name})
+}
+
+// Login authenticates with MongoDB using the provided credential.  The
+// authentication is valid for the whole session and will stay valid until
+// Logout is explicitly called for the same database, or the session is
+// closed.
+func (s *Session) Login(cred *Credential) error {
+	socket, err := s.acquireSocket(true)
+	if err != nil {
+		return err
+	}
+	defer socket.Release()
+
+	credCopy := *cred
+	if cred.Source == "" {
+		if cred.Mechanism == "GSSAPI" {
+			credCopy.Source = "$external"
+		} else {
+			credCopy.Source = s.sourcedb
+		}
+	}
+	err = socket.Login(credCopy)
+	if err != nil {
+		return err
+	}
+
+	s.m.Lock()
+	s.creds = append(s.creds, credCopy)
+	s.m.Unlock()
+	return nil
+}
+
+func (s *Session) socketLogin(socket *mongoSocket) error {
+	for _, cred := range s.creds {
+		if err := socket.Login(cred); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Logout removes any established authentication credentials for the database.
+func (db *Database) Logout() {
+	session := db.Session
+	dbname := db.Name
+	session.m.Lock()
+	found := false
+	for i, cred := range session.creds {
+		if cred.Source == dbname {
+			copy(session.creds[i:], session.creds[i+1:])
+			session.creds = session.creds[:len(session.creds)-1]
+			found = true
+			break
+		}
+	}
+	if found {
+		if session.masterSocket != nil {
+			session.masterSocket.Logout(dbname)
+		}
+		if session.slaveSocket != nil {
+			session.slaveSocket.Logout(dbname)
+		}
+	}
+	session.m.Unlock()
+}
+
+// LogoutAll removes all established authentication credentials for the session.
+func (s *Session) LogoutAll() {
+	s.m.Lock()
+	for _, cred := range s.creds {
+		if s.masterSocket != nil {
+			s.masterSocket.Logout(cred.Source)
+		}
+		if s.slaveSocket != nil {
+			s.slaveSocket.Logout(cred.Source)
+		}
+	}
+	s.creds = s.creds[0:0]
+	s.m.Unlock()
+}
+
+// User represents a MongoDB user.
+//
+// Relevant documentation:
+//
+//     http://docs.mongodb.org/manual/reference/privilege-documents/
+//     http://docs.mongodb.org/manual/reference/user-privileges/
+//
+type User struct {
+	// Username is how the user identifies itself to the system.
+	Username string `bson:"user"`
+
+	// Password is the plaintext password for the user. If set,
+	// the UpsertUser method will hash it into PasswordHash and
+	// unset it before the user is added to the database.
+	Password string `bson:",omitempty"`
+
+	// PasswordHash is the MD5 hash of Username+":mongo:"+Password.
+	PasswordHash string `bson:"pwd,omitempty"`
+
+	// CustomData holds arbitrary data admins decide to associate
+	// with this user, such as the full name or employee id.
+	CustomData interface{} `bson:"customData,omitempty"`
+
+	// Roles indicates the set of roles the user will be provided.
+	// See the Role constants.
+	Roles []Role `bson:"roles"`
+
+	// OtherDBRoles allows assigning roles in other databases from
+	// user documents inserted in the admin database. This field
+	// only works in the admin database.
+	OtherDBRoles map[string][]Role `bson:"otherDBRoles,omitempty"`
+
+	// UserSource indicates where to look for this user's credentials.
+	// It may be set to a database name, or to "$external" for
+	// consulting an external resource such as Kerberos. UserSource
+	// must not be set if Password or PasswordHash are present.
+	//
+	// WARNING: This setting was only ever supported in MongoDB 2.4,
+	// and is now obsolete.
+	UserSource string `bson:"userSource,omitempty"`
+}
+
+type Role string
+
+const (
+	// Relevant documentation:
+	//
+	//     http://docs.mongodb.org/manual/reference/user-privileges/
+	//
+	RoleRoot         Role = "root"
+	RoleRead         Role = "read"
+	RoleReadAny      Role = "readAnyDatabase"
+	RoleReadWrite    Role = "readWrite"
+	RoleReadWriteAny Role = "readWriteAnyDatabase"
+	RoleDBAdmin      Role = "dbAdmin"
+	RoleDBAdminAny   Role = "dbAdminAnyDatabase"
+	RoleUserAdmin    Role = "userAdmin"
+	RoleUserAdminAny Role = "userAdminAnyDatabase"
+	RoleClusterAdmin Role = "clusterAdmin"
+)
+
+// UpsertUser updates the authentication credentials and the roles for
+// a MongoDB user within the db database. If the named user doesn't exist
+// it will be created.
+//
+// This method should only be used from MongoDB 2.4 and on. For older
+// MongoDB releases, use the obsolete AddUser method instead.
+//
+// Relevant documentation:
+//
+//     http://docs.mongodb.org/manual/reference/user-privileges/
+//     http://docs.mongodb.org/manual/reference/privilege-documents/
+//
+func (db *Database) UpsertUser(user *User) error {
+	if user.Username == "" {
+		return fmt.Errorf("user has no Username")
+	}
+	if (user.Password != "" || user.PasswordHash != "") && user.UserSource != "" {
+		return fmt.Errorf("user has both Password/PasswordHash and UserSource set")
+	}
+	if len(user.OtherDBRoles) > 0 && db.Name != "admin" && db.Name != "$external" {
+		return fmt.Errorf("user with OtherDBRoles is only supported in the admin or $external databases")
+	}
+
+	// Attempt to run this using 2.6+ commands.
+	rundb := db
+	if user.UserSource != "" {
+		// Compatibility logic for the userSource field of MongoDB <= 2.4.X
+		rundb = db.Session.DB(user.UserSource)
+	}
+	err := rundb.runUserCmd("updateUser", user)
+	// retry with createUser when isAuthError in order to enable the "localhost exception"
+	if isNotFound(err) || isAuthError(err) {
+		return rundb.runUserCmd("createUser", user)
+	}
+	if !isNoCmd(err) {
+		return err
+	}
+
+	// Command does not exist. Fallback to pre-2.6 behavior.
+	var set, unset bson.D
+	if user.Password != "" {
+		psum := md5.New()
+		psum.Write([]byte(user.Username + ":mongo:" + user.Password))
+		set = append(set, bson.DocElem{"pwd", hex.EncodeToString(psum.Sum(nil))})
+		unset = append(unset, bson.DocElem{"userSource", 1})
+	} else if user.PasswordHash != "" {
+		set = append(set, bson.DocElem{"pwd", user.PasswordHash})
+		unset = append(unset, bson.DocElem{"userSource", 1})
+	}
+	if user.UserSource != "" {
+		set = append(set, bson.DocElem{"userSource", user.UserSource})
+		unset = append(unset, bson.DocElem{"pwd", 1})
+	}
+	if user.Roles != nil || user.OtherDBRoles != nil {
+		set = append(set, bson.DocElem{"roles", user.Roles})
+		if len(user.OtherDBRoles) > 0 {
+			set = append(set, bson.DocElem{"otherDBRoles", user.OtherDBRoles})
+		} else {
+			unset = append(unset, bson.DocElem{"otherDBRoles", 1})
+		}
+	}
+	users := db.C("system.users")
+	err = users.Update(bson.D{{"user", user.Username}}, bson.D{{"$unset", unset}, {"$set", set}})
+	if err == ErrNotFound {
+		set = append(set, bson.DocElem{"user", user.Username})
+		if user.Roles == nil && user.OtherDBRoles == nil {
+			// Roles must be sent, as it's the way MongoDB distinguishes
+			// old-style documents from new-style documents in pre-2.6.
+			set = append(set, bson.DocElem{"roles", user.Roles})
+		}
+		err = users.Insert(set)
+	}
+	return err
+}
+
+func isNoCmd(err error) bool {
+	e, ok := err.(*QueryError)
+	return ok && (e.Code == 59 || e.Code == 13390 || strings.HasPrefix(e.Message, "no such cmd:"))
+}
+
+func isNotFound(err error) bool {
+	e, ok := err.(*QueryError)
+	return ok && e.Code == 11
+}
+
+func isAuthError(err error) bool {
+	e, ok := err.(*QueryError)
+	return ok && e.Code == 13
+}
+
+func (db *Database) runUserCmd(cmdName string, user *User) error {
+	cmd := make(bson.D, 0, 16)
+	cmd = append(cmd, bson.DocElem{cmdName, user.Username})
+	if user.Password != "" {
+		cmd = append(cmd, bson.DocElem{"pwd", user.Password})
+	}
+	var roles []interface{}
+	for _, role := range user.Roles {
+		roles = append(roles, role)
+	}
+	for db, dbroles := range user.OtherDBRoles {
+		for _, role := range dbroles {
+			roles = append(roles, bson.D{{"role", role}, {"db", db}})
+		}
+	}
+	if roles != nil || user.Roles != nil || cmdName == "createUser" {
+		cmd = append(cmd, bson.DocElem{"roles", roles})
+	}
+	err := db.Run(cmd, nil)
+	if !isNoCmd(err) && user.UserSource != "" && (user.UserSource != "$external" || db.Name != "$external") {
+		return fmt.Errorf("MongoDB 2.6+ does not support the UserSource setting")
+	}
+	return err
+}
+
+// AddUser creates or updates the authentication credentials of user within
+// the db database.
+//
+// WARNING: This method is obsolete and should only be used with MongoDB 2.2
+// or earlier. For MongoDB 2.4 and on, use UpsertUser instead.
+func (db *Database) AddUser(username, password string, readOnly bool) error {
+	// Try to emulate the old behavior on 2.6+
+	user := &User{Username: username, Password: password}
+	if db.Name == "admin" {
+		if readOnly {
+			user.Roles = []Role{RoleReadAny}
+		} else {
+			user.Roles = []Role{RoleReadWriteAny}
+		}
+	} else {
+		if readOnly {
+			user.Roles = []Role{RoleRead}
+		} else {
+			user.Roles = []Role{RoleReadWrite}
+		}
+	}
+	err := db.runUserCmd("updateUser", user)
+	if isNotFound(err) {
+		return db.runUserCmd("createUser", user)
+	}
+	if !isNoCmd(err) {
+		return err
+	}
+
+	// Command doesn't exist. Fallback to pre-2.6 behavior.
+	psum := md5.New()
+	psum.Write([]byte(username + ":mongo:" + password))
+	digest := hex.EncodeToString(psum.Sum(nil))
+	c := db.C("system.users")
+	_, err = c.Upsert(bson.M{"user": username}, bson.M{"$set": bson.M{"user": username, "pwd": digest, "readOnly": readOnly}})
+	return err
+}
+
+// RemoveUser removes the authentication credentials of user from the database.
+func (db *Database) RemoveUser(user string) error {
+	err := db.Run(bson.D{{"dropUser", user}}, nil)
+	if isNoCmd(err) {
+		users := db.C("system.users")
+		return users.Remove(bson.M{"user": user})
+	}
+	if isNotFound(err) {
+		return ErrNotFound
+	}
+	return err
+}
+
+type indexSpec struct {
+	Name, NS         string
+	Key              bson.D
+	Unique           bool    ",omitempty"
+	DropDups         bool    "dropDups,omitempty"
+	Background       bool    ",omitempty"
+	Sparse           bool    ",omitempty"
+	Bits, Min, Max   int     ",omitempty"
+	BucketSize       float64 "bucketSize,omitempty"
+	ExpireAfter      int     "expireAfterSeconds,omitempty"
+	Weights          bson.D  ",omitempty"
+	DefaultLanguage  string  "default_language,omitempty"
+	LanguageOverride string  "language_override,omitempty"
+}
+
+type Index struct {
+	Key        []string // Index key fields; prefix name with dash (-) for descending order
+	Unique     bool     // Prevent two documents from having the same index key
+	DropDups   bool     // Drop documents with the same index key as a previously indexed one
+	Background bool     // Build index in background and return immediately
+	Sparse     bool     // Only index documents containing the Key fields
+
+	// If ExpireAfter is defined the server will periodically delete
+	// documents with indexed time.Time older than the provided delta.
+	ExpireAfter time.Duration
+
+	// Name holds the stored index name. On creation this field is ignored and the index name
+	// is automatically computed by EnsureIndex based on the index key
+	Name string
+
+	// Properties for spatial indexes.
+	Bits, Min, Max int
+	BucketSize     float64
+
+	// Properties for text indexes.
+	DefaultLanguage  string
+	LanguageOverride string
+
+	// Weights defines the significance of provided fields relative to other
+	// fields in a text index. The score for a given word in a document is derived
+	// from the weighted sum of the frequency for each of the indexed fields in
+	// that document. The default field weight is 1.
+	Weights map[string]int
+}
+
+type indexKeyInfo struct {
+	name    string
+	key     bson.D
+	weights bson.D
+}
+
+func parseIndexKey(key []string) (*indexKeyInfo, error) {
+	var keyInfo indexKeyInfo
+	isText := false
+	var order interface{}
+	for _, field := range key {
+		raw := field
+		if keyInfo.name != "" {
+			keyInfo.name += "_"
+		}
+		var kind string
+		if field != "" {
+			if field[0] == '$' {
+				if c := strings.Index(field, ":"); c > 1 && c < len(field)-1 {
+					kind = field[1:c]
+					field = field[c+1:]
+					keyInfo.name += field + "_" + kind
+				} else {
+					field = "\x00"
+				}
+			}
+			switch field[0] {
+			case 0:
+				// Logic above failed. Reset and error.
+				field = ""
+			case '@':
+				order = "2d"
+				field = field[1:]
+				// The shell used to render this field as key_ instead of key_2d,
+				// and mgo followed suit. This has been fixed in recent server
+				// releases, and mgo followed as well.
+				keyInfo.name += field + "_2d"
+			case '-':
+				order = -1
+				field = field[1:]
+				keyInfo.name += field + "_-1"
+			case '+':
+				field = field[1:]
+				fallthrough
+			default:
+				if kind == "" {
+					order = 1
+					keyInfo.name += field + "_1"
+				} else {
+					order = kind
+				}
+			}
+		}
+		if field == "" || kind != "" && order != kind {
+			return nil, fmt.Errorf(`invalid index key: want "[$<kind>:][-]<field name>", got %q`, raw)
+		}
+		if kind == "text" {
+			if !isText {
+				keyInfo.key = append(keyInfo.key, bson.DocElem{"_fts", "text"}, bson.DocElem{"_ftsx", 1})
+				isText = true
+			}
+			keyInfo.weights = append(keyInfo.weights, bson.DocElem{field, 1})
+		} else {
+			keyInfo.key = append(keyInfo.key, bson.DocElem{field, order})
+		}
+	}
+	if keyInfo.name == "" {
+		return nil, errors.New("invalid index key: no fields provided")
+	}
+	return &keyInfo, nil
+}
+
+// EnsureIndexKey ensures an index with the given key exists, creating it
+// if necessary.
+//
+// This example:
+//
+//     err := collection.EnsureIndexKey("a", "b")
+//
+// Is equivalent to:
+//
+//     err := collection.EnsureIndex(mgo.Index{Key: []string{"a", "b"}})
+//
+// See the EnsureIndex method for more details.
+func (c *Collection) EnsureIndexKey(key ...string) error {
+	return c.EnsureIndex(Index{Key: key})
+}
+
+// EnsureIndex ensures an index with the given key exists, creating it with
+// the provided parameters if necessary. EnsureIndex does not modify a previously
+// existent index with a matching key. The old index must be dropped first instead.
+//
+// Once EnsureIndex returns successfully, following requests for the same index
+// will not contact the server unless Collection.DropIndex is used to drop the
+// same index, or Session.ResetIndexCache is called.
+//
+// For example:
+//
+//     index := Index{
+//         Key: []string{"lastname", "firstname"},
+//         Unique: true,
+//         DropDups: true,
+//         Background: true, // See notes.
+//         Sparse: true,
+//     }
+//     err := collection.EnsureIndex(index)
+//
+// The Key value determines which fields compose the index. The index ordering
+// will be ascending by default.  To obtain an index with a descending order,
+// the field name should be prefixed by a dash (e.g. []string{"-time"}). It can
+// also be optionally prefixed by an index kind, as in "$text:summary" or
+// "$2d:-point". The key string format is:
+//
+//     [$<kind>:][-]<field name>
+//
+// If the Unique field is true, the index must necessarily contain only a single
+// document per Key.  With DropDups set to true, documents with the same key
+// as a previously indexed one will be dropped rather than an error returned.
+//
+// If Background is true, other connections will be allowed to proceed using
+// the collection without the index while it's being built. Note that the
+// session executing EnsureIndex will be blocked for as long as it takes for
+// the index to be built.
+//
+// If Sparse is true, only documents containing the provided Key fields will be
+// included in the index.  When using a sparse index for sorting, only indexed
+// documents will be returned.
+//
+// If ExpireAfter is non-zero, the server will periodically scan the collection
+// and remove documents containing an indexed time.Time field with a value
+// older than ExpireAfter. See the documentation for details:
+//
+//     http://docs.mongodb.org/manual/tutorial/expire-data
+//
+// Other kinds of indexes are also supported through that API. Here is an example:
+//
+//     index := Index{
+//         Key: []string{"$2d:loc"},
+//         Bits: 26,
+//     }
+//     err := collection.EnsureIndex(index)
+//
+// The example above requests the creation of a "2d" index for the "loc" field.
+//
+// The 2D index bounds may be changed using the Min and Max attributes of the
+// Index value.  The default bound setting of (-180, 180) is suitable for
+// latitude/longitude pairs.
+//
+// The Bits parameter sets the precision of the 2D geohash values.  If not
+// provided, 26 bits are used, which is roughly equivalent to 1 foot of
+// precision for the default (-180, 180) index bounds.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Indexes
+//     http://www.mongodb.org/display/DOCS/Indexing+Advice+and+FAQ
+//     http://www.mongodb.org/display/DOCS/Indexing+as+a+Background+Operation
+//     http://www.mongodb.org/display/DOCS/Geospatial+Indexing
+//     http://www.mongodb.org/display/DOCS/Multikeys
+//
+func (c *Collection) EnsureIndex(index Index) error {
+	keyInfo, err := parseIndexKey(index.Key)
+	if err != nil {
+		return err
+	}
+
+	session := c.Database.Session
+	cacheKey := c.FullName + "\x00" + keyInfo.name
+	if session.cluster().HasCachedIndex(cacheKey) {
+		return nil
+	}
+
+	spec := indexSpec{
+		Name:             keyInfo.name,
+		NS:               c.FullName,
+		Key:              keyInfo.key,
+		Unique:           index.Unique,
+		DropDups:         index.DropDups,
+		Background:       index.Background,
+		Sparse:           index.Sparse,
+		Bits:             index.Bits,
+		Min:              index.Min,
+		Max:              index.Max,
+		BucketSize:       index.BucketSize,
+		ExpireAfter:      int(index.ExpireAfter / time.Second),
+		Weights:          keyInfo.weights,
+		DefaultLanguage:  index.DefaultLanguage,
+		LanguageOverride: index.LanguageOverride,
+	}
+
+NextField:
+	for name, weight := range index.Weights {
+		for i, elem := range spec.Weights {
+			if elem.Name == name {
+				spec.Weights[i].Value = weight
+				continue NextField
+			}
+		}
+		panic("weight provided for field that is not part of index key: " + name)
+	}
+
+	cloned := session.Clone()
+	defer cloned.Close()
+	cloned.SetMode(Strong, false)
+	cloned.EnsureSafe(&Safe{})
+	db := c.Database.With(cloned)
+
+	// Try with a command first.
+	err = db.Run(bson.D{{"createIndexes", c.Name}, {"indexes", []indexSpec{spec}}}, nil)
+	if isNoCmd(err) {
+		// Command not yet supported. Insert into the indexes collection instead.
+		err = db.C("system.indexes").Insert(&spec)
+	}
+	if err == nil {
+		session.cluster().CacheIndex(cacheKey, true)
+	}
+	return err
+}
+
+// DropIndex removes the index with key from the collection.
+//
+// The key value determines which fields compose the index. The index ordering
+// will be ascending by default.  To obtain an index with a descending order,
+// the field name should be prefixed by a dash (e.g. []string{"-time"}).
+//
+// For example:
+//
+//     err := collection.DropIndex("lastname", "firstname")
+//
+// See the EnsureIndex method for more details on indexes.
+func (c *Collection) DropIndex(key ...string) error {
+	keyInfo, err := parseIndexKey(key)
+	if err != nil {
+		return err
+	}
+
+	session := c.Database.Session
+	cacheKey := c.FullName + "\x00" + keyInfo.name
+	session.cluster().CacheIndex(cacheKey, false)
+
+	session = session.Clone()
+	defer session.Close()
+	session.SetMode(Strong, false)
+
+	db := c.Database.With(session)
+	result := struct {
+		ErrMsg string
+		Ok     bool
+	}{}
+	err = db.Run(bson.D{{"dropIndexes", c.Name}, {"index", keyInfo.name}}, &result)
+	if err != nil {
+		return err
+	}
+	if !result.Ok {
+		return errors.New(result.ErrMsg)
+	}
+	return nil
+}
+
+// Indexes returns a list of all indexes for the collection.
+//
+// For example, this snippet would drop all available indexes:
+//
+//   indexes, err := collection.Indexes()
+//   if err != nil {
+//       return err
+//   }
+//   for _, index := range indexes {
+//       err = collection.DropIndex(index.Key...)
+//       if err != nil {
+//           return err
+//       }
+//   }
+//
+// See the EnsureIndex method for more details on indexes.
+func (c *Collection) Indexes() (indexes []Index, err error) {
+	// Clone session and set it to Monotonic mode so that the server
+	// used for the query may be safely obtained afterwards, if
+	// necessary for iteration when a cursor is received.
+	session := c.Database.Session
+	cloned := session.Clone()
+	cloned.SetMode(Monotonic, false)
+	defer cloned.Close()
+
+	batchSize := int(cloned.queryConfig.op.limit)
+
+	// Try with a command.
+	var result struct {
+		Indexes []bson.Raw
+
+		Cursor struct {
+			FirstBatch []bson.Raw "firstBatch"
+			NS         string
+			Id         int64
+		}
+	}
+	var iter *Iter
+	err = c.Database.With(cloned).Run(bson.D{{"listIndexes", c.Name}, {"cursor", bson.D{{"batchSize", batchSize}}}}, &result)
+	if err == nil {
+		firstBatch := result.Indexes
+		if firstBatch == nil {
+			firstBatch = result.Cursor.FirstBatch
+		}
+		ns := strings.SplitN(result.Cursor.NS, ".", 2)
+		if len(ns) < 2 {
+			iter = c.With(cloned).NewIter(nil, firstBatch, result.Cursor.Id, nil)
+		} else {
+			iter = cloned.DB(ns[0]).C(ns[1]).NewIter(nil, firstBatch, result.Cursor.Id, nil)
+		}
+	} else if isNoCmd(err) {
+		// Command not yet supported. Query the database instead.
+		iter = c.Database.C("system.indexes").Find(bson.M{"ns": c.FullName}).Iter()
+	} else {
+		return nil, err
+	}
+
+	var spec indexSpec
+	for iter.Next(&spec) {
+		indexes = append(indexes, indexFromSpec(spec))
+	}
+	if err = iter.Close(); err != nil {
+		return nil, err
+	}
+	sort.Sort(indexSlice(indexes))
+	return indexes, nil
+}
+
+func indexFromSpec(spec indexSpec) Index {
+	return Index{
+		Name:        spec.Name,
+		Key:         simpleIndexKey(spec.Key),
+		Unique:      spec.Unique,
+		DropDups:    spec.DropDups,
+		Background:  spec.Background,
+		Sparse:      spec.Sparse,
+		ExpireAfter: time.Duration(spec.ExpireAfter) * time.Second,
+	}
+}
+
+type indexSlice []Index
+
+func (idxs indexSlice) Len() int           { return len(idxs) }
+func (idxs indexSlice) Less(i, j int) bool { return idxs[i].Name < idxs[j].Name }
+func (idxs indexSlice) Swap(i, j int)      { idxs[i], idxs[j] = idxs[j], idxs[i] }
+
+func simpleIndexKey(realKey bson.D) (key []string) {
+	for i := range realKey {
+		field := realKey[i].Name
+		vi, ok := realKey[i].Value.(int)
+		if !ok {
+			vf, _ := realKey[i].Value.(float64)
+			vi = int(vf)
+		}
+		if vi == 1 {
+			key = append(key, field)
+			continue
+		}
+		if vi == -1 {
+			key = append(key, "-"+field)
+			continue
+		}
+		if vs, ok := realKey[i].Value.(string); ok {
+			key = append(key, "$"+vs+":"+field)
+			continue
+		}
+		panic("Got unknown index key type for field " + field)
+	}
+	return
+}
+
+// ResetIndexCache() clears the cache of previously ensured indexes.
+// Following requests to EnsureIndex will contact the server.
+func (s *Session) ResetIndexCache() {
+	s.cluster().ResetIndexCache()
+}
+
+// New creates a new session with the same parameters as the original
+// session, including consistency, batch size, prefetching, safety mode,
+// etc. The returned session will use sockets from the pool, so there's
+// a chance that writes just performed in another session may not yet
+// be visible.
+//
+// Login information from the original session will not be copied over
+// into the new session unless it was provided through the initial URL
+// for the Dial function.
+//
+// See the Copy and Clone methods.
+//
+func (s *Session) New() *Session {
+	s.m.Lock()
+	scopy := copySession(s, false)
+	s.m.Unlock()
+	scopy.Refresh()
+	return scopy
+}
+
+// Copy works just like New, but preserves the exact authentication
+// information from the original session.
+func (s *Session) Copy() *Session {
+	s.m.Lock()
+	scopy := copySession(s, true)
+	s.m.Unlock()
+	scopy.Refresh()
+	return scopy
+}
+
+// Clone works just like Copy, but also reuses the same socket as the original
+// session, in case it had already reserved one due to its consistency
+// guarantees.  This behavior ensures that writes performed in the old session
+// are necessarily observed when using the new session, as long as it was a
+// strong or monotonic session.  That said, it also means that long operations
+// may cause other goroutines using the original session to wait.
+func (s *Session) Clone() *Session {
+	s.m.Lock()
+	scopy := copySession(s, true)
+	s.m.Unlock()
+	return scopy
+}
+
+// Close terminates the session.  It's a runtime error to use a session
+// after it has been closed.
+func (s *Session) Close() {
+	s.m.Lock()
+	if s.cluster_ != nil {
+		debugf("Closing session %p", s)
+		s.unsetSocket()
+		s.cluster_.Release()
+		s.cluster_ = nil
+	}
+	s.m.Unlock()
+}
+
+func (s *Session) cluster() *mongoCluster {
+	if s.cluster_ == nil {
+		panic("Session already closed")
+	}
+	return s.cluster_
+}
+
+// Refresh puts back any reserved sockets in use and restarts the consistency
+// guarantees according to the current consistency setting for the session.
+func (s *Session) Refresh() {
+	s.m.Lock()
+	s.slaveOk = s.consistency != Strong
+	s.unsetSocket()
+	s.m.Unlock()
+}
+
+// SetMode changes the consistency mode for the session.
+//
+// In the Strong consistency mode reads and writes will always be made to
+// the primary server using a unique connection so that reads and writes are
+// fully consistent, ordered, and observing the most up-to-date data.
+// This offers the least benefits in terms of distributing load, but the
+// most guarantees.  See also Monotonic and Eventual.
+//
+// In the Monotonic consistency mode reads may not be entirely up-to-date,
+// but they will always see the history of changes moving forward, the data
+// read will be consistent across sequential queries in the same session,
+// and modifications made within the session will be observed in following
+// queries (read-your-writes).
+//
+// In practice, the Monotonic mode is obtained by performing initial reads
+// on a unique connection to an arbitrary secondary, if one is available,
+// and once the first write happens, the session connection is switched over
+// to the primary server.  This manages to distribute some of the reading
+// load with secondaries, while maintaining some useful guarantees.
+//
+// In the Eventual consistency mode reads will be made to any secondary in the
+// cluster, if one is available, and sequential reads will not necessarily
+// be made with the same connection.  This means that data may be observed
+// out of order.  Writes will of course be issued to the primary, but
+// independent writes in the same Eventual session may also be made with
+// independent connections, so there are also no guarantees in terms of
+// write ordering (no read-your-writes guarantees either).
+//
+// The Eventual mode is the fastest and most resource-friendly, but is
+// also the one offering the least guarantees about ordering of the data
+// read and written.
+//
+// If refresh is true, in addition to ensuring the session is in the given
+// consistency mode, the consistency guarantees will also be reset (e.g.
+// a Monotonic session will be allowed to read from secondaries again).
+// This is equivalent to calling the Refresh function.
+//
+// Shifting between Monotonic and Strong modes will keep a previously
+// reserved connection for the session unless refresh is true or the
+// connection is unsuitable (to a secondary server in a Strong session).
+func (s *Session) SetMode(consistency mode, refresh bool) {
+	s.m.Lock()
+	debugf("Session %p: setting mode %d with refresh=%v (master=%p, slave=%p)", s, consistency, refresh, s.masterSocket, s.slaveSocket)
+	s.consistency = consistency
+	if refresh {
+		s.slaveOk = s.consistency != Strong
+		s.unsetSocket()
+	} else if s.consistency == Strong {
+		s.slaveOk = false
+	} else if s.masterSocket == nil {
+		s.slaveOk = true
+	}
+	s.m.Unlock()
+}
+
+// Mode returns the current consistency mode for the session.
+func (s *Session) Mode() mode {
+	s.m.RLock()
+	mode := s.consistency
+	s.m.RUnlock()
+	return mode
+}
+
+// SetSyncTimeout sets the amount of time an operation with this session
+// will wait before returning an error in case a connection to a usable
+// server can't be established. Set it to zero to wait forever. The
+// default value is 7 seconds.
+func (s *Session) SetSyncTimeout(d time.Duration) {
+	s.m.Lock()
+	s.syncTimeout = d
+	s.m.Unlock()
+}
+
+// SetSocketTimeout sets the amount of time to wait for a non-responding
+// socket to the database before it is forcefully closed.
+func (s *Session) SetSocketTimeout(d time.Duration) {
+	s.m.Lock()
+	s.sockTimeout = d
+	if s.masterSocket != nil {
+		s.masterSocket.SetTimeout(d)
+	}
+	if s.slaveSocket != nil {
+		s.slaveSocket.SetTimeout(d)
+	}
+	s.m.Unlock()
+}
+
+// SetCursorTimeout changes the standard timeout period that the server
+// enforces on created cursors. The only supported value right now is
+// 0, which disables the timeout. The standard server timeout is 10 minutes.
+func (s *Session) SetCursorTimeout(d time.Duration) {
+	s.m.Lock()
+	if d == 0 {
+		s.queryConfig.op.flags |= flagNoCursorTimeout
+	} else {
+		panic("SetCursorTimeout: only 0 (disable timeout) supported for now")
+	}
+	s.m.Unlock()
+}
+
+// SetPoolLimit sets the maximum number of sockets in use in a single server
+// before this session will block waiting for a socket to be available.
+// The default limit is 4096.
+//
+// This limit must be set to cover more than any expected workload of the
+// application. It is a bad practice and an unsupported use case to use the
+// database driver to define the concurrency limit of an application. Prevent
+// such concurrency "at the door" instead, by properly restricting the amount
+// of used resources and number of goroutines before they are created.
+func (s *Session) SetPoolLimit(limit int) {
+	s.m.Lock()
+	s.poolLimit = limit
+	s.m.Unlock()
+}
+
+// SetBatch sets the default batch size used when fetching documents from the
+// database. It's possible to change this setting on a per-query basis as
+// well, using the Query.Batch method.
+//
+// The default batch size is defined by the database itself.  As of this
+// writing, MongoDB will use an initial size of min(100 docs, 4MB) on the
+// first batch, and 4MB on remaining ones.
+func (s *Session) SetBatch(n int) {
+	if n == 1 {
+		// Server interprets 1 as -1 and closes the cursor (!?)
+		n = 2
+	}
+	s.m.Lock()
+	s.queryConfig.op.limit = int32(n)
+	s.m.Unlock()
+}
+
+// SetPrefetch sets the default point at which the next batch of results will be
+// requested.  When there are p*batch_size remaining documents cached in an
+// Iter, the next batch will be requested in background. For instance, when
+// using this:
+//
+//     session.SetBatch(200)
+//     session.SetPrefetch(0.25)
+//
+// and there are only 50 documents cached in the Iter to be processed, the
+// next batch of 200 will be requested. It's possible to change this setting on
+// a per-query basis as well, using the Prefetch method of Query.
+//
+// The default prefetch value is 0.25.
+func (s *Session) SetPrefetch(p float64) {
+	s.m.Lock()
+	s.queryConfig.prefetch = p
+	s.m.Unlock()
+}
+
+// See SetSafe for details on the Safe type.
+type Safe struct {
+	W        int    // Min # of servers to ack before success
+	WMode    string // Write mode for MongoDB 2.0+ (e.g. "majority")
+	WTimeout int    // Milliseconds to wait for W before timing out
+	FSync    bool   // Should servers sync to disk before returning success
+	J        bool   // Wait for next group commit if journaling; no effect otherwise
+}
+
+// Safe returns the current safety mode for the session.
+func (s *Session) Safe() (safe *Safe) {
+	s.m.Lock()
+	defer s.m.Unlock()
+	if s.safeOp != nil {
+		cmd := s.safeOp.query.(*getLastError)
+		safe = &Safe{WTimeout: cmd.WTimeout, FSync: cmd.FSync, J: cmd.J}
+		switch w := cmd.W.(type) {
+		case string:
+			safe.WMode = w
+		case int:
+			safe.W = w
+		}
+	}
+	return
+}
+
+// SetSafe changes the session safety mode.
+//
+// If the safe parameter is nil, the session is put in unsafe mode, and writes
+// become fire-and-forget, without error checking.  The unsafe mode is faster
+// since operations won't hold on waiting for a confirmation.
+//
+// If the safe parameter is not nil, any changing query (insert, update, ...)
+// will be followed by a getLastError command with the specified parameters,
+// to ensure the request was correctly processed.
+//
+// The safe.W parameter determines how many servers should confirm a write
+// before the operation is considered successful.  If set to 0 or 1, the
+// command will return as soon as the primary is done with the request.
+// If safe.WTimeout is greater than zero, it determines how many milliseconds
+// to wait for the safe.W servers to respond before returning an error.
+//
+// Starting with MongoDB 2.0.0 the safe.WMode parameter can be used instead
+// of W to request for richer semantics. If set to "majority" the server will
+// wait for a majority of members from the replica set to respond before
+// returning. Custom modes may also be defined within the server to create
+// very detailed placement schemas. See the data awareness documentation in
+// the links below for more details (note that MongoDB internally reuses the
+// "w" field name for WMode).
+//
+// If safe.FSync is true and journaling is disabled, the servers will be
+// forced to sync all files to disk immediately before returning. If the
+// same option is true but journaling is enabled, the server will instead
+// await for the next group commit before returning.
+//
+// Since MongoDB 2.0.0, the safe.J option can also be used instead of FSync
+// to force the server to wait for a group commit in case journaling is
+// enabled. The option has no effect if the server has journaling disabled.
+//
+// For example, the following statement will make the session check for
+// errors, without imposing further constraints:
+//
+//     session.SetSafe(&mgo.Safe{})
+//
+// The following statement will force the server to wait for a majority of
+// members of a replica set to return (MongoDB 2.0+ only):
+//
+//     session.SetSafe(&mgo.Safe{WMode: "majority"})
+//
+// The following statement, on the other hand, ensures that at least two
+// servers have flushed the change to disk before confirming the success
+// of operations:
+//
+//     session.EnsureSafe(&mgo.Safe{W: 2, FSync: true})
+//
+// The following statement, on the other hand, disables the verification
+// of errors entirely:
+//
+//     session.SetSafe(nil)
+//
+// See also the EnsureSafe method.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/getLastError+Command
+//     http://www.mongodb.org/display/DOCS/Verifying+Propagation+of+Writes+with+getLastError
+//     http://www.mongodb.org/display/DOCS/Data+Center+Awareness
+//
+func (s *Session) SetSafe(safe *Safe) {
+	s.m.Lock()
+	s.safeOp = nil
+	s.ensureSafe(safe)
+	s.m.Unlock()
+}
+
+// EnsureSafe compares the provided safety parameters with the ones
+// currently in use by the session and picks the most conservative
+// choice for each setting.
+//
+// That is:
+//
+//     - safe.WMode is always used if set.
+//     - safe.W is used if larger than the current W and WMode is empty.
+//     - safe.FSync is always used if true.
+//     - safe.J is used if FSync is false.
+//     - safe.WTimeout is used if set and smaller than the current WTimeout.
+//
+// For example, the following statement will ensure the session is
+// at least checking for errors, without enforcing further constraints.
+// If a more conservative SetSafe or EnsureSafe call was previously done,
+// the following call will be ignored.
+//
+//     session.EnsureSafe(&mgo.Safe{})
+//
+// See also the SetSafe method for details on what each option means.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/getLastError+Command
+//     http://www.mongodb.org/display/DOCS/Verifying+Propagation+of+Writes+with+getLastError
+//     http://www.mongodb.org/display/DOCS/Data+Center+Awareness
+//
+func (s *Session) EnsureSafe(safe *Safe) {
+	s.m.Lock()
+	s.ensureSafe(safe)
+	s.m.Unlock()
+}
+
+func (s *Session) ensureSafe(safe *Safe) {
+	if safe == nil {
+		return
+	}
+
+	var w interface{}
+	if safe.WMode != "" {
+		w = safe.WMode
+	} else if safe.W > 0 {
+		w = safe.W
+	}
+
+	var cmd getLastError
+	if s.safeOp == nil {
+		cmd = getLastError{1, w, safe.WTimeout, safe.FSync, safe.J}
+	} else {
+		// Copy.  We don't want to mutate the existing query.
+		cmd = *(s.safeOp.query.(*getLastError))
+		if cmd.W == nil {
+			cmd.W = w
+		} else if safe.WMode != "" {
+			cmd.W = safe.WMode
+		} else if i, ok := cmd.W.(int); ok && safe.W > i {
+			cmd.W = safe.W
+		}
+		if safe.WTimeout > 0 && safe.WTimeout < cmd.WTimeout {
+			cmd.WTimeout = safe.WTimeout
+		}
+		if safe.FSync {
+			cmd.FSync = true
+			cmd.J = false
+		} else if safe.J && !cmd.FSync {
+			cmd.J = true
+		}
+	}
+	s.safeOp = &queryOp{
+		query:      &cmd,
+		collection: "admin.$cmd",
+		limit:      -1,
+	}
+}
+
+// Run issues the provided command on the "admin" database and
+// and unmarshals its result in the respective argument. The cmd
+// argument may be either a string with the command name itself, in
+// which case an empty document of the form bson.M{cmd: 1} will be used,
+// or it may be a full command document.
+//
+// Note that MongoDB considers the first marshalled key as the command
+// name, so when providing a command with options, it's important to
+// use an ordering-preserving document, such as a struct value or an
+// instance of bson.D.  For instance:
+//
+//     db.Run(bson.D{{"create", "mycollection"}, {"size", 1024}})
+//
+// For commands on arbitrary databases, see the Run method in
+// the Database type.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Commands
+//     http://www.mongodb.org/display/DOCS/List+of+Database+CommandSkips
+//
+func (s *Session) Run(cmd interface{}, result interface{}) error {
+	return s.DB("admin").Run(cmd, result)
+}
+
+// SelectServers restricts communication to servers configured with the
+// given tags. For example, the following statement restricts servers
+// used for reading operations to those with both tag "disk" set to
+// "ssd" and tag "rack" set to 1:
+//
+//     session.SelectSlaves(bson.D{{"disk", "ssd"}, {"rack", 1}})
+//
+// Multiple sets of tags may be provided, in which case the used server
+// must match all tags within any one set.
+//
+// If a connection was previously assigned to the session due to the
+// current session mode (see Session.SetMode), the tag selection will
+// only be enforced after the session is refreshed.
+//
+// Relevant documentation:
+//
+//     http://docs.mongodb.org/manual/tutorial/configure-replica-set-tag-sets
+//
+func (s *Session) SelectServers(tags ...bson.D) {
+	s.m.Lock()
+	s.queryConfig.op.serverTags = tags
+	s.m.Unlock()
+}
+
+// Ping runs a trivial ping command just to get in touch with the server.
+func (s *Session) Ping() error {
+	return s.Run("ping", nil)
+}
+
+// Fsync flushes in-memory writes to disk on the server the session
+// is established with. If async is true, the call returns immediately,
+// otherwise it returns after the flush has been made.
+func (s *Session) Fsync(async bool) error {
+	return s.Run(bson.D{{"fsync", 1}, {"async", async}}, nil)
+}
+
+// FsyncLock locks all writes in the specific server the session is
+// established with and returns. Any writes attempted to the server
+// after it is successfully locked will block until FsyncUnlock is
+// called for the same server.
+//
+// This method works on secondaries as well, preventing the oplog from
+// being flushed while the server is locked, but since only the server
+// connected to is locked, for locking specific secondaries it may be
+// necessary to establish a connection directly to the secondary (see
+// Dial's connect=direct option).
+//
+// As an important caveat, note that once a write is attempted and
+// blocks, follow up reads will block as well due to the way the
+// lock is internally implemented in the server. More details at:
+//
+//     https://jira.mongodb.org/browse/SERVER-4243
+//
+// FsyncLock is often used for performing consistent backups of
+// the database files on disk.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/fsync+Command
+//     http://www.mongodb.org/display/DOCS/Backups
+//
+func (s *Session) FsyncLock() error {
+	return s.Run(bson.D{{"fsync", 1}, {"lock", true}}, nil)
+}
+
+// FsyncUnlock releases the server for writes. See FsyncLock for details.
+func (s *Session) FsyncUnlock() error {
+	return s.DB("admin").C("$cmd.sys.unlock").Find(nil).One(nil) // WTF?
+}
+
+// Find prepares a query using the provided document.  The document may be a
+// map or a struct value capable of being marshalled with bson.  The map
+// may be a generic one using interface{} for its key and/or values, such as
+// bson.M, or it may be a properly typed map.  Providing nil as the document
+// is equivalent to providing an empty document such as bson.M{}.
+//
+// Further details of the query may be tweaked using the resulting Query value,
+// and then executed to retrieve results using methods such as One, For,
+// Iter, or Tail.
+//
+// In case the resulting document includes a field named $err or errmsg, which
+// are standard ways for MongoDB to return query errors, the returned err will
+// be set to a *QueryError value including the Err message and the Code.  In
+// those cases, the result argument is still unmarshalled into with the
+// received document so that any other custom values may be obtained if
+// desired.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Querying
+//     http://www.mongodb.org/display/DOCS/Advanced+Queries
+//
+func (c *Collection) Find(query interface{}) *Query {
+	session := c.Database.Session
+	session.m.RLock()
+	q := &Query{session: session, query: session.queryConfig}
+	session.m.RUnlock()
+	q.op.query = query
+	q.op.collection = c.FullName
+	return q
+}
+
+type repairCmd struct {
+	RepairCursor string           `bson:"repairCursor"`
+	Cursor       *repairCmdCursor ",omitempty"
+}
+
+type repairCmdCursor struct {
+	BatchSize int `bson:"batchSize,omitempty"`
+}
+
+// Repair returns an iterator that goes over all recovered documents in the
+// collection, in a best-effort manner. This is most useful when there are
+// damaged data files. Multiple copies of the same document may be returned
+// by the iterator.
+//
+// Repair is supported in MongoDB 2.7.8 and later.
+func (c *Collection) Repair() *Iter {
+	// Clone session and set it to Monotonic mode so that the server
+	// used for the query may be safely obtained afterwards, if
+	// necessary for iteration when a cursor is received.
+	session := c.Database.Session
+	cloned := session.Clone()
+	cloned.SetMode(Monotonic, false)
+	defer cloned.Close()
+
+	batchSize := int(cloned.queryConfig.op.limit)
+
+	var result struct {
+		Cursor struct {
+			FirstBatch []bson.Raw "firstBatch"
+			Id         int64
+		}
+	}
+
+	cmd := repairCmd{
+		RepairCursor: c.Name,
+		Cursor:       &repairCmdCursor{batchSize},
+	}
+
+	clonedc := c.With(cloned)
+	err := clonedc.Database.Run(cmd, &result)
+	return clonedc.NewIter(session, result.Cursor.FirstBatch, result.Cursor.Id, err)
+}
+
+// FindId is a convenience helper equivalent to:
+//
+//     query := collection.Find(bson.M{"_id": id})
+//
+// See the Find method for more details.
+func (c *Collection) FindId(id interface{}) *Query {
+	return c.Find(bson.D{{"_id", id}})
+}
+
+type Pipe struct {
+	session    *Session
+	collection *Collection
+	pipeline   interface{}
+	allowDisk  bool
+	batchSize  int
+}
+
+type pipeCmd struct {
+	Aggregate string
+	Pipeline  interface{}
+	Cursor    *pipeCmdCursor ",omitempty"
+	Explain   bool           ",omitempty"
+	AllowDisk bool           "allowDiskUse,omitempty"
+}
+
+type pipeCmdCursor struct {
+	BatchSize int `bson:"batchSize,omitempty"`
+}
+
+// Pipe prepares a pipeline to aggregate. The pipeline document
+// must be a slice built in terms of the aggregation framework language.
+//
+// For example:
+//
+//     pipe := collection.Pipe([]bson.M{{"$match": bson.M{"name": "Otavio"}}})
+//     iter := pipe.Iter()
+//
+// Relevant documentation:
+//
+//     http://docs.mongodb.org/manual/reference/aggregation
+//     http://docs.mongodb.org/manual/applications/aggregation
+//     http://docs.mongodb.org/manual/tutorial/aggregation-examples
+//
+func (c *Collection) Pipe(pipeline interface{}) *Pipe {
+	session := c.Database.Session
+	session.m.RLock()
+	batchSize := int(session.queryConfig.op.limit)
+	session.m.RUnlock()
+	return &Pipe{
+		session:    session,
+		collection: c,
+		pipeline:   pipeline,
+		batchSize:  batchSize,
+	}
+}
+
+// Iter executes the pipeline and returns an iterator capable of going
+// over all the generated results.
+func (p *Pipe) Iter() *Iter {
+	// Clone session and set it to Monotonic mode so that the server
+	// used for the query may be safely obtained afterwards, if
+	// necessary for iteration when a cursor is received.
+	cloned := p.session.Clone()
+	cloned.SetMode(Monotonic, false)
+	defer cloned.Close()
+	c := p.collection.With(cloned)
+
+	var result struct {
+		// 2.4, no cursors.
+		Result []bson.Raw
+
+		// 2.6+, with cursors.
+		Cursor struct {
+			FirstBatch []bson.Raw "firstBatch"
+			Id         int64
+		}
+	}
+
+	cmd := pipeCmd{
+		Aggregate: c.Name,
+		Pipeline:  p.pipeline,
+		AllowDisk: p.allowDisk,
+		Cursor:    &pipeCmdCursor{p.batchSize},
+	}
+	err := c.Database.Run(cmd, &result)
+	if e, ok := err.(*QueryError); ok && e.Message == `unrecognized field "cursor` {
+		cmd.Cursor = nil
+		cmd.AllowDisk = false
+		err = c.Database.Run(cmd, &result)
+	}
+	firstBatch := result.Result
+	if firstBatch == nil {
+		firstBatch = result.Cursor.FirstBatch
+	}
+	return c.NewIter(p.session, firstBatch, result.Cursor.Id, err)
+}
+
+// NewIter returns a newly created iterator with the provided parameters.
+// Using this method is not recommended unless the desired functionality
+// is not yet exposed via a more convenient interface (Find, Pipe, etc).
+//
+// The optional session parameter associates the lifetime of the returned
+// iterator to an arbitrary session. If nil, the iterator will be bound to
+// c's session.
+//
+// Documents in firstBatch will be individually provided by the returned
+// iterator before documents from cursorId are made available. If cursorId
+// is zero, only the documents in firstBatch are provided.
+//
+// If err is not nil, the iterator's Err method will report it after
+// exhausting documents in firstBatch.
+//
+// NewIter must be called right after the cursor id is obtained, and must not
+// be called on a collection in Eventual mode, because the cursor id is
+// associated with the specific server that returned it. The provided session
+// parameter may be in any mode or state, though.
+//
+func (c *Collection) NewIter(session *Session, firstBatch []bson.Raw, cursorId int64, err error) *Iter {
+	var server *mongoServer
+	csession := c.Database.Session
+	csession.m.RLock()
+	socket := csession.masterSocket
+	if socket == nil {
+		socket = csession.slaveSocket
+	}
+	if socket != nil {
+		server = socket.Server()
+	}
+	csession.m.RUnlock()
+
+	if server == nil {
+		if csession.Mode() == Eventual {
+			panic("Collection.NewIter called in Eventual mode")
+		}
+		if err == nil {
+			err = errors.New("server not available")
+		}
+	}
+
+	if session == nil {
+		session = csession
+	}
+
+	iter := &Iter{
+		session: session,
+		server:  server,
+		timeout: -1,
+		err:     err,
+	}
+	iter.gotReply.L = &iter.m
+	for _, doc := range firstBatch {
+		iter.docData.Push(doc.Data)
+	}
+	if cursorId != 0 {
+		iter.op.cursorId = cursorId
+		iter.op.collection = c.FullName
+		iter.op.replyFunc = iter.replyFunc()
+	}
+	return iter
+}
+
+// All works like Iter.All.
+func (p *Pipe) All(result interface{}) error {
+	return p.Iter().All(result)
+}
+
+// One executes the pipeline and unmarshals the first item from the
+// result set into the result parameter.
+// It returns ErrNotFound if no items are generated by the pipeline.
+func (p *Pipe) One(result interface{}) error {
+	iter := p.Iter()
+	if iter.Next(result) {
+		return nil
+	}
+	if err := iter.Err(); err != nil {
+		return err
+	}
+	return ErrNotFound
+}
+
+// Explain returns a number of details about how the MongoDB server would
+// execute the requested pipeline, such as the number of objects examined,
+// the number of times the read lock was yielded to allow writes to go in,
+// and so on.
+//
+// For example:
+//
+//     var m bson.M
+//     err := collection.Pipe(pipeline).Explain(&m)
+//     if err == nil {
+//         fmt.Printf("Explain: %#v\n", m)
+//     }
+//
+func (p *Pipe) Explain(result interface{}) error {
+	c := p.collection
+	cmd := pipeCmd{
+		Aggregate: c.Name,
+		Pipeline:  p.pipeline,
+		AllowDisk: p.allowDisk,
+		Explain:   true,
+	}
+	return c.Database.Run(cmd, result)
+}
+
+// AllowDiskUse enables writing to the "<dbpath>/_tmp" server directory so
+// that aggregation pipelines do not have to be held entirely in memory.
+func (p *Pipe) AllowDiskUse() *Pipe {
+	p.allowDisk = true
+	return p
+}
+
+// Batch sets the batch size used when fetching documents from the database.
+// It's possible to change this setting on a per-session basis as well, using
+// the Batch method of Session.
+//
+// The default batch size is defined by the database server.
+func (p *Pipe) Batch(n int) *Pipe {
+	p.batchSize = n
+	return p
+}
+
+type LastError struct {
+	Err             string
+	Code, N, Waited int
+	FSyncFiles      int `bson:"fsyncFiles"`
+	WTimeout        bool
+	UpdatedExisting bool        `bson:"updatedExisting"`
+	UpsertedId      interface{} `bson:"upserted"`
+}
+
+func (err *LastError) Error() string {
+	return err.Err
+}
+
+type queryError struct {
+	Err           string "$err"
+	ErrMsg        string
+	Assertion     string
+	Code          int
+	AssertionCode int        "assertionCode"
+	LastError     *LastError "lastErrorObject"
+}
+
+type QueryError struct {
+	Code      int
+	Message   string
+	Assertion bool
+}
+
+func (err *QueryError) Error() string {
+	return err.Message
+}
+
+// IsDup returns whether err informs of a duplicate key error because
+// a primary key index or a secondary unique index already has an entry
+// with the given value.
+func IsDup(err error) bool {
+	// Besides being handy, helps with MongoDB bugs SERVER-7164 and SERVER-11493.
+	// What follows makes me sad. Hopefully conventions will be more clear over time.
+	switch e := err.(type) {
+	case *LastError:
+		return e.Code == 11000 || e.Code == 11001 || e.Code == 12582 || e.Code == 16460 && strings.Contains(e.Err, " E11000 ")
+	case *QueryError:
+		return e.Code == 11000 || e.Code == 11001 || e.Code == 12582
+	}
+	return false
+}
+
+// Insert inserts one or more documents in the respective collection.  In
+// case the session is in safe mode (see the SetSafe method) and an error
+// happens while inserting the provided documents, the returned error will
+// be of type *LastError.
+func (c *Collection) Insert(docs ...interface{}) error {
+	_, err := c.writeQuery(&insertOp{c.FullName, docs, 0})
+	return err
+}
+
+// Update finds a single document matching the provided selector document
+// and modifies it according to the update document.
+// If the session is in safe mode (see SetSafe) a ErrNotFound error is
+// returned if a document isn't found, or a value of type *LastError
+// when some other error is detected.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Updating
+//     http://www.mongodb.org/display/DOCS/Atomic+Operations
+//
+func (c *Collection) Update(selector interface{}, update interface{}) error {
+	lerr, err := c.writeQuery(&updateOp{c.FullName, selector, update, 0})
+	if err == nil && lerr != nil && !lerr.UpdatedExisting {
+		return ErrNotFound
+	}
+	return err
+}
+
+// UpdateId is a convenience helper equivalent to:
+//
+//     err := collection.Update(bson.M{"_id": id}, update)
+//
+// See the Update method for more details.
+func (c *Collection) UpdateId(id interface{}, update interface{}) error {
+	return c.Update(bson.D{{"_id", id}}, update)
+}
+
+// ChangeInfo holds details about the outcome of an update operation.
+type ChangeInfo struct {
+	Updated    int         // Number of existing documents updated
+	Removed    int         // Number of documents removed
+	UpsertedId interface{} // Upserted _id field, when not explicitly provided
+}
+
+// UpdateAll finds all documents matching the provided selector document
+// and modifies them according to the update document.
+// If the session is in safe mode (see SetSafe) details of the executed
+// operation are returned in info or an error of type *LastError when
+// some problem is detected. It is not an error for the update to not be
+// applied on any documents because the selector doesn't match.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Updating
+//     http://www.mongodb.org/display/DOCS/Atomic+Operations
+//
+func (c *Collection) UpdateAll(selector interface{}, update interface{}) (info *ChangeInfo, err error) {
+	lerr, err := c.writeQuery(&updateOp{c.FullName, selector, update, 2})
+	if err == nil && lerr != nil {
+		info = &ChangeInfo{Updated: lerr.N}
+	}
+	return info, err
+}
+
+// Upsert finds a single document matching the provided selector document
+// and modifies it according to the update document.  If no document matching
+// the selector is found, the update document is applied to the selector
+// document and the result is inserted in the collection.
+// If the session is in safe mode (see SetSafe) details of the executed
+// operation are returned in info, or an error of type *LastError when
+// some problem is detected.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Updating
+//     http://www.mongodb.org/display/DOCS/Atomic+Operations
+//
+func (c *Collection) Upsert(selector interface{}, update interface{}) (info *ChangeInfo, err error) {
+	lerr, err := c.writeQuery(&updateOp{c.FullName, selector, update, 1})
+	if err == nil && lerr != nil {
+		info = &ChangeInfo{}
+		if lerr.UpdatedExisting {
+			info.Updated = lerr.N
+		} else {
+			info.UpsertedId = lerr.UpsertedId
+		}
+	}
+	return info, err
+}
+
+// UpsertId is a convenience helper equivalent to:
+//
+//     info, err := collection.Upsert(bson.M{"_id": id}, update)
+//
+// See the Upsert method for more details.
+func (c *Collection) UpsertId(id interface{}, update interface{}) (info *ChangeInfo, err error) {
+	return c.Upsert(bson.D{{"_id", id}}, update)
+}
+
+// Remove finds a single document matching the provided selector document
+// and removes it from the database.
+// If the session is in safe mode (see SetSafe) a ErrNotFound error is
+// returned if a document isn't found, or a value of type *LastError
+// when some other error is detected.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Removing
+//
+func (c *Collection) Remove(selector interface{}) error {
+	lerr, err := c.writeQuery(&deleteOp{c.FullName, selector, 1})
+	if err == nil && lerr != nil && lerr.N == 0 {
+		return ErrNotFound
+	}
+	return err
+}
+
+// RemoveId is a convenience helper equivalent to:
+//
+//     err := collection.Remove(bson.M{"_id": id})
+//
+// See the Remove method for more details.
+func (c *Collection) RemoveId(id interface{}) error {
+	return c.Remove(bson.D{{"_id", id}})
+}
+
+// RemoveAll finds all documents matching the provided selector document
+// and removes them from the database.  In case the session is in safe mode
+// (see the SetSafe method) and an error happens when attempting the change,
+// the returned error will be of type *LastError.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Removing
+//
+func (c *Collection) RemoveAll(selector interface{}) (info *ChangeInfo, err error) {
+	lerr, err := c.writeQuery(&deleteOp{c.FullName, selector, 0})
+	if err == nil && lerr != nil {
+		info = &ChangeInfo{Removed: lerr.N}
+	}
+	return info, err
+}
+
+// DropDatabase removes the entire database including all of its collections.
+func (db *Database) DropDatabase() error {
+	return db.Run(bson.D{{"dropDatabase", 1}}, nil)
+}
+
+// DropCollection removes the entire collection including all of its documents.
+func (c *Collection) DropCollection() error {
+	return c.Database.Run(bson.D{{"drop", c.Name}}, nil)
+}
+
+// The CollectionInfo type holds metadata about a collection.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/createCollection+Command
+//     http://www.mongodb.org/display/DOCS/Capped+Collections
+//
+type CollectionInfo struct {
+	// DisableIdIndex prevents the automatic creation of the index
+	// on the _id field for the collection.
+	DisableIdIndex bool
+
+	// ForceIdIndex enforces the automatic creation of the index
+	// on the _id field for the collection. Capped collections,
+	// for example, do not have such an index by default.
+	ForceIdIndex bool
+
+	// If Capped is true new documents will replace old ones when
+	// the collection is full. MaxBytes must necessarily be set
+	// to define the size when the collection wraps around.
+	// MaxDocs optionally defines the number of documents when it
+	// wraps, but MaxBytes still needs to be set.
+	Capped   bool
+	MaxBytes int
+	MaxDocs  int
+}
+
+// Create explicitly creates the c collection with details of info.
+// MongoDB creates collections automatically on use, so this method
+// is only necessary when creating collection with non-default
+// characteristics, such as capped collections.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/createCollection+Command
+//     http://www.mongodb.org/display/DOCS/Capped+Collections
+//
+func (c *Collection) Create(info *CollectionInfo) error {
+	cmd := make(bson.D, 0, 4)
+	cmd = append(cmd, bson.DocElem{"create", c.Name})
+	if info.Capped {
+		if info.MaxBytes < 1 {
+			return fmt.Errorf("Collection.Create: with Capped, MaxBytes must also be set")
+		}
+		cmd = append(cmd, bson.DocElem{"capped", true})
+		cmd = append(cmd, bson.DocElem{"size", info.MaxBytes})
+		if info.MaxDocs > 0 {
+			cmd = append(cmd, bson.DocElem{"max", info.MaxDocs})
+		}
+	}
+	if info.DisableIdIndex {
+		cmd = append(cmd, bson.DocElem{"autoIndexId", false})
+	}
+	if info.ForceIdIndex {
+		cmd = append(cmd, bson.DocElem{"autoIndexId", true})
+	}
+	return c.Database.Run(cmd, nil)
+}
+
+// Batch sets the batch size used when fetching documents from the database.
+// It's possible to change this setting on a per-session basis as well, using
+// the Batch method of Session.
+//
+// The default batch size is defined by the database itself.  As of this
+// writing, MongoDB will use an initial size of min(100 docs, 4MB) on the
+// first batch, and 4MB on remaining ones.
+func (q *Query) Batch(n int) *Query {
+	if n == 1 {
+		// Server interprets 1 as -1 and closes the cursor (!?)
+		n = 2
+	}
+	q.m.Lock()
+	q.op.limit = int32(n)
+	q.m.Unlock()
+	return q
+}
+
+// Prefetch sets the point at which the next batch of results will be requested.
+// When there are p*batch_size remaining documents cached in an Iter, the next
+// batch will be requested in background. For instance, when using this:
+//
+//     query.Batch(200).Prefetch(0.25)
+//
+// and there are only 50 documents cached in the Iter to be processed, the
+// next batch of 200 will be requested. It's possible to change this setting on
+// a per-session basis as well, using the SetPrefetch method of Session.
+//
+// The default prefetch value is 0.25.
+func (q *Query) Prefetch(p float64) *Query {
+	q.m.Lock()
+	q.prefetch = p
+	q.m.Unlock()
+	return q
+}
+
+// Skip skips over the n initial documents from the query results.  Note that
+// this only makes sense with capped collections where documents are naturally
+// ordered by insertion time, or with sorted results.
+func (q *Query) Skip(n int) *Query {
+	q.m.Lock()
+	q.op.skip = int32(n)
+	q.m.Unlock()
+	return q
+}
+
+// Limit restricts the maximum number of documents retrieved to n, and also
+// changes the batch size to the same value.  Once n documents have been
+// returned by Next, the following call will return ErrNotFound.
+func (q *Query) Limit(n int) *Query {
+	q.m.Lock()
+	switch {
+	case n == 1:
+		q.limit = 1
+		q.op.limit = -1
+	case n == math.MinInt32: // -MinInt32 == -MinInt32
+		q.limit = math.MaxInt32
+		q.op.limit = math.MinInt32 + 1
+	case n < 0:
+		q.limit = int32(-n)
+		q.op.limit = int32(n)
+	default:
+		q.limit = int32(n)
+		q.op.limit = int32(n)
+	}
+	q.m.Unlock()
+	return q
+}
+
+// Select enables selecting which fields should be retrieved for the results
+// found. For example, the following query would only retrieve the name field:
+//
+//     err := collection.Find(nil).Select(bson.M{"name": 1}).One(&result)
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Retrieving+a+Subset+of+Fields
+//
+func (q *Query) Select(selector interface{}) *Query {
+	q.m.Lock()
+	q.op.selector = selector
+	q.m.Unlock()
+	return q
+}
+
+// Sort asks the database to order returned documents according to the
+// provided field names. A field name may be prefixed by - (minus) for
+// it to be sorted in reverse order.
+//
+// For example:
+//
+//     query1 := collection.Find(nil).Sort("firstname", "lastname")
+//     query2 := collection.Find(nil).Sort("-age")
+//     query3 := collection.Find(nil).Sort("$natural")
+//     query4 := collection.Find(nil).Select(bson.M{"score": bson.M{"$meta": "textScore"}}).Sort("$textScore:score")
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order
+//
+func (q *Query) Sort(fields ...string) *Query {
+	q.m.Lock()
+	var order bson.D
+	for _, field := range fields {
+		n := 1
+		var kind string
+		if field != "" {
+			if field[0] == '$' {
+				if c := strings.Index(field, ":"); c > 1 && c < len(field)-1 {
+					kind = field[1:c]
+					field = field[c+1:]
+				}
+			}
+			switch field[0] {
+			case '+':
+				field = field[1:]
+			case '-':
+				n = -1
+				field = field[1:]
+			}
+		}
+		if field == "" {
+			panic("Sort: empty field name")
+		}
+		if kind == "textScore" {
+			order = append(order, bson.DocElem{field, bson.M{"$meta": kind}})
+		} else {
+			order = append(order, bson.DocElem{field, n})
+		}
+	}
+	q.op.options.OrderBy = order
+	q.op.hasOptions = true
+	q.m.Unlock()
+	return q
+}
+
+// Explain returns a number of details about how the MongoDB server would
+// execute the requested query, such as the number of objects examined,
+// the number of times the read lock was yielded to allow writes to go in,
+// and so on.
+//
+// For example:
+//
+//     m := bson.M{}
+//     err := collection.Find(bson.M{"filename": name}).Explain(m)
+//     if err == nil {
+//         fmt.Printf("Explain: %#v\n", m)
+//     }
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Optimization
+//     http://www.mongodb.org/display/DOCS/Query+Optimizer
+//
+func (q *Query) Explain(result interface{}) error {
+	q.m.Lock()
+	clone := &Query{session: q.session, query: q.query}
+	q.m.Unlock()
+	clone.op.options.Explain = true
+	clone.op.hasOptions = true
+	if clone.op.limit > 0 {
+		clone.op.limit = -q.op.limit
+	}
+	iter := clone.Iter()
+	if iter.Next(result) {
+		return nil
+	}
+	return iter.Close()
+}
+
+// Hint will include an explicit "hint" in the query to force the server
+// to use a specified index, potentially improving performance in some
+// situations.  The provided parameters are the fields that compose the
+// key of the index to be used.  For details on how the indexKey may be
+// built, see the EnsureIndex method.
+//
+// For example:
+//
+//     query := collection.Find(bson.M{"firstname": "Joe", "lastname": "Winter"})
+//     query.Hint("lastname", "firstname")
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Optimization
+//     http://www.mongodb.org/display/DOCS/Query+Optimizer
+//
+func (q *Query) Hint(indexKey ...string) *Query {
+	q.m.Lock()
+	keyInfo, err := parseIndexKey(indexKey)
+	q.op.options.Hint = keyInfo.key
+	q.op.hasOptions = true
+	q.m.Unlock()
+	if err != nil {
+		panic(err)
+	}
+	return q
+}
+
+// SetMaxScan constrains the query to stop after scanning the specified
+// number of documents.
+//
+// This modifier is generally used to prevent potentially long running
+// queries from disrupting performance by scanning through too much data.
+func (q *Query) SetMaxScan(n int) *Query {
+	q.m.Lock()
+	q.op.options.MaxScan = n
+	q.op.hasOptions = true
+	q.m.Unlock()
+	return q
+}
+
+// SetMaxTime constrains the query to stop after running for the specified time.
+//
+// When the time limit is reached MongoDB automatically cancels the query.
+// This can be used to efficiently prevent and identify unexpectedly slow queries.
+//
+// A few important notes about the mechanism enforcing this limit:
+//
+//  - Requests can block behind locking operations on the server, and that blocking
+//    time is not accounted for. In other words, the timer starts ticking only after
+//    the actual start of the query when it initially acquires the appropriate lock;
+//
+//  - Operations are interrupted only at interrupt points where an operation can be
+//    safely aborted – the total execution time may exceed the specified value;
+//
+//  - The limit can be applied to both CRUD operations and commands, but not all
+//    commands are interruptible;
+//
+//  - While iterating over results, computing follow up batches is included in the
+//    total time and the iteration continues until the alloted time is over, but
+//    network roundtrips are not taken into account for the limit.
+//
+//  - This limit does not override the inactive cursor timeout for idle cursors
+//    (default is 10 min).
+//
+// This mechanism was introduced in MongoDB 2.6.
+//
+// Relevant documentation:
+//
+//   http://blog.mongodb.org/post/83621787773/maxtimems-and-query-optimizer-introspection-in
+//
+func (q *Query) SetMaxTime(d time.Duration) *Query {
+	q.m.Lock()
+	q.op.options.MaxTimeMS = int(d / time.Millisecond)
+	q.op.hasOptions = true
+	q.m.Unlock()
+	return q
+}
+
+// Snapshot will force the performed query to make use of an available
+// index on the _id field to prevent the same document from being returned
+// more than once in a single iteration. This might happen without this
+// setting in situations when the document changes in size and thus has to
+// be moved while the iteration is running.
+//
+// Because snapshot mode traverses the _id index, it may not be used with
+// sorting or explicit hints. It also cannot use any other index for the
+// query.
+//
+// Even with snapshot mode, items inserted or deleted during the query may
+// or may not be returned; that is, this mode is not a true point-in-time
+// snapshot.
+//
+// The same effect of Snapshot may be obtained by using any unique index on
+// field(s) that will not be modified (best to use Hint explicitly too).
+// A non-unique index (such as creation time) may be made unique by
+// appending _id to the index when creating it.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/How+to+do+Snapshotted+Queries+in+the+Mongo+Database
+//
+func (q *Query) Snapshot() *Query {
+	q.m.Lock()
+	q.op.options.Snapshot = true
+	q.op.hasOptions = true
+	q.m.Unlock()
+	return q
+}
+
+// Comment adds a comment to the query to identify it in the database profiler output.
+//
+// Relevant documentation:
+//
+//     http://docs.mongodb.org/manual/reference/operator/meta/comment
+//     http://docs.mongodb.org/manual/reference/command/profile
+//     http://docs.mongodb.org/manual/administration/analyzing-mongodb-performance/#database-profiling
+//
+func (q *Query) Comment(comment string) *Query {
+	q.m.Lock()
+	q.op.options.Comment = comment
+	q.op.hasOptions = true
+	q.m.Unlock()
+	return q
+}
+
+// LogReplay enables an option that optimizes queries that are typically
+// made on the MongoDB oplog for replaying it. This is an internal
+// implementation aspect and most likely uninteresting for other uses.
+// It has seen at least one use case, though, so it's exposed via the API.
+func (q *Query) LogReplay() *Query {
+	q.m.Lock()
+	q.op.flags |= flagLogReplay
+	q.m.Unlock()
+	return q
+}
+
+func checkQueryError(fullname string, d []byte) error {
+	l := len(d)
+	if l < 16 {
+		return nil
+	}
+	if d[5] == '$' && d[6] == 'e' && d[7] == 'r' && d[8] == 'r' && d[9] == '\x00' && d[4] == '\x02' {
+		goto Error
+	}
+	if len(fullname) < 5 || fullname[len(fullname)-5:] != ".$cmd" {
+		return nil
+	}
+	for i := 0; i+8 < l; i++ {
+		if d[i] == '\x02' && d[i+1] == 'e' && d[i+2] == 'r' && d[i+3] == 'r' && d[i+4] == 'm' && d[i+5] == 's' && d[i+6] == 'g' && d[i+7] == '\x00' {
+			goto Error
+		}
+	}
+	return nil
+
+Error:
+	result := &queryError{}
+	bson.Unmarshal(d, result)
+	if result.LastError != nil {
+		return result.LastError
+	}
+	if result.Err == "" && result.ErrMsg == "" {
+		return nil
+	}
+	if result.AssertionCode != 0 && result.Assertion != "" {
+		return &QueryError{Code: result.AssertionCode, Message: result.Assertion, Assertion: true}
+	}
+	if result.Err != "" {
+		return &QueryError{Code: result.Code, Message: result.Err}
+	}
+	return &QueryError{Code: result.Code, Message: result.ErrMsg}
+}
+
+// One executes the query and unmarshals the first obtained document into the
+// result argument.  The result must be a struct or map value capable of being
+// unmarshalled into by gobson.  This function blocks until either a result
+// is available or an error happens.  For example:
+//
+//     err := collection.Find(bson.M{"a", 1}).One(&result)
+//
+// In case the resulting document includes a field named $err or errmsg, which
+// are standard ways for MongoDB to return query errors, the returned err will
+// be set to a *QueryError value including the Err message and the Code.  In
+// those cases, the result argument is still unmarshalled into with the
+// received document so that any other custom values may be obtained if
+// desired.
+//
+func (q *Query) One(result interface{}) (err error) {
+	q.m.Lock()
+	session := q.session
+	op := q.op // Copy.
+	q.m.Unlock()
+
+	socket, err := session.acquireSocket(true)
+	if err != nil {
+		return err
+	}
+	defer socket.Release()
+
+	op.flags |= session.slaveOkFlag()
+	op.limit = -1
+
+	data, err := socket.SimpleQuery(&op)
+	if err != nil {
+		return err
+	}
+	if data == nil {
+		return ErrNotFound
+	}
+	if result != nil {
+		err = bson.Unmarshal(data, result)
+		if err == nil {
+			debugf("Query %p document unmarshaled: %#v", q, result)
+		} else {
+			debugf("Query %p document unmarshaling failed: %#v", q, err)
+			return err
+		}
+	}
+	return checkQueryError(op.collection, data)
+}
+
+// run duplicates the behavior of collection.Find(query).One(&result)
+// as performed by Database.Run, specializing the logic for running
+// database commands on a given socket.
+func (db *Database) run(socket *mongoSocket, cmd, result interface{}) (err error) {
+	// Database.Run:
+	if name, ok := cmd.(string); ok {
+		cmd = bson.D{{name, 1}}
+	}
+
+	// Collection.Find:
+	session := db.Session
+	session.m.RLock()
+	op := session.queryConfig.op // Copy.
+	session.m.RUnlock()
+	op.query = cmd
+	op.collection = db.Name + ".$cmd"
+
+	// Query.One:
+	op.flags |= session.slaveOkFlag()
+	op.limit = -1
+
+	data, err := socket.SimpleQuery(&op)
+	if err != nil {
+		return err
+	}
+	if data == nil {
+		return ErrNotFound
+	}
+	if result != nil {
+		err = bson.Unmarshal(data, result)
+		if err == nil {
+			var res bson.M
+			bson.Unmarshal(data, &res)
+			debugf("Run command unmarshaled: %#v, result: %#v", op, res)
+		} else {
+			debugf("Run command unmarshaling failed: %#v", op, err)
+			return err
+		}
+	}
+	return checkQueryError(op.collection, data)
+}
+
+// The DBRef type implements support for the database reference MongoDB
+// convention as supported by multiple drivers.  This convention enables
+// cross-referencing documents between collections and databases using
+// a structure which includes a collection name, a document id, and
+// optionally a database name.
+//
+// See the FindRef methods on Session and on Database.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Database+References
+//
+type DBRef struct {
+	Collection string      `bson:"$ref"`
+	Id         interface{} `bson:"$id"`
+	Database   string      `bson:"$db,omitempty"`
+}
+
+// NOTE: Order of fields for DBRef above does matter, per documentation.
+
+// FindRef returns a query that looks for the document in the provided
+// reference. If the reference includes the DB field, the document will
+// be retrieved from the respective database.
+//
+// See also the DBRef type and the FindRef method on Session.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Database+References
+//
+func (db *Database) FindRef(ref *DBRef) *Query {
+	var c *Collection
+	if ref.Database == "" {
+		c = db.C(ref.Collection)
+	} else {
+		c = db.Session.DB(ref.Database).C(ref.Collection)
+	}
+	return c.FindId(ref.Id)
+}
+
+// FindRef returns a query that looks for the document in the provided
+// reference. For a DBRef to be resolved correctly at the session level
+// it must necessarily have the optional DB field defined.
+//
+// See also the DBRef type and the FindRef method on Database.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Database+References
+//
+func (s *Session) FindRef(ref *DBRef) *Query {
+	if ref.Database == "" {
+		panic(errors.New(fmt.Sprintf("Can't resolve database for %#v", ref)))
+	}
+	c := s.DB(ref.Database).C(ref.Collection)
+	return c.FindId(ref.Id)
+}
+
+// CollectionNames returns the collection names present in the db database.
+func (db *Database) CollectionNames() (names []string, err error) {
+	// Clone session and set it to Monotonic mode so that the server
+	// used for the query may be safely obtained afterwards, if
+	// necessary for iteration when a cursor is received.
+	session := db.Session
+	cloned := session.Clone()
+	cloned.SetMode(Monotonic, false)
+	defer cloned.Close()
+
+	batchSize := int(cloned.queryConfig.op.limit)
+
+	// Try with a command.
+	var result struct {
+		Collections []bson.Raw
+
+		Cursor struct {
+			FirstBatch []bson.Raw "firstBatch"
+			NS         string
+			Id         int64
+		}
+	}
+	err = db.With(cloned).Run(bson.D{{"listCollections", 1}, {"cursor", bson.D{{"batchSize", batchSize}}}}, &result)
+	if err == nil {
+		firstBatch := result.Collections
+		if firstBatch == nil {
+			firstBatch = result.Cursor.FirstBatch
+		}
+		var iter *Iter
+		ns := strings.SplitN(result.Cursor.NS, ".", 2)
+		if len(ns) < 2 {
+			iter = db.With(cloned).C("").NewIter(nil, firstBatch, result.Cursor.Id, nil)
+		} else {
+			iter = cloned.DB(ns[0]).C(ns[1]).NewIter(nil, firstBatch, result.Cursor.Id, nil)
+		}
+		var coll struct{ Name string }
+		for iter.Next(&coll) {
+			names = append(names, coll.Name)
+		}
+		if err := iter.Close(); err != nil {
+			return nil, err
+		}
+		sort.Strings(names)
+		return names, err
+	}
+	if err != nil && !isNoCmd(err) {
+		return nil, err
+	}
+
+	// Command not yet supported. Query the database instead.
+	nameIndex := len(db.Name) + 1
+	iter := db.C("system.namespaces").Find(nil).Iter()
+	var coll struct{ Name string }
+	for iter.Next(&coll) {
+		if strings.Index(coll.Name, "$") < 0 || strings.Index(coll.Name, ".oplog.$") >= 0 {
+			names = append(names, coll.Name[nameIndex:])
+		}
+	}
+	if err := iter.Close(); err != nil {
+		return nil, err
+	}
+	sort.Strings(names)
+	return names, nil
+}
+
+type dbNames struct {
+	Databases []struct {
+		Name  string
+		Empty bool
+	}
+}
+
+// DatabaseNames returns the names of non-empty databases present in the cluster.
+func (s *Session) DatabaseNames() (names []string, err error) {
+	var result dbNames
+	err = s.Run("listDatabases", &result)
+	if err != nil {
+		return nil, err
+	}
+	for _, db := range result.Databases {
+		if !db.Empty {
+			names = append(names, db.Name)
+		}
+	}
+	sort.Strings(names)
+	return names, nil
+}
+
+// Iter executes the query and returns an iterator capable of going over all
+// the results. Results will be returned in batches of configurable
+// size (see the Batch method) and more documents will be requested when a
+// configurable number of documents is iterated over (see the Prefetch method).
+func (q *Query) Iter() *Iter {
+	q.m.Lock()
+	session := q.session
+	op := q.op
+	prefetch := q.prefetch
+	limit := q.limit
+	q.m.Unlock()
+
+	iter := &Iter{
+		session:  session,
+		prefetch: prefetch,
+		limit:    limit,
+		timeout:  -1,
+	}
+	iter.gotReply.L = &iter.m
+	iter.op.collection = op.collection
+	iter.op.limit = op.limit
+	iter.op.replyFunc = iter.replyFunc()
+	iter.docsToReceive++
+	op.replyFunc = iter.op.replyFunc
+	op.flags |= session.slaveOkFlag()
+
+	socket, err := session.acquireSocket(true)
+	if err != nil {
+		iter.err = err
+	} else {
+		iter.server = socket.Server()
+		err = socket.Query(&op)
+		if err != nil {
+			// Must lock as the query above may call replyFunc.
+			iter.m.Lock()
+			iter.err = err
+			iter.m.Unlock()
+		}
+		socket.Release()
+	}
+	return iter
+}
+
+// Tail returns a tailable iterator. Unlike a normal iterator, a
+// tailable iterator may wait for new values to be inserted in the
+// collection once the end of the current result set is reached,
+// A tailable iterator may only be used with capped collections.
+//
+// The timeout parameter indicates how long Next will block waiting
+// for a result before timing out.  If set to -1, Next will not
+// timeout, and will continue waiting for a result for as long as
+// the cursor is valid and the session is not closed. If set to 0,
+// Next times out as soon as it reaches the end of the result set.
+// Otherwise, Next will wait for at least the given number of
+// seconds for a new document to be available before timing out.
+//
+// On timeouts, Next will unblock and return false, and the Timeout
+// method will return true if called. In these cases, Next may still
+// be called again on the same iterator to check if a new value is
+// available at the current cursor position, and again it will block
+// according to the specified timeoutSecs. If the cursor becomes
+// invalid, though, both Next and Timeout will return false and
+// the query must be restarted.
+//
+// The following example demonstrates timeout handling and query
+// restarting:
+//
+//    iter := collection.Find(nil).Sort("$natural").Tail(5 * time.Second)
+//    for {
+//         for iter.Next(&result) {
+//             fmt.Println(result.Id)
+//             lastId = result.Id
+//         }
+//         if iter.Err() != nil {
+//             return iter.Close()
+//         }
+//         if iter.Timeout() {
+//             continue
+//         }
+//         query := collection.Find(bson.M{"_id": bson.M{"$gt": lastId}})
+//         iter = query.Sort("$natural").Tail(5 * time.Second)
+//    }
+//    iter.Close()
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Tailable+Cursors
+//     http://www.mongodb.org/display/DOCS/Capped+Collections
+//     http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order
+//
+func (q *Query) Tail(timeout time.Duration) *Iter {
+	q.m.Lock()
+	session := q.session
+	op := q.op
+	prefetch := q.prefetch
+	q.m.Unlock()
+
+	iter := &Iter{session: session, prefetch: prefetch}
+	iter.gotReply.L = &iter.m
+	iter.timeout = timeout
+	iter.op.collection = op.collection
+	iter.op.limit = op.limit
+	iter.op.replyFunc = iter.replyFunc()
+	iter.docsToReceive++
+	op.replyFunc = iter.op.replyFunc
+	op.flags |= flagTailable | flagAwaitData | session.slaveOkFlag()
+
+	socket, err := session.acquireSocket(true)
+	if err != nil {
+		iter.err = err
+	} else {
+		iter.server = socket.Server()
+		err = socket.Query(&op)
+		if err != nil {
+			// Must lock as the query above may call replyFunc.
+			iter.m.Lock()
+			iter.err = err
+			iter.m.Unlock()
+		}
+		socket.Release()
+	}
+	return iter
+}
+
+func (s *Session) slaveOkFlag() (flag queryOpFlags) {
+	s.m.RLock()
+	if s.slaveOk {
+		flag = flagSlaveOk
+	}
+	s.m.RUnlock()
+	return
+}
+
+// Err returns nil if no errors happened during iteration, or the actual
+// error otherwise.
+//
+// In case a resulting document included a field named $err or errmsg, which are
+// standard ways for MongoDB to report an improper query, the returned value has
+// a *QueryError type, and includes the Err message and the Code.
+func (iter *Iter) Err() error {
+	iter.m.Lock()
+	err := iter.err
+	iter.m.Unlock()
+	if err == ErrNotFound {
+		return nil
+	}
+	return err
+}
+
+// Close kills the server cursor used by the iterator, if any, and returns
+// nil if no errors happened during iteration, or the actual error otherwise.
+//
+// Server cursors are automatically closed at the end of an iteration, which
+// means close will do nothing unless the iteration was interrupted before
+// the server finished sending results to the driver. If Close is not called
+// in such a situation, the cursor will remain available at the server until
+// the default cursor timeout period is reached. No further problems arise.
+//
+// Close is idempotent. That means it can be called repeatedly and will
+// return the same result every time.
+//
+// In case a resulting document included a field named $err or errmsg, which are
+// standard ways for MongoDB to report an improper query, the returned value has
+// a *QueryError type.
+func (iter *Iter) Close() error {
+	iter.m.Lock()
+	cursorId := iter.op.cursorId
+	iter.op.cursorId = 0
+	err := iter.err
+	iter.m.Unlock()
+	if cursorId == 0 {
+		if err == ErrNotFound {
+			return nil
+		}
+		return err
+	}
+	socket, err := iter.acquireSocket()
+	if err == nil {
+		// TODO Batch kills.
+		err = socket.Query(&killCursorsOp{[]int64{cursorId}})
+		socket.Release()
+	}
+
+	iter.m.Lock()
+	if err != nil && (iter.err == nil || iter.err == ErrNotFound) {
+		iter.err = err
+	} else if iter.err != ErrNotFound {
+		err = iter.err
+	}
+	iter.m.Unlock()
+	return err
+}
+
+// Timeout returns true if Next returned false due to a timeout of
+// a tailable cursor. In those cases, Next may be called again to continue
+// the iteration at the previous cursor position.
+func (iter *Iter) Timeout() bool {
+	iter.m.Lock()
+	result := iter.timedout
+	iter.m.Unlock()
+	return result
+}
+
+// Next retrieves the next document from the result set, blocking if necessary.
+// This method will also automatically retrieve another batch of documents from
+// the server when the current one is exhausted, or before that in background
+// if pre-fetching is enabled (see the Query.Prefetch and Session.SetPrefetch
+// methods).
+//
+// Next returns true if a document was successfully unmarshalled onto result,
+// and false at the end of the result set or if an error happened.
+// When Next returns false, the Err method should be called to verify if
+// there was an error during iteration.
+//
+// For example:
+//
+//    iter := collection.Find(nil).Iter()
+//    for iter.Next(&result) {
+//        fmt.Printf("Result: %v\n", result.Id)
+//    }
+//    if err := iter.Close(); err != nil {
+//        return err
+//    }
+//
+func (iter *Iter) Next(result interface{}) bool {
+	iter.m.Lock()
+	iter.timedout = false
+	timeout := time.Time{}
+	for iter.err == nil && iter.docData.Len() == 0 && (iter.docsToReceive > 0 || iter.op.cursorId != 0) {
+		if iter.docsToReceive == 0 {
+			if iter.timeout >= 0 {
+				if timeout.IsZero() {
+					timeout = time.Now().Add(iter.timeout)
+				}
+				if time.Now().After(timeout) {
+					iter.timedout = true
+					iter.m.Unlock()
+					return false
+				}
+			}
+			iter.getMore()
+			if iter.err != nil {
+				break
+			}
+		}
+		iter.gotReply.Wait()
+	}
+
+	// Exhaust available data before reporting any errors.
+	if docData, ok := iter.docData.Pop().([]byte); ok {
+		close := false
+		if iter.limit > 0 {
+			iter.limit--
+			if iter.limit == 0 {
+				if iter.docData.Len() > 0 {
+					iter.m.Unlock()
+					panic(fmt.Errorf("data remains after limit exhausted: %d", iter.docData.Len()))
+				}
+				iter.err = ErrNotFound
+				close = true
+			}
+		}
+		if iter.op.cursorId != 0 && iter.err == nil {
+			iter.docsBeforeMore--
+			if iter.docsBeforeMore == -1 {
+				iter.getMore()
+			}
+		}
+		iter.m.Unlock()
+
+		if close {
+			iter.Close()
+		}
+		err := bson.Unmarshal(docData, result)
+		if err != nil {
+			debugf("Iter %p document unmarshaling failed: %#v", iter, err)
+			iter.m.Lock()
+			if iter.err == nil {
+				iter.err = err
+			}
+			iter.m.Unlock()
+			return false
+		}
+		debugf("Iter %p document unmarshaled: %#v", iter, result)
+		// XXX Only have to check first document for a query error?
+		err = checkQueryError(iter.op.collection, docData)
+		if err != nil {
+			iter.m.Lock()
+			if iter.err == nil {
+				iter.err = err
+			}
+			iter.m.Unlock()
+			return false
+		}
+		return true
+	} else if iter.err != nil {
+		debugf("Iter %p returning false: %s", iter, iter.err)
+		iter.m.Unlock()
+		return false
+	} else if iter.op.cursorId == 0 {
+		iter.err = ErrNotFound
+		debugf("Iter %p exhausted with cursor=0", iter)
+		iter.m.Unlock()
+		return false
+	}
+
+	panic("unreachable")
+}
+
+// All retrieves all documents from the result set into the provided slice
+// and closes the iterator.
+//
+// The result argument must necessarily be the address for a slice. The slice
+// may be nil or previously allocated.
+//
+// WARNING: Obviously, All must not be used with result sets that may be
+// potentially large, since it may consume all memory until the system
+// crashes. Consider building the query with a Limit clause to ensure the
+// result size is bounded.
+//
+// For instance:
+//
+//    var result []struct{ Value int }
+//    iter := collection.Find(nil).Limit(100).Iter()
+//    err := iter.All(&result)
+//    if err != nil {
+//        return err
+//    }
+//
+func (iter *Iter) All(result interface{}) error {
+	resultv := reflect.ValueOf(result)
+	if resultv.Kind() != reflect.Ptr || resultv.Elem().Kind() != reflect.Slice {
+		panic("result argument must be a slice address")
+	}
+	slicev := resultv.Elem()
+	slicev = slicev.Slice(0, slicev.Cap())
+	elemt := slicev.Type().Elem()
+	i := 0
+	for {
+		if slicev.Len() == i {
+			elemp := reflect.New(elemt)
+			if !iter.Next(elemp.Interface()) {
+				break
+			}
+			slicev = reflect.Append(slicev, elemp.Elem())
+			slicev = slicev.Slice(0, slicev.Cap())
+		} else {
+			if !iter.Next(slicev.Index(i).Addr().Interface()) {
+				break
+			}
+		}
+		i++
+	}
+	resultv.Elem().Set(slicev.Slice(0, i))
+	return iter.Close()
+}
+
+// All works like Iter.All.
+func (q *Query) All(result interface{}) error {
+	return q.Iter().All(result)
+}
+
+// The For method is obsolete and will be removed in a future release.
+// See Iter as an elegant replacement.
+func (q *Query) For(result interface{}, f func() error) error {
+	return q.Iter().For(result, f)
+}
+
+// The For method is obsolete and will be removed in a future release.
+// See Iter as an elegant replacement.
+func (iter *Iter) For(result interface{}, f func() error) (err error) {
+	valid := false
+	v := reflect.ValueOf(result)
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+		switch v.Kind() {
+		case reflect.Map, reflect.Ptr, reflect.Interface, reflect.Slice:
+			valid = v.IsNil()
+		}
+	}
+	if !valid {
+		panic("For needs a pointer to nil reference value.  See the documentation.")
+	}
+	zero := reflect.Zero(v.Type())
+	for {
+		v.Set(zero)
+		if !iter.Next(result) {
+			break
+		}
+		err = f()
+		if err != nil {
+			return err
+		}
+	}
+	return iter.Err()
+}
+
+// acquireSocket acquires a socket from the same server that the iterator
+// cursor was obtained from.
+//
+// WARNING: This method must not be called with iter.m locked. Acquiring the
+// socket depends on the cluster sync loop, and the cluster sync loop might
+// attempt actions which cause replyFunc to be called, inducing a deadlock.
+func (iter *Iter) acquireSocket() (*mongoSocket, error) {
+	socket, err := iter.session.acquireSocket(true)
+	if err != nil {
+		return nil, err
+	}
+	if socket.Server() != iter.server {
+		// Socket server changed during iteration. This may happen
+		// with Eventual sessions, if a Refresh is done, or if a
+		// monotonic session gets a write and shifts from secondary
+		// to primary. Our cursor is in a specific server, though.
+		iter.session.m.Lock()
+		sockTimeout := iter.session.sockTimeout
+		iter.session.m.Unlock()
+		socket.Release()
+		socket, _, err = iter.server.AcquireSocket(0, sockTimeout)
+		if err != nil {
+			return nil, err
+		}
+		err := iter.session.socketLogin(socket)
+		if err != nil {
+			socket.Release()
+			return nil, err
+		}
+	}
+	return socket, nil
+}
+
+func (iter *Iter) getMore() {
+	// Increment now so that unlocking the iterator won't cause a
+	// different goroutine to get here as well.
+	iter.docsToReceive++
+	iter.m.Unlock()
+	socket, err := iter.acquireSocket()
+	iter.m.Lock()
+	if err != nil {
+		iter.err = err
+		return
+	}
+	defer socket.Release()
+
+	debugf("Iter %p requesting more documents", iter)
+	if iter.limit > 0 {
+		// The -1 below accounts for the fact docsToReceive was incremented above.
+		limit := iter.limit - int32(iter.docsToReceive-1) - int32(iter.docData.Len())
+		if limit < iter.op.limit {
+			iter.op.limit = limit
+		}
+	}
+	if err := socket.Query(&iter.op); err != nil {
+		iter.docsToReceive--
+		iter.err = err
+	}
+}
+
+type countCmd struct {
+	Count string
+	Query interface{}
+	Limit int32 ",omitempty"
+	Skip  int32 ",omitempty"
+}
+
+// Count returns the total number of documents in the result set.
+func (q *Query) Count() (n int, err error) {
+	q.m.Lock()
+	session := q.session
+	op := q.op
+	limit := q.limit
+	q.m.Unlock()
+
+	c := strings.Index(op.collection, ".")
+	if c < 0 {
+		return 0, errors.New("Bad collection name: " + op.collection)
+	}
+
+	dbname := op.collection[:c]
+	cname := op.collection[c+1:]
+	query := op.query
+	if query == nil {
+		query = bson.D{}
+	}
+	result := struct{ N int }{}
+	err = session.DB(dbname).Run(countCmd{cname, query, limit, op.skip}, &result)
+	return result.N, err
+}
+
+// Count returns the total number of documents in the collection.
+func (c *Collection) Count() (n int, err error) {
+	return c.Find(nil).Count()
+}
+
+type distinctCmd struct {
+	Collection string "distinct"
+	Key        string
+	Query      interface{} ",omitempty"
+}
+
+// Distinct unmarshals into result the list of distinct values for the given key.
+//
+// For example:
+//
+//     var result []int
+//     err := collection.Find(bson.M{"gender": "F"}).Distinct("age", &result)
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/Aggregation
+//
+func (q *Query) Distinct(key string, result interface{}) error {
+	q.m.Lock()
+	session := q.session
+	op := q.op // Copy.
+	q.m.Unlock()
+
+	c := strings.Index(op.collection, ".")
+	if c < 0 {
+		return errors.New("Bad collection name: " + op.collection)
+	}
+
+	dbname := op.collection[:c]
+	cname := op.collection[c+1:]
+
+	var doc struct{ Values bson.Raw }
+	err := session.DB(dbname).Run(distinctCmd{cname, key, op.query}, &doc)
+	if err != nil {
+		return err
+	}
+	return doc.Values.Unmarshal(result)
+}
+
+type mapReduceCmd struct {
+	Collection string "mapreduce"
+	Map        string ",omitempty"
+	Reduce     string ",omitempty"
+	Finalize   string ",omitempty"
+	Limit      int32  ",omitempty"
+	Out        interface{}
+	Query      interface{} ",omitempty"
+	Sort       interface{} ",omitempty"
+	Scope      interface{} ",omitempty"
+	Verbose    bool        ",omitempty"
+}
+
+type mapReduceResult struct {
+	Results    bson.Raw
+	Result     bson.Raw
+	TimeMillis int64 "timeMillis"
+	Counts     struct{ Input, Emit, Output int }
+	Ok         bool
+	Err        string
+	Timing     *MapReduceTime
+}
+
+type MapReduce struct {
+	Map      string      // Map Javascript function code (required)
+	Reduce   string      // Reduce Javascript function code (required)
+	Finalize string      // Finalize Javascript function code (optional)
+	Out      interface{} // Output collection name or document. If nil, results are inlined into the result parameter.
+	Scope    interface{} // Optional global scope for Javascript functions
+	Verbose  bool
+}
+
+type MapReduceInfo struct {
+	InputCount  int            // Number of documents mapped
+	EmitCount   int            // Number of times reduce called emit
+	OutputCount int            // Number of documents in resulting collection
+	Database    string         // Output database, if results are not inlined
+	Collection  string         // Output collection, if results are not inlined
+	Time        int64          // Time to run the job, in nanoseconds
+	VerboseTime *MapReduceTime // Only defined if Verbose was true
+}
+
+type MapReduceTime struct {
+	Total    int64 // Total time, in nanoseconds
+	Map      int64 "mapTime"  // Time within map function, in nanoseconds
+	EmitLoop int64 "emitLoop" // Time within the emit/map loop, in nanoseconds
+}
+
+// MapReduce executes a map/reduce job for documents covered by the query.
+// That kind of job is suitable for very flexible bulk aggregation of data
+// performed at the server side via Javascript functions.
+//
+// Results from the job may be returned as a result of the query itself
+// through the result parameter in case they'll certainly fit in memory
+// and in a single document.  If there's the possibility that the amount
+// of data might be too large, results must be stored back in an alternative
+// collection or even a separate database, by setting the Out field of the
+// provided MapReduce job.  In that case, provide nil as the result parameter.
+//
+// These are some of the ways to set Out:
+//
+//     nil
+//         Inline results into the result parameter.
+//
+//     bson.M{"replace": "mycollection"}
+//         The output will be inserted into a collection which replaces any
+//         existing collection with the same name.
+//
+//     bson.M{"merge": "mycollection"}
+//         This option will merge new data into the old output collection. In
+//         other words, if the same key exists in both the result set and the
+//         old collection, the new key will overwrite the old one.
+//
+//     bson.M{"reduce": "mycollection"}
+//         If documents exist for a given key in the result set and in the old
+//         collection, then a reduce operation (using the specified reduce
+//         function) will be performed on the two values and the result will be
+//         written to the output collection. If a finalize function was
+//         provided, this will be run after the reduce as well.
+//
+//     bson.M{...., "db": "mydb"}
+//         Any of the above options can have the "db" key included for doing
+//         the respective action in a separate database.
+//
+// The following is a trivial example which will count the number of
+// occurrences of a field named n on each document in a collection, and
+// will return results inline:
+//
+//     job := &mgo.MapReduce{
+//             Map:      "function() { emit(this.n, 1) }",
+//             Reduce:   "function(key, values) { return Array.sum(values) }",
+//     }
+//     var result []struct { Id int "_id"; Value int }
+//     _, err := collection.Find(nil).MapReduce(job, &result)
+//     if err != nil {
+//         return err
+//     }
+//     for _, item := range result {
+//         fmt.Println(item.Value)
+//     }
+//
+// This function is compatible with MongoDB 1.7.4+.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/MapReduce
+//
+func (q *Query) MapReduce(job *MapReduce, result interface{}) (info *MapReduceInfo, err error) {
+	q.m.Lock()
+	session := q.session
+	op := q.op // Copy.
+	limit := q.limit
+	q.m.Unlock()
+
+	c := strings.Index(op.collection, ".")
+	if c < 0 {
+		return nil, errors.New("Bad collection name: " + op.collection)
+	}
+
+	dbname := op.collection[:c]
+	cname := op.collection[c+1:]
+
+	cmd := mapReduceCmd{
+		Collection: cname,
+		Map:        job.Map,
+		Reduce:     job.Reduce,
+		Finalize:   job.Finalize,
+		Out:        fixMROut(job.Out),
+		Scope:      job.Scope,
+		Verbose:    job.Verbose,
+		Query:      op.query,
+		Sort:       op.options.OrderBy,
+		Limit:      limit,
+	}
+
+	if cmd.Out == nil {
+		cmd.Out = bson.D{{"inline", 1}}
+	}
+
+	var doc mapReduceResult
+	err = session.DB(dbname).Run(&cmd, &doc)
+	if err != nil {
+		return nil, err
+	}
+	if doc.Err != "" {
+		return nil, errors.New(doc.Err)
+	}
+
+	info = &MapReduceInfo{
+		InputCount:  doc.Counts.Input,
+		EmitCount:   doc.Counts.Emit,
+		OutputCount: doc.Counts.Output,
+		Time:        doc.TimeMillis * 1e6,
+	}
+
+	if doc.Result.Kind == 0x02 {
+		err = doc.Result.Unmarshal(&info.Collection)
+		info.Database = dbname
+	} else if doc.Result.Kind == 0x03 {
+		var v struct{ Collection, Db string }
+		err = doc.Result.Unmarshal(&v)
+		info.Collection = v.Collection
+		info.Database = v.Db
+	}
+
+	if doc.Timing != nil {
+		info.VerboseTime = doc.Timing
+		info.VerboseTime.Total *= 1e6
+		info.VerboseTime.Map *= 1e6
+		info.VerboseTime.EmitLoop *= 1e6
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	if result != nil {
+		return info, doc.Results.Unmarshal(result)
+	}
+	return info, nil
+}
+
+// The "out" option in the MapReduce command must be ordered. This was
+// found after the implementation was accepting maps for a long time,
+// so rather than breaking the API, we'll fix the order if necessary.
+// Details about the order requirement may be seen in MongoDB's code:
+//
+//     http://goo.gl/L8jwJX
+//
+func fixMROut(out interface{}) interface{} {
+	outv := reflect.ValueOf(out)
+	if outv.Kind() != reflect.Map || outv.Type().Key() != reflect.TypeOf("") {
+		return out
+	}
+	outs := make(bson.D, outv.Len())
+
+	outTypeIndex := -1
+	for i, k := range outv.MapKeys() {
+		ks := k.String()
+		outs[i].Name = ks
+		outs[i].Value = outv.MapIndex(k).Interface()
+		switch ks {
+		case "normal", "replace", "merge", "reduce", "inline":
+			outTypeIndex = i
+		}
+	}
+	if outTypeIndex > 0 {
+		outs[0], outs[outTypeIndex] = outs[outTypeIndex], outs[0]
+	}
+	return outs
+}
+
+// Change holds fields for running a findAndModify MongoDB command via
+// the Query.Apply method.
+type Change struct {
+	Update    interface{} // The update document
+	Upsert    bool        // Whether to insert in case the document isn't found
+	Remove    bool        // Whether to remove the document found rather than updating
+	ReturnNew bool        // Should the modified document be returned rather than the old one
+}
+
+type findModifyCmd struct {
+	Collection                  string      "findAndModify"
+	Query, Update, Sort, Fields interface{} ",omitempty"
+	Upsert, Remove, New         bool        ",omitempty"
+}
+
+type valueResult struct {
+	Value     bson.Raw
+	LastError LastError "lastErrorObject"
+}
+
+// Apply runs the findAndModify MongoDB command, which allows updating, upserting
+// or removing a document matching a query and atomically returning either the old
+// version (the default) or the new version of the document (when ReturnNew is true).
+// If no objects are found Apply returns ErrNotFound.
+//
+// The Sort and Select query methods affect the result of Apply.  In case
+// multiple documents match the query, Sort enables selecting which document to
+// act upon by ordering it first.  Select enables retrieving only a selection
+// of fields of the new or old document.
+//
+// This simple example increments a counter and prints its new value:
+//
+//     change := mgo.Change{
+//             Update: bson.M{"$inc": bson.M{"n": 1}},
+//             ReturnNew: true,
+//     }
+//     info, err = col.Find(M{"_id": id}).Apply(change, &doc)
+//     fmt.Println(doc.N)
+//
+// This method depends on MongoDB >= 2.0 to work properly.
+//
+// Relevant documentation:
+//
+//     http://www.mongodb.org/display/DOCS/findAndModify+Command
+//     http://www.mongodb.org/display/DOCS/Updating
+//     http://www.mongodb.org/display/DOCS/Atomic+Operations
+//
+func (q *Query) Apply(change Change, result interface{}) (info *ChangeInfo, err error) {
+	q.m.Lock()
+	session := q.session
+	op := q.op // Copy.
+	q.m.Unlock()
+
+	c := strings.Index(op.collection, ".")
+	if c < 0 {
+		return nil, errors.New("bad collection name: " + op.collection)
+	}
+
+	dbname := op.collection[:c]
+	cname := op.collection[c+1:]
+
+	cmd := findModifyCmd{
+		Collection: cname,
+		Update:     change.Update,
+		Upsert:     change.Upsert,
+		Remove:     change.Remove,
+		New:        change.ReturnNew,
+		Query:      op.query,
+		Sort:       op.options.OrderBy,
+		Fields:     op.selector,
+	}
+
+	session = session.Clone()
+	defer session.Close()
+	session.SetMode(Strong, false)
+
+	var doc valueResult
+	err = session.DB(dbname).Run(&cmd, &doc)
+	if err != nil {
+		if qerr, ok := err.(*QueryError); ok && qerr.Message == "No matching object found" {
+			return nil, ErrNotFound
+		}
+		return nil, err
+	}
+	if doc.LastError.N == 0 {
+		return nil, ErrNotFound
+	}
+	if doc.Value.Kind != 0x0A {
+		err = doc.Value.Unmarshal(result)
+		if err != nil {
+			return nil, err
+		}
+	}
+	info = &ChangeInfo{}
+	lerr := &doc.LastError
+	if lerr.UpdatedExisting {
+		info.Updated = lerr.N
+	} else if change.Remove {
+		info.Removed = lerr.N
+	} else if change.Upsert {
+		info.UpsertedId = lerr.UpsertedId
+	}
+	return info, nil
+}
+
+// The BuildInfo type encapsulates details about the running MongoDB server.
+//
+// Note that the VersionArray field was introduced in MongoDB 2.0+, but it is
+// internally assembled from the Version information for previous versions.
+// In both cases, VersionArray is guaranteed to have at least 4 entries.
+type BuildInfo struct {
+	Version        string
+	VersionArray   []int  `bson:"versionArray"` // On MongoDB 2.0+; assembled from Version otherwise
+	GitVersion     string `bson:"gitVersion"`
+	OpenSSLVersion string `bson:"OpenSSLVersion"`
+	SysInfo        string `bson:"sysInfo"`
+	Bits           int
+	Debug          bool
+	MaxObjectSize  int `bson:"maxBsonObjectSize"`
+}
+
+// VersionAtLeast returns whether the BuildInfo version is greater than or
+// equal to the provided version number. If more than one number is
+// provided, numbers will be considered as major, minor, and so on.
+func (bi *BuildInfo) VersionAtLeast(version ...int) bool {
+	for i := range version {
+		if i == len(bi.VersionArray) {
+			return false
+		}
+		if bi.VersionArray[i] < version[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// BuildInfo retrieves the version and other details about the
+// running MongoDB server.
+func (s *Session) BuildInfo() (info BuildInfo, err error) {
+	err = s.Run(bson.D{{"buildInfo", "1"}}, &info)
+	if len(info.VersionArray) == 0 {
+		for _, a := range strings.Split(info.Version, ".") {
+			i, err := strconv.Atoi(a)
+			if err != nil {
+				break
+			}
+			info.VersionArray = append(info.VersionArray, i)
+		}
+	}
+	for len(info.VersionArray) < 4 {
+		info.VersionArray = append(info.VersionArray, 0)
+	}
+	if i := strings.IndexByte(info.GitVersion, ' '); i >= 0 {
+		// Strip off the " modules: enterprise" suffix. This is a _git version_.
+		// That information may be moved to another field if people need it.
+		info.GitVersion = info.GitVersion[:i]
+	}
+	return
+}
+
+// ---------------------------------------------------------------------------
+// Internal session handling helpers.
+
+func (s *Session) acquireSocket(slaveOk bool) (*mongoSocket, error) {
+
+	// Read-only lock to check for previously reserved socket.
+	s.m.RLock()
+	if s.masterSocket != nil {
+		socket := s.masterSocket
+		socket.Acquire()
+		s.m.RUnlock()
+		return socket, nil
+	}
+	if s.slaveSocket != nil && s.slaveOk && slaveOk {
+		socket := s.slaveSocket
+		socket.Acquire()
+		s.m.RUnlock()
+		return socket, nil
+	}
+	s.m.RUnlock()
+
+	// No go.  We may have to request a new socket and change the session,
+	// so try again but with an exclusive lock now.
+	s.m.Lock()
+	defer s.m.Unlock()
+
+	if s.masterSocket != nil {
+		s.masterSocket.Acquire()
+		return s.masterSocket, nil
+	}
+	if s.slaveSocket != nil && s.slaveOk && slaveOk {
+		s.slaveSocket.Acquire()
+		return s.slaveSocket, nil
+	}
+
+	// Still not good.  We need a new socket.
+	sock, err := s.cluster().AcquireSocket(slaveOk && s.slaveOk, s.syncTimeout, s.sockTimeout, s.queryConfig.op.serverTags, s.poolLimit)
+	if err != nil {
+		return nil, err
+	}
+
+	// Authenticate the new socket.
+	if err = s.socketLogin(sock); err != nil {
+		sock.Release()
+		return nil, err
+	}
+
+	// Keep track of the new socket, if necessary.
+	// Note that, as a special case, if the Eventual session was
+	// not refreshed (s.slaveSocket != nil), it means the developer
+	// asked to preserve an existing reserved socket, so we'll
+	// keep a master one around too before a Refresh happens.
+	if s.consistency != Eventual || s.slaveSocket != nil {
+		s.setSocket(sock)
+	}
+
+	// Switch over a Monotonic session to the master.
+	if !slaveOk && s.consistency == Monotonic {
+		s.slaveOk = false
+	}
+
+	return sock, nil
+}
+
+// setSocket binds socket to this section.
+func (s *Session) setSocket(socket *mongoSocket) {
+	info := socket.Acquire()
+	if info.Master {
+		if s.masterSocket != nil {
+			panic("setSocket(master) with existing master socket reserved")
+		}
+		s.masterSocket = socket
+	} else {
+		if s.slaveSocket != nil {
+			panic("setSocket(slave) with existing slave socket reserved")
+		}
+		s.slaveSocket = socket
+	}
+}
+
+// unsetSocket releases any slave and/or master sockets reserved.
+func (s *Session) unsetSocket() {
+	if s.masterSocket != nil {
+		s.masterSocket.Release()
+	}
+	if s.slaveSocket != nil {
+		s.slaveSocket.Release()
+	}
+	s.masterSocket = nil
+	s.slaveSocket = nil
+}
+
+func (iter *Iter) replyFunc() replyFunc {
+	return func(err error, op *replyOp, docNum int, docData []byte) {
+		iter.m.Lock()
+		iter.docsToReceive--
+		if err != nil {
+			iter.err = err
+			debugf("Iter %p received an error: %s", iter, err.Error())
+		} else if docNum == -1 {
+			debugf("Iter %p received no documents (cursor=%d).", iter, op.cursorId)
+			if op != nil && op.cursorId != 0 {
+				// It's a tailable cursor.
+				iter.op.cursorId = op.cursorId
+			} else if op != nil && op.cursorId == 0 && op.flags&1 == 1 {
+				// Cursor likely timed out.
+				iter.err = ErrCursor
+			} else {
+				iter.err = ErrNotFound
+			}
+		} else {
+			rdocs := int(op.replyDocs)
+			if docNum == 0 {
+				iter.docsToReceive += rdocs - 1
+				docsToProcess := iter.docData.Len() + rdocs
+				if iter.limit == 0 || int32(docsToProcess) < iter.limit {
+					iter.docsBeforeMore = docsToProcess - int(iter.prefetch*float64(rdocs))
+				} else {
+					iter.docsBeforeMore = -1
+				}
+				iter.op.cursorId = op.cursorId
+			}
+			// XXX Handle errors and flags.
+			debugf("Iter %p received reply document %d/%d (cursor=%d)", iter, docNum+1, rdocs, op.cursorId)
+			iter.docData.Push(docData)
+		}
+		iter.gotReply.Broadcast()
+		iter.m.Unlock()
+	}
+}
+
+type writeCmdResult struct {
+	Ok        bool
+	N         int
+	NModified int `bson:"nModified"`
+	Upserted  []struct {
+		Index int
+		Id    interface{} `_id`
+	}
+	Errors []struct {
+		Ok     bool
+		Index  int
+		Code   int
+		N      int
+		ErrMsg string
+	} `bson:"writeErrors"`
+	ConcernError struct {
+		Code   int
+		ErrMsg string
+	} `bson:"writeConcernError"`
+}
+
+// writeQuery runs the given modifying operation, potentially followed up
+// by a getLastError command in case the session is in safe mode.  The
+// LastError result is made available in lerr, and if lerr.Err is set it
+// will also be returned as err.
+func (c *Collection) writeQuery(op interface{}) (lerr *LastError, err error) {
+	s := c.Database.Session
+	dbname := c.Database.Name
+	socket, err := s.acquireSocket(dbname == "local")
+	if err != nil {
+		return nil, err
+	}
+	defer socket.Release()
+
+	s.m.RLock()
+	safeOp := s.safeOp
+	s.m.RUnlock()
+
+	// TODO Enable this path for wire version 2 as well.
+	if socket.ServerInfo().MaxWireVersion >= 3 {
+		// Servers with a more recent write protocol benefit from write commands.
+		if op, ok := op.(*insertOp); ok && len(op.documents) > 1000 {
+			var firstErr error
+			// Maximum batch size is 1000. Must split out in separate operations for compatibility.
+			all := op.documents
+			for i := 0; i < len(all); i += 1000 {
+				l := i + 1000
+				if l > len(all) {
+					l = len(all)
+				}
+				op.documents = all[i:l]
+				_, err := c.writeCommand(socket, safeOp, op)
+				if err != nil {
+					if op.flags&1 != 0 {
+						if firstErr == nil {
+							firstErr = err
+						}
+					} else {
+						return nil, err
+					}
+				}
+			}
+			return nil, firstErr
+		}
+		return c.writeCommand(socket, safeOp, op)
+	}
+
+	if safeOp == nil {
+		return nil, socket.Query(op)
+	}
+
+	var mutex sync.Mutex
+	var replyData []byte
+	var replyErr error
+	mutex.Lock()
+	query := *safeOp // Copy the data.
+	query.collection = dbname + ".$cmd"
+	query.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
+		replyData = docData
+		replyErr = err
+		mutex.Unlock()
+	}
+	err = socket.Query(op, &query)
+	if err != nil {
+		return nil, err
+	}
+	mutex.Lock() // Wait.
+	if replyErr != nil {
+		return nil, replyErr // XXX TESTME
+	}
+	if hasErrMsg(replyData) {
+		// Looks like getLastError itself failed.
+		err = checkQueryError(query.collection, replyData)
+		if err != nil {
+			return nil, err
+		}
+	}
+	result := &LastError{}
+	bson.Unmarshal(replyData, &result)
+	debugf("Result from writing query: %#v", result)
+	if result.Err != "" {
+		return result, result
+	}
+	return result, nil
+}
+
+func (c *Collection) writeCommand(socket *mongoSocket, safeOp *queryOp, op interface{}) (lerr *LastError, err error) {
+	var writeConcern interface{}
+	if safeOp == nil {
+		writeConcern = bson.D{{"w", 0}}
+	} else {
+		writeConcern = safeOp.query.(*getLastError)
+	}
+
+	var cmd bson.D
+	switch op := op.(type) {
+	case *insertOp:
+		// http://docs.mongodb.org/manual/reference/command/insert
+		cmd = bson.D{
+			{"insert", c.Name},
+			{"documents", op.documents},
+			{"writeConcern", writeConcern},
+			{"ordered", op.flags&1 == 0},
+		}
+	case *updateOp:
+		// http://docs.mongodb.org/manual/reference/command/update
+		selector := op.selector
+		if selector == nil {
+			selector = bson.D{}
+		}
+		cmd = bson.D{
+			{"update", c.Name},
+			{"updates", []bson.D{{{"q", selector}, {"u", op.update}, {"upsert", op.flags&1 != 0}, {"multi", op.flags&2 != 0}}}},
+			{"writeConcern", writeConcern},
+			//{"ordered", <bool>},
+		}
+	case *deleteOp:
+		// http://docs.mongodb.org/manual/reference/command/delete
+		selector := op.selector
+		if selector == nil {
+			selector = bson.D{}
+		}
+		cmd = bson.D{
+			{"delete", c.Name},
+			{"deletes", []bson.D{{{"q", selector}, {"limit", op.flags & 1}}}},
+			{"writeConcern", writeConcern},
+			//{"ordered", <bool>},
+		}
+	}
+
+	var result writeCmdResult
+	err = c.Database.run(socket, cmd, &result)
+	debugf("Write command result: %#v (err=%v)", result, err)
+	// TODO Should lerr.N be result.NModified on updates?
+	lerr = &LastError{UpdatedExisting: result.NModified != 0, N: result.N}
+	if len(result.Upserted) > 0 {
+		lerr.UpsertedId = result.Upserted[0].Id
+	}
+	if len(result.Errors) > 0 {
+		e := result.Errors[0]
+		if !e.Ok {
+			lerr.Code = e.Code
+			lerr.Err = e.ErrMsg
+			err = lerr
+		}
+	} else if result.ConcernError.Code != 0 {
+		e := result.ConcernError
+		lerr.Code = e.Code
+		lerr.Err = e.ErrMsg
+		err = lerr
+	}
+
+	if err == nil && safeOp == nil {
+		return nil, nil
+	}
+	return lerr, err
+}
+
+func hasErrMsg(d []byte) bool {
+	l := len(d)
+	for i := 0; i+8 < l; i++ {
+		if d[i] == '\x02' && d[i+1] == 'e' && d[i+2] == 'r' && d[i+3] == 'r' && d[i+4] == 'm' && d[i+5] == 's' && d[i+6] == 'g' && d[i+7] == '\x00' {
+			return true
+		}
+	}
+	return false
+}
diff --git a/vendor/gopkg.in/mgo.v2/socket.go b/vendor/gopkg.in/mgo.v2/socket.go
new file mode 100644
index 00000000..f6882d50
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/socket.go
@@ -0,0 +1,677 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"errors"
+	"net"
+	"sync"
+	"time"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+type replyFunc func(err error, reply *replyOp, docNum int, docData []byte)
+
+type mongoSocket struct {
+	sync.Mutex
+	server        *mongoServer // nil when cached
+	conn          net.Conn
+	timeout       time.Duration
+	addr          string // For debugging only.
+	nextRequestId uint32
+	replyFuncs    map[uint32]replyFunc
+	references    int
+	creds         []Credential
+	logout        []Credential
+	cachedNonce   string
+	gotNonce      sync.Cond
+	dead          error
+	serverInfo    *mongoServerInfo
+}
+
+type queryOpFlags uint32
+
+const (
+	_ queryOpFlags = 1 << iota
+	flagTailable
+	flagSlaveOk
+	flagLogReplay
+	flagNoCursorTimeout
+	flagAwaitData
+)
+
+type queryOp struct {
+	collection string
+	query      interface{}
+	skip       int32
+	limit      int32
+	selector   interface{}
+	flags      queryOpFlags
+	replyFunc  replyFunc
+
+	options    queryWrapper
+	hasOptions bool
+	serverTags []bson.D
+}
+
+type queryWrapper struct {
+	Query          interface{} "$query"
+	OrderBy        interface{} "$orderby,omitempty"
+	Hint           interface{} "$hint,omitempty"
+	Explain        bool        "$explain,omitempty"
+	Snapshot       bool        "$snapshot,omitempty"
+	ReadPreference bson.D      "$readPreference,omitempty"
+	MaxScan        int         "$maxScan,omitempty"
+	MaxTimeMS      int         "$maxTimeMS,omitempty"
+	Comment        string      "$comment,omitempty"
+}
+
+func (op *queryOp) finalQuery(socket *mongoSocket) interface{} {
+	if op.flags&flagSlaveOk != 0 && len(op.serverTags) > 0 && socket.ServerInfo().Mongos {
+		op.hasOptions = true
+		op.options.ReadPreference = bson.D{{"mode", "secondaryPreferred"}, {"tags", op.serverTags}}
+	}
+	if op.hasOptions {
+		if op.query == nil {
+			var empty bson.D
+			op.options.Query = empty
+		} else {
+			op.options.Query = op.query
+		}
+		debugf("final query is %#v\n", &op.options)
+		return &op.options
+	}
+	return op.query
+}
+
+type getMoreOp struct {
+	collection string
+	limit      int32
+	cursorId   int64
+	replyFunc  replyFunc
+}
+
+type replyOp struct {
+	flags     uint32
+	cursorId  int64
+	firstDoc  int32
+	replyDocs int32
+}
+
+type insertOp struct {
+	collection string        // "database.collection"
+	documents  []interface{} // One or more documents to insert
+	flags      uint32
+}
+
+type updateOp struct {
+	collection string // "database.collection"
+	selector   interface{}
+	update     interface{}
+	flags      uint32
+}
+
+type deleteOp struct {
+	collection string // "database.collection"
+	selector   interface{}
+	flags      uint32
+}
+
+type killCursorsOp struct {
+	cursorIds []int64
+}
+
+type requestInfo struct {
+	bufferPos int
+	replyFunc replyFunc
+}
+
+func newSocket(server *mongoServer, conn net.Conn, timeout time.Duration) *mongoSocket {
+	socket := &mongoSocket{
+		conn:       conn,
+		addr:       server.Addr,
+		server:     server,
+		replyFuncs: make(map[uint32]replyFunc),
+	}
+	socket.gotNonce.L = &socket.Mutex
+	if err := socket.InitialAcquire(server.Info(), timeout); err != nil {
+		panic("newSocket: InitialAcquire returned error: " + err.Error())
+	}
+	stats.socketsAlive(+1)
+	debugf("Socket %p to %s: initialized", socket, socket.addr)
+	socket.resetNonce()
+	go socket.readLoop()
+	return socket
+}
+
+// Server returns the server that the socket is associated with.
+// It returns nil while the socket is cached in its respective server.
+func (socket *mongoSocket) Server() *mongoServer {
+	socket.Lock()
+	server := socket.server
+	socket.Unlock()
+	return server
+}
+
+// ServerInfo returns details for the server at the time the socket
+// was initially acquired.
+func (socket *mongoSocket) ServerInfo() *mongoServerInfo {
+	socket.Lock()
+	serverInfo := socket.serverInfo
+	socket.Unlock()
+	return serverInfo
+}
+
+// InitialAcquire obtains the first reference to the socket, either
+// right after the connection is made or once a recycled socket is
+// being put back in use.
+func (socket *mongoSocket) InitialAcquire(serverInfo *mongoServerInfo, timeout time.Duration) error {
+	socket.Lock()
+	if socket.references > 0 {
+		panic("Socket acquired out of cache with references")
+	}
+	if socket.dead != nil {
+		dead := socket.dead
+		socket.Unlock()
+		return dead
+	}
+	socket.references++
+	socket.serverInfo = serverInfo
+	socket.timeout = timeout
+	stats.socketsInUse(+1)
+	stats.socketRefs(+1)
+	socket.Unlock()
+	return nil
+}
+
+// Acquire obtains an additional reference to the socket.
+// The socket will only be recycled when it's released as many
+// times as it's been acquired.
+func (socket *mongoSocket) Acquire() (info *mongoServerInfo) {
+	socket.Lock()
+	if socket.references == 0 {
+		panic("Socket got non-initial acquire with references == 0")
+	}
+	// We'll track references to dead sockets as well.
+	// Caller is still supposed to release the socket.
+	socket.references++
+	stats.socketRefs(+1)
+	serverInfo := socket.serverInfo
+	socket.Unlock()
+	return serverInfo
+}
+
+// Release decrements a socket reference. The socket will be
+// recycled once its released as many times as it's been acquired.
+func (socket *mongoSocket) Release() {
+	socket.Lock()
+	if socket.references == 0 {
+		panic("socket.Release() with references == 0")
+	}
+	socket.references--
+	stats.socketRefs(-1)
+	if socket.references == 0 {
+		stats.socketsInUse(-1)
+		server := socket.server
+		socket.Unlock()
+		socket.LogoutAll()
+		// If the socket is dead server is nil.
+		if server != nil {
+			server.RecycleSocket(socket)
+		}
+	} else {
+		socket.Unlock()
+	}
+}
+
+// SetTimeout changes the timeout used on socket operations.
+func (socket *mongoSocket) SetTimeout(d time.Duration) {
+	socket.Lock()
+	socket.timeout = d
+	socket.Unlock()
+}
+
+type deadlineType int
+
+const (
+	readDeadline  deadlineType = 1
+	writeDeadline deadlineType = 2
+)
+
+func (socket *mongoSocket) updateDeadline(which deadlineType) {
+	var when time.Time
+	if socket.timeout > 0 {
+		when = time.Now().Add(socket.timeout)
+	}
+	whichstr := ""
+	switch which {
+	case readDeadline | writeDeadline:
+		whichstr = "read/write"
+		socket.conn.SetDeadline(when)
+	case readDeadline:
+		whichstr = "read"
+		socket.conn.SetReadDeadline(when)
+	case writeDeadline:
+		whichstr = "write"
+		socket.conn.SetWriteDeadline(when)
+	default:
+		panic("invalid parameter to updateDeadline")
+	}
+	debugf("Socket %p to %s: updated %s deadline to %s ahead (%s)", socket, socket.addr, whichstr, socket.timeout, when)
+}
+
+// Close terminates the socket use.
+func (socket *mongoSocket) Close() {
+	socket.kill(errors.New("Closed explicitly"), false)
+}
+
+func (socket *mongoSocket) kill(err error, abend bool) {
+	socket.Lock()
+	if socket.dead != nil {
+		debugf("Socket %p to %s: killed again: %s (previously: %s)", socket, socket.addr, err.Error(), socket.dead.Error())
+		socket.Unlock()
+		return
+	}
+	logf("Socket %p to %s: closing: %s (abend=%v)", socket, socket.addr, err.Error(), abend)
+	socket.dead = err
+	socket.conn.Close()
+	stats.socketsAlive(-1)
+	replyFuncs := socket.replyFuncs
+	socket.replyFuncs = make(map[uint32]replyFunc)
+	server := socket.server
+	socket.server = nil
+	socket.gotNonce.Broadcast()
+	socket.Unlock()
+	for _, replyFunc := range replyFuncs {
+		logf("Socket %p to %s: notifying replyFunc of closed socket: %s", socket, socket.addr, err.Error())
+		replyFunc(err, nil, -1, nil)
+	}
+	if abend {
+		server.AbendSocket(socket)
+	}
+}
+
+func (socket *mongoSocket) SimpleQuery(op *queryOp) (data []byte, err error) {
+	var wait, change sync.Mutex
+	var replyDone bool
+	var replyData []byte
+	var replyErr error
+	wait.Lock()
+	op.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
+		change.Lock()
+		if !replyDone {
+			replyDone = true
+			replyErr = err
+			if err == nil {
+				replyData = docData
+			}
+		}
+		change.Unlock()
+		wait.Unlock()
+	}
+	err = socket.Query(op)
+	if err != nil {
+		return nil, err
+	}
+	wait.Lock()
+	change.Lock()
+	data = replyData
+	err = replyErr
+	change.Unlock()
+	return data, err
+}
+
+func (socket *mongoSocket) Query(ops ...interface{}) (err error) {
+
+	if lops := socket.flushLogout(); len(lops) > 0 {
+		ops = append(lops, ops...)
+	}
+
+	buf := make([]byte, 0, 256)
+
+	// Serialize operations synchronously to avoid interrupting
+	// other goroutines while we can't really be sending data.
+	// Also, record id positions so that we can compute request
+	// ids at once later with the lock already held.
+	requests := make([]requestInfo, len(ops))
+	requestCount := 0
+
+	for _, op := range ops {
+		debugf("Socket %p to %s: serializing op: %#v", socket, socket.addr, op)
+		start := len(buf)
+		var replyFunc replyFunc
+		switch op := op.(type) {
+
+		case *updateOp:
+			buf = addHeader(buf, 2001)
+			buf = addInt32(buf, 0) // Reserved
+			buf = addCString(buf, op.collection)
+			buf = addInt32(buf, int32(op.flags))
+			debugf("Socket %p to %s: serializing selector document: %#v", socket, socket.addr, op.selector)
+			buf, err = addBSON(buf, op.selector)
+			if err != nil {
+				return err
+			}
+			debugf("Socket %p to %s: serializing update document: %#v", socket, socket.addr, op.update)
+			buf, err = addBSON(buf, op.update)
+			if err != nil {
+				return err
+			}
+
+		case *insertOp:
+			buf = addHeader(buf, 2002)
+			buf = addInt32(buf, int32(op.flags))
+			buf = addCString(buf, op.collection)
+			for _, doc := range op.documents {
+				debugf("Socket %p to %s: serializing document for insertion: %#v", socket, socket.addr, doc)
+				buf, err = addBSON(buf, doc)
+				if err != nil {
+					return err
+				}
+			}
+
+		case *queryOp:
+			buf = addHeader(buf, 2004)
+			buf = addInt32(buf, int32(op.flags))
+			buf = addCString(buf, op.collection)
+			buf = addInt32(buf, op.skip)
+			buf = addInt32(buf, op.limit)
+			buf, err = addBSON(buf, op.finalQuery(socket))
+			if err != nil {
+				return err
+			}
+			if op.selector != nil {
+				buf, err = addBSON(buf, op.selector)
+				if err != nil {
+					return err
+				}
+			}
+			replyFunc = op.replyFunc
+
+		case *getMoreOp:
+			buf = addHeader(buf, 2005)
+			buf = addInt32(buf, 0) // Reserved
+			buf = addCString(buf, op.collection)
+			buf = addInt32(buf, op.limit)
+			buf = addInt64(buf, op.cursorId)
+			replyFunc = op.replyFunc
+
+		case *deleteOp:
+			buf = addHeader(buf, 2006)
+			buf = addInt32(buf, 0) // Reserved
+			buf = addCString(buf, op.collection)
+			buf = addInt32(buf, int32(op.flags))
+			debugf("Socket %p to %s: serializing selector document: %#v", socket, socket.addr, op.selector)
+			buf, err = addBSON(buf, op.selector)
+			if err != nil {
+				return err
+			}
+
+		case *killCursorsOp:
+			buf = addHeader(buf, 2007)
+			buf = addInt32(buf, 0) // Reserved
+			buf = addInt32(buf, int32(len(op.cursorIds)))
+			for _, cursorId := range op.cursorIds {
+				buf = addInt64(buf, cursorId)
+			}
+
+		default:
+			panic("internal error: unknown operation type")
+		}
+
+		setInt32(buf, start, int32(len(buf)-start))
+
+		if replyFunc != nil {
+			request := &requests[requestCount]
+			request.replyFunc = replyFunc
+			request.bufferPos = start
+			requestCount++
+		}
+	}
+
+	// Buffer is ready for the pipe.  Lock, allocate ids, and enqueue.
+
+	socket.Lock()
+	if socket.dead != nil {
+		dead := socket.dead
+		socket.Unlock()
+		debugf("Socket %p to %s: failing query, already closed: %s", socket, socket.addr, socket.dead.Error())
+		// XXX This seems necessary in case the session is closed concurrently
+		// with a query being performed, but it's not yet tested:
+		for i := 0; i != requestCount; i++ {
+			request := &requests[i]
+			if request.replyFunc != nil {
+				request.replyFunc(dead, nil, -1, nil)
+			}
+		}
+		return dead
+	}
+
+	wasWaiting := len(socket.replyFuncs) > 0
+
+	// Reserve id 0 for requests which should have no responses.
+	requestId := socket.nextRequestId + 1
+	if requestId == 0 {
+		requestId++
+	}
+	socket.nextRequestId = requestId + uint32(requestCount)
+	for i := 0; i != requestCount; i++ {
+		request := &requests[i]
+		setInt32(buf, request.bufferPos+4, int32(requestId))
+		socket.replyFuncs[requestId] = request.replyFunc
+		requestId++
+	}
+
+	debugf("Socket %p to %s: sending %d op(s) (%d bytes)", socket, socket.addr, len(ops), len(buf))
+	stats.sentOps(len(ops))
+
+	socket.updateDeadline(writeDeadline)
+	_, err = socket.conn.Write(buf)
+	if !wasWaiting && requestCount > 0 {
+		socket.updateDeadline(readDeadline)
+	}
+	socket.Unlock()
+	return err
+}
+
+func fill(r net.Conn, b []byte) error {
+	l := len(b)
+	n, err := r.Read(b)
+	for n != l && err == nil {
+		var ni int
+		ni, err = r.Read(b[n:])
+		n += ni
+	}
+	return err
+}
+
+// Estimated minimum cost per socket: 1 goroutine + memory for the largest
+// document ever seen.
+func (socket *mongoSocket) readLoop() {
+	p := make([]byte, 36) // 16 from header + 20 from OP_REPLY fixed fields
+	s := make([]byte, 4)
+	conn := socket.conn // No locking, conn never changes.
+	for {
+		// XXX Handle timeouts, , etc
+		err := fill(conn, p)
+		if err != nil {
+			socket.kill(err, true)
+			return
+		}
+
+		totalLen := getInt32(p, 0)
+		responseTo := getInt32(p, 8)
+		opCode := getInt32(p, 12)
+
+		// Don't use socket.server.Addr here.  socket is not
+		// locked and socket.server may go away.
+		debugf("Socket %p to %s: got reply (%d bytes)", socket, socket.addr, totalLen)
+
+		_ = totalLen
+
+		if opCode != 1 {
+			socket.kill(errors.New("opcode != 1, corrupted data?"), true)
+			return
+		}
+
+		reply := replyOp{
+			flags:     uint32(getInt32(p, 16)),
+			cursorId:  getInt64(p, 20),
+			firstDoc:  getInt32(p, 28),
+			replyDocs: getInt32(p, 32),
+		}
+
+		stats.receivedOps(+1)
+		stats.receivedDocs(int(reply.replyDocs))
+
+		socket.Lock()
+		replyFunc, ok := socket.replyFuncs[uint32(responseTo)]
+		if ok {
+			delete(socket.replyFuncs, uint32(responseTo))
+		}
+		socket.Unlock()
+
+		if replyFunc != nil && reply.replyDocs == 0 {
+			replyFunc(nil, &reply, -1, nil)
+		} else {
+			for i := 0; i != int(reply.replyDocs); i++ {
+				err := fill(conn, s)
+				if err != nil {
+					if replyFunc != nil {
+						replyFunc(err, nil, -1, nil)
+					}
+					socket.kill(err, true)
+					return
+				}
+
+				b := make([]byte, int(getInt32(s, 0)))
+
+				// copy(b, s) in an efficient way.
+				b[0] = s[0]
+				b[1] = s[1]
+				b[2] = s[2]
+				b[3] = s[3]
+
+				err = fill(conn, b[4:])
+				if err != nil {
+					if replyFunc != nil {
+						replyFunc(err, nil, -1, nil)
+					}
+					socket.kill(err, true)
+					return
+				}
+
+				if globalDebug && globalLogger != nil {
+					m := bson.M{}
+					if err := bson.Unmarshal(b, m); err == nil {
+						debugf("Socket %p to %s: received document: %#v", socket, socket.addr, m)
+					}
+				}
+
+				if replyFunc != nil {
+					replyFunc(nil, &reply, i, b)
+				}
+
+				// XXX Do bound checking against totalLen.
+			}
+		}
+
+		socket.Lock()
+		if len(socket.replyFuncs) == 0 {
+			// Nothing else to read for now. Disable deadline.
+			socket.conn.SetReadDeadline(time.Time{})
+		} else {
+			socket.updateDeadline(readDeadline)
+		}
+		socket.Unlock()
+
+		// XXX Do bound checking against totalLen.
+	}
+}
+
+var emptyHeader = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+func addHeader(b []byte, opcode int) []byte {
+	i := len(b)
+	b = append(b, emptyHeader...)
+	// Enough for current opcodes.
+	b[i+12] = byte(opcode)
+	b[i+13] = byte(opcode >> 8)
+	return b
+}
+
+func addInt32(b []byte, i int32) []byte {
+	return append(b, byte(i), byte(i>>8), byte(i>>16), byte(i>>24))
+}
+
+func addInt64(b []byte, i int64) []byte {
+	return append(b, byte(i), byte(i>>8), byte(i>>16), byte(i>>24),
+		byte(i>>32), byte(i>>40), byte(i>>48), byte(i>>56))
+}
+
+func addCString(b []byte, s string) []byte {
+	b = append(b, []byte(s)...)
+	b = append(b, 0)
+	return b
+}
+
+func addBSON(b []byte, doc interface{}) ([]byte, error) {
+	if doc == nil {
+		return append(b, 5, 0, 0, 0, 0), nil
+	}
+	data, err := bson.Marshal(doc)
+	if err != nil {
+		return b, err
+	}
+	return append(b, data...), nil
+}
+
+func setInt32(b []byte, pos int, i int32) {
+	b[pos] = byte(i)
+	b[pos+1] = byte(i >> 8)
+	b[pos+2] = byte(i >> 16)
+	b[pos+3] = byte(i >> 24)
+}
+
+func getInt32(b []byte, pos int) int32 {
+	return (int32(b[pos+0])) |
+		(int32(b[pos+1]) << 8) |
+		(int32(b[pos+2]) << 16) |
+		(int32(b[pos+3]) << 24)
+}
+
+func getInt64(b []byte, pos int) int64 {
+	return (int64(b[pos+0])) |
+		(int64(b[pos+1]) << 8) |
+		(int64(b[pos+2]) << 16) |
+		(int64(b[pos+3]) << 24) |
+		(int64(b[pos+4]) << 32) |
+		(int64(b[pos+5]) << 40) |
+		(int64(b[pos+6]) << 48) |
+		(int64(b[pos+7]) << 56)
+}
diff --git a/vendor/gopkg.in/mgo.v2/stats.go b/vendor/gopkg.in/mgo.v2/stats.go
new file mode 100644
index 00000000..59723e60
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/stats.go
@@ -0,0 +1,147 @@
+// mgo - MongoDB driver for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// 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.
+
+package mgo
+
+import (
+	"sync"
+)
+
+var stats *Stats
+var statsMutex sync.Mutex
+
+func SetStats(enabled bool) {
+	statsMutex.Lock()
+	if enabled {
+		if stats == nil {
+			stats = &Stats{}
+		}
+	} else {
+		stats = nil
+	}
+	statsMutex.Unlock()
+}
+
+func GetStats() (snapshot Stats) {
+	statsMutex.Lock()
+	snapshot = *stats
+	statsMutex.Unlock()
+	return
+}
+
+func ResetStats() {
+	statsMutex.Lock()
+	debug("Resetting stats")
+	old := stats
+	stats = &Stats{}
+	// These are absolute values:
+	stats.Clusters = old.Clusters
+	stats.SocketsInUse = old.SocketsInUse
+	stats.SocketsAlive = old.SocketsAlive
+	stats.SocketRefs = old.SocketRefs
+	statsMutex.Unlock()
+	return
+}
+
+type Stats struct {
+	Clusters     int
+	MasterConns  int
+	SlaveConns   int
+	SentOps      int
+	ReceivedOps  int
+	ReceivedDocs int
+	SocketsAlive int
+	SocketsInUse int
+	SocketRefs   int
+}
+
+func (stats *Stats) cluster(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.Clusters += delta
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) conn(delta int, master bool) {
+	if stats != nil {
+		statsMutex.Lock()
+		if master {
+			stats.MasterConns += delta
+		} else {
+			stats.SlaveConns += delta
+		}
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) sentOps(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.SentOps += delta
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) receivedOps(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.ReceivedOps += delta
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) receivedDocs(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.ReceivedDocs += delta
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) socketsInUse(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.SocketsInUse += delta
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) socketsAlive(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.SocketsAlive += delta
+		statsMutex.Unlock()
+	}
+}
+
+func (stats *Stats) socketRefs(delta int) {
+	if stats != nil {
+		statsMutex.Lock()
+		stats.SocketRefs += delta
+		statsMutex.Unlock()
+	}
+}
diff --git a/vendor/gopkg.in/mgo.v2/testdb/client.pem b/vendor/gopkg.in/mgo.v2/testdb/client.pem
new file mode 100644
index 00000000..cc57eec7
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/client.pem
@@ -0,0 +1,44 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAwE2sl8YeTTSetwo9kykJ5mCZ/FtfPtn/0X4nOlTM2Qc/uWzA
+sjSYoSV4UkuOiWjKQQH2EDeXaltshOo7F0oCY5ozVeQe+phe987iKTvLtf7NoXJD
+KqNqR4Kb4ylbCrEky7+Xvw6yrrqw8qgWy+9VsrilR3q8LsETE9SBMtfp3BUaaNQp
+peNm+iAhx3uZSv3mdzSLFSA/o61kAyG0scLExYDjo/7xyMNQoloLvNmx4Io160+y
+lOz077/qqU620tmuDLRz1QdxK/bptmXTnsBCRxl+U8nzbwVZgWFENhXplbcN+SjN
+LhdnvTiU2qFhgZmc7ZtCKdPIpx3W6pH9bx7kTwIDAQABAoIBAQCOQygyo8NY9FuS
+J8ZDrvF+9+oS8fm1QorpDT2x/ngI+j7fSyAG9bgQRusLXpAVAWvWyb+iYa3nZbkT
+X0DVys+XpcTifr+YPc7L3sYbIPxkKBsxm5kq2vfN7Uart7V9ZG1HOfblxdbUQpKT
+AVzUA7vPWqATEC5VHEqjuerWlTqRr9YLZE/nkE7ICLISqdl4WDYfUYJwoXWfYkXQ
+Lfl5Qh2leyri9S3urvDrhnURTQ1lM182IbTRA+9rUiFzsRW+9U4HPY7Ao2Itp8dr
+GRP4rcq4TP+NcF0Ky64cNfKXCWmwqTBRFYAlTD6gwjN/s2BzvWD/2nlnc0DYAXrB
+TgFCPk7xAoGBAOwuHICwwTxtzrdWjuRGU3RxL4eLEXedtL8yon/yPci3e+8eploX
+1Fp0rEK2gIGDp/X8DiOtrKXih8XPusCwE/I3EvjHdI0RylLZXTPOp1Ei21dXRsiV
+YxcF+d5s11q5tJtF+5ISUeIz2iSc9Z2LBnb8JDK1jcCRa5Q212q3ZWW5AoGBANBw
+9CoMbxINLG1q0NvOOSwMKDk2OB+9JbQ5lwF4ijZl2I6qRoOCzQ3lBs0Qv/AeBjNR
+SerDs2+eWnIBUbgSdiqcOKnXAI/Qbl1IkVFYV/2g9m6dgu1fNWNBv8NIYDHCLfDx
+W3fpO5JMf+iE5XC4XqCfSBIME2yxPSGQjal6tB5HAoGAddYDzolhv/6hVoPPQ0F7
+PeuC5UOTcXSzy3k97kw0W0KAiStnoCengYIYuChKMVQ4ptgdTdvG+fTt/NnJuX2g
+Vgb4ZjtNgVzQ70kX4VNH04lqmkcnP8iY6dHHexwezls9KwNdouGVDSEFw6K0QOgu
+T4s5nDtNADkNzaMXE11xL7ECgYBoML3rstFmTY1ymB0Uck3jtaP5jR+axdpt7weL
+Zax4qooILhcXL6++DUhMAt5ecTOaPTzci7xKw/Xj3MLzZs8IV5R/WQhf2sj/+gEh
+jy5UijwEaNmEO74dAkWPoMLsvGpocMzO8JeldnXNTXi+0noCgfvtgXnIMAQlnfMh
+z0LviwKBgQCg5KR9JC4iuKses7Kfv2YelcO8vOZkRzBu3NdRWMsiJQC+qfetgd57
+RjRjlRWd1WCHJ5Kmx3hkUaZZOrX5knqfsRW3Nl0I74xgWl7Bli2eSJ9VWl59bcd6
+DqphhY7/gcW+QZlhXpnqbf0W8jB2gPhTYERyCBoS9LfhZWZu/11wuQ==
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIICyTCCAjKgAwIBAgIBATANBgkqhkiG9w0BAQUFADBcMQswCQYDVQQGEwJHTzEM
+MAoGA1UECBMDTUdPMQwwCgYDVQQHEwNNR08xDDAKBgNVBAoTA01HTzEPMA0GA1UE
+CxMGU2VydmVyMRIwEAYDVQQDEwlsb2NhbGhvc3QwHhcNMTQwOTI0MTQwMzUzWhcN
+MTUwOTI0MTQwMzUzWjBcMQswCQYDVQQGEwJHTzEMMAoGA1UECBMDTUdPMQwwCgYD
+VQQHEwNNR08xDDAKBgNVBAoTA01HTzEPMA0GA1UECxMGQ2xpZW50MRIwEAYDVQQD
+Ewlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDATayX
+xh5NNJ63Cj2TKQnmYJn8W18+2f/Rfic6VMzZBz+5bMCyNJihJXhSS46JaMpBAfYQ
+N5dqW2yE6jsXSgJjmjNV5B76mF73zuIpO8u1/s2hckMqo2pHgpvjKVsKsSTLv5e/
+DrKuurDyqBbL71WyuKVHerwuwRMT1IEy1+ncFRpo1Cml42b6ICHHe5lK/eZ3NIsV
+ID+jrWQDIbSxwsTFgOOj/vHIw1CiWgu82bHgijXrT7KU7PTvv+qpTrbS2a4MtHPV
+B3Er9um2ZdOewEJHGX5TyfNvBVmBYUQ2FemVtw35KM0uF2e9OJTaoWGBmZztm0Ip
+08inHdbqkf1vHuRPAgMBAAGjFzAVMBMGA1UdJQQMMAoGCCsGAQUFBwMCMA0GCSqG
+SIb3DQEBBQUAA4GBAJZD7idSIRzhGlJYARPKWnX2CxD4VVB0F5cH5Mlc2YnoUSU/
+rKuPZFuOYND3awKqez6K3rNb3+tQmNitmoOT8ImmX1uJKBo5w9tuo4B2MmLQcPMk
+3fhPePuQCjtlArSmKVrNTrYPkyB9NwKS6q0+FzseFTw9ZJUIKiO9sSjMe+HP
+-----END CERTIFICATE-----
diff --git a/vendor/gopkg.in/mgo.v2/testdb/dropall.js b/vendor/gopkg.in/mgo.v2/testdb/dropall.js
new file mode 100644
index 00000000..2059349d
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/dropall.js
@@ -0,0 +1,66 @@
+
+var ports = [40001, 40002, 40011, 40012, 40013, 40021, 40022, 40023, 40041, 40101, 40102, 40103, 40201, 40202, 40203]
+var auth = [40002, 40103, 40203, 40031]
+var db1 = new Mongo("localhost:40001")
+
+if (db1.getDB("admin").serverBuildInfo().OpenSSLVersion) {
+    ports.push(40003)
+    auth.push(40003)
+}
+
+for (var i in ports) {
+    var port = ports[i]
+    var server = "localhost:" + port
+    var mongo = new Mongo("localhost:" + port)
+    var admin = mongo.getDB("admin")
+
+    for (var j in auth) {
+        if (auth[j] == port) {
+            admin.auth("root", "rapadura")
+            admin.system.users.find().forEach(function(u) {
+                if (u.user == "root" || u.user == "reader") {
+                        return;
+                }
+                if (typeof admin.dropUser == "function") {
+                    mongo.getDB(u.db).dropUser(u.user);
+                } else {
+                    admin.removeUser(u.user);
+                }
+            })
+            break
+        }
+    }
+    var result = admin.runCommand({"listDatabases": 1})
+    for (var j = 0; j != 100; j++) {
+        if (typeof result.databases != "undefined" || notMaster(result)) {
+            break
+        }
+        result = admin.runCommand({"listDatabases": 1})
+    }
+    if (notMaster(result)) {
+        continue
+    }
+    if (typeof result.databases == "undefined") {
+        print("Could not list databases. Command result:")
+        print(JSON.stringify(result))
+        quit(12)
+    }
+    var dbs = result.databases
+    for (var j = 0; j != dbs.length; j++) {
+        var db = dbs[j]
+        switch (db.name) {
+        case "admin":
+        case "local":
+        case "config":
+            break
+        default:
+            mongo.getDB(db.name).dropDatabase()
+        }
+    }
+}
+
+function notMaster(result) {
+        return typeof result.errmsg != "undefined" && result.errmsg.indexOf("not master") >= 0
+}
+
+// vim:ts=4:sw=4:et
diff --git a/vendor/gopkg.in/mgo.v2/testdb/init.js b/vendor/gopkg.in/mgo.v2/testdb/init.js
new file mode 100644
index 00000000..8e5d8011
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/init.js
@@ -0,0 +1,110 @@
+//var settings = {heartbeatSleep: 0.05, heartbeatTimeout: 0.5}
+var settings = {};
+
+// We know the master of the first set (pri=1), but not of the second.
+var rs1cfg = {_id: "rs1",
+              members: [{_id: 1, host: "127.0.0.1:40011", priority: 1, tags: {rs1: "a"}},
+                        {_id: 2, host: "127.0.0.1:40012", priority: 0, tags: {rs1: "b"}},
+                        {_id: 3, host: "127.0.0.1:40013", priority: 0, tags: {rs1: "c"}}],
+              settings: settings}
+var rs2cfg = {_id: "rs2",
+              members: [{_id: 1, host: "127.0.0.1:40021", priority: 1, tags: {rs2: "a"}},
+                        {_id: 2, host: "127.0.0.1:40022", priority: 1, tags: {rs2: "b"}},
+                        {_id: 3, host: "127.0.0.1:40023", priority: 1, tags: {rs2: "c"}}],
+              settings: settings}
+var rs3cfg = {_id: "rs3",
+              members: [{_id: 1, host: "127.0.0.1:40031", priority: 1, tags: {rs3: "a"}},
+                        {_id: 2, host: "127.0.0.1:40032", priority: 1, tags: {rs3: "b"}},
+                        {_id: 3, host: "127.0.0.1:40033", priority: 1, tags: {rs3: "c"}}],
+              settings: settings}
+
+for (var i = 0; i != 60; i++) {
+	try {
+		db1 = new Mongo("127.0.0.1:40001").getDB("admin")
+		db2 = new Mongo("127.0.0.1:40002").getDB("admin")
+		rs1a = new Mongo("127.0.0.1:40011").getDB("admin")
+		rs2a = new Mongo("127.0.0.1:40021").getDB("admin")
+		rs3a = new Mongo("127.0.0.1:40031").getDB("admin")
+		break
+	} catch(err) {
+		print("Can't connect yet...")
+	}
+	sleep(1000)
+}
+
+function hasSSL() {
+    return Boolean(db1.serverBuildInfo().OpenSSLVersion)
+}
+
+rs1a.runCommand({replSetInitiate: rs1cfg})
+rs2a.runCommand({replSetInitiate: rs2cfg})
+rs3a.runCommand({replSetInitiate: rs3cfg})
+
+function configShards() {
+    cfg1 = new Mongo("127.0.0.1:40201").getDB("admin")
+    cfg1.runCommand({addshard: "127.0.0.1:40001"})
+    cfg1.runCommand({addshard: "rs1/127.0.0.1:40011"})
+
+    cfg2 = new Mongo("127.0.0.1:40202").getDB("admin")
+    cfg2.runCommand({addshard: "rs2/127.0.0.1:40021"})
+
+    cfg3 = new Mongo("127.0.0.1:40203").getDB("admin")
+    cfg3.runCommand({addshard: "rs3/127.0.0.1:40031"})
+}
+
+function configAuth() {
+    var addrs = ["127.0.0.1:40002", "127.0.0.1:40203", "127.0.0.1:40031"]
+    if (hasSSL()) {
+        addrs.push("127.0.0.1:40003")
+    }
+    for (var i in addrs) {
+        var db = new Mongo(addrs[i]).getDB("admin")
+        var v = db.serverBuildInfo().versionArray
+        if (v < [2, 5]) {
+            db.addUser("root", "rapadura")
+        } else {
+            db.createUser({user: "root", pwd: "rapadura", roles: ["root"]})
+        }
+        db.auth("root", "rapadura")
+        if (v >= [2, 6]) {
+            db.createUser({user: "reader", pwd: "rapadura", roles: ["readAnyDatabase"]})
+        } else if (v >= [2, 4]) {
+            db.addUser({user: "reader", pwd: "rapadura", roles: ["readAnyDatabase"]})
+        } else {
+            db.addUser("reader", "rapadura", true)
+        }
+    }
+}
+
+function countHealthy(rs) {
+    var status = rs.runCommand({replSetGetStatus: 1})
+    var count = 0
+    if (typeof status.members != "undefined") {
+        for (var i = 0; i != status.members.length; i++) {
+            var m = status.members[i]
+            if (m.health == 1 && (m.state == 1 || m.state == 2)) {
+                count += 1
+            }
+        }
+    }
+    return count
+}
+
+var totalRSMembers = rs1cfg.members.length + rs2cfg.members.length + rs3cfg.members.length
+
+for (var i = 0; i != 60; i++) {
+    var count = countHealthy(rs1a) + countHealthy(rs2a) + countHealthy(rs3a)
+    print("Replica sets have", count, "healthy nodes.")
+    if (count == totalRSMembers) {
+        sleep(2000)
+        configShards()
+        configAuth()
+        quit(0)
+    }
+    sleep(1000)
+}
+
+print("Replica sets didn't sync up properly.")
+quit(12)
+
+// vim:ts=4:sw=4:et
diff --git a/vendor/gopkg.in/mgo.v2/testdb/server.pem b/vendor/gopkg.in/mgo.v2/testdb/server.pem
new file mode 100644
index 00000000..16fbef16
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/server.pem
@@ -0,0 +1,33 @@
+-----BEGIN CERTIFICATE-----
+MIIC+DCCAmGgAwIBAgIJAJ5pBAq2HXAsMA0GCSqGSIb3DQEBBQUAMFwxCzAJBgNV
+BAYTAkdPMQwwCgYDVQQIEwNNR08xDDAKBgNVBAcTA01HTzEMMAoGA1UEChMDTUdP
+MQ8wDQYDVQQLEwZTZXJ2ZXIxEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xNDA5MjQx
+MzUxMTBaFw0xNTA5MjQxMzUxMTBaMFwxCzAJBgNVBAYTAkdPMQwwCgYDVQQIEwNN
+R08xDDAKBgNVBAcTA01HTzEMMAoGA1UEChMDTUdPMQ8wDQYDVQQLEwZTZXJ2ZXIx
+EjAQBgNVBAMTCWxvY2FsaG9zdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA
+pQ5wO2L23xMI4PzpVt/Ftvez82IvA9amwr3fUd7RjlYwiFsFeMnG24a4CUoOeKF0
+fpQWc9rmCs0EeP5ofZ2otOsfxoVWXZAZWdgauuwlYB6EeFaAMH3fxVH3IiH+21RR
+q2w9sH/s4fqh5stavUfyPdVmCcb8NW0jD8jlqniJL0kCAwEAAaOBwTCBvjAdBgNV
+HQ4EFgQUjyVWGMHBrmPDGwCY5VusHsKIpzIwgY4GA1UdIwSBhjCBg4AUjyVWGMHB
+rmPDGwCY5VusHsKIpzKhYKReMFwxCzAJBgNVBAYTAkdPMQwwCgYDVQQIEwNNR08x
+DDAKBgNVBAcTA01HTzEMMAoGA1UEChMDTUdPMQ8wDQYDVQQLEwZTZXJ2ZXIxEjAQ
+BgNVBAMTCWxvY2FsaG9zdIIJAJ5pBAq2HXAsMAwGA1UdEwQFMAMBAf8wDQYJKoZI
+hvcNAQEFBQADgYEAa65TgDKp3SRUDNAILSuQOCEbenWh/DMPL4vTVgo/Dxd4emoO
+7i8/4HMTa0XeYIVbAsxO+dqtxqt32IcV7DurmQozdUZ7q0ueJRXon6APnCN0IqPC
+sF71w63xXfpmnvTAfQXi7x6TUAyAQ2nScHExAjzc000DF1dO/6+nIINqNQE=
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQClDnA7YvbfEwjg/OlW38W297PzYi8D1qbCvd9R3tGOVjCIWwV4
+ycbbhrgJSg54oXR+lBZz2uYKzQR4/mh9nai06x/GhVZdkBlZ2Bq67CVgHoR4VoAw
+fd/FUfciIf7bVFGrbD2wf+zh+qHmy1q9R/I91WYJxvw1bSMPyOWqeIkvSQIDAQAB
+AoGABA9S22MXx2zkbwRJiQWAC3wURQxJM8L33xpkf9MHPIUKNJBolgwAhC3QIQpd
+SMJP5z0lQDxGJEXesksvrsdN+vsgbleRfQsAIcY/rEhr9h8m6auM08f+69oIX32o
+aTOWJJRofjbgzE5c/RijqhIaYGdq54a0EE9mAaODwZoa2/ECQQDRGrIRI5L3pdRA
+yifDKNjvAFOk6TbdGe+J9zHFw4F7bA2In/b+rno9vrj+EanOevD8LRLzeFshzXrG
+WQFzZ69/AkEAyhLSY7WNiQTeJWCwXawVnoSl5AMSRYFA/A2sEUokfORR5BS7gqvL
+mmEKmvslnZp5qlMtM4AyrW2OaoGvE6sFNwJACB3xK5kl61cUli9Cu+CqCx0IIi6r
+YonPMpvV4sdkD1ZycAtFmz1KoXr102b8IHfFQwS855aUcwt26Jwr4j70IQJAXv9+
+PTXq9hF9xiCwiTkPaNh/jLQM8PQU8uoSjIZIpRZJkWpVxNay/z7D15xeULuAmxxD
+UcThDjtFCrkw75Qk/QJAFfcM+5r31R1RrBGM1QPKwDqkFTGsFKnMWuS/pXyLTTOv
+I+In9ZJyA/R5zKeJZjM7xtZs0ANU9HpOpgespq6CvA==
+-----END RSA PRIVATE KEY-----
diff --git a/vendor/gopkg.in/mgo.v2/testdb/setup.sh b/vendor/gopkg.in/mgo.v2/testdb/setup.sh
new file mode 100644
index 00000000..317e8e5a
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/setup.sh
@@ -0,0 +1,58 @@
+#!/bin/sh -e
+
+start() {
+    mkdir _testdb
+    cd _testdb
+    mkdir db1 db2 db3 rs1a rs1b rs1c rs2a rs2b rs2c rs3a rs3b rs3c rs4a cfg1 cfg2 cfg3
+    cp ../testdb/supervisord.conf supervisord.conf
+    cp ../testdb/server.pem server.pem
+    echo keyfile > keyfile
+    chmod 600 keyfile
+    COUNT=$(grep '^\[program' supervisord.conf | wc -l | tr -d ' ')
+    if ! mongod --help | grep -q -- --ssl; then
+        COUNT=$(($COUNT - 1))
+    fi
+    echo "Running supervisord..."
+    supervisord || ( echo "Supervisord failed executing ($?)" && exit 1 )
+    echo "Supervisord is up, starting $COUNT processes..."
+    for i in $(seq 10); do
+        RUNNING=$(supervisorctl status | grep RUNNING | wc -l | tr -d ' ')
+        echo "$RUNNING processes running..."
+        if [ x$COUNT = x$RUNNING ]; then
+            echo "Running setup.js with mongo..."
+            mongo --nodb ../testdb/init.js
+            exit 0
+        fi
+        sleep 1
+    done
+    echo "Failed to start all processes. Check out what's up at $PWD now!"
+    exit 1
+}
+
+stop() {
+    if [ -d _testdb ]; then
+        echo "Shutting down test cluster..."
+        (cd _testdb && supervisorctl shutdown)
+        rm -rf _testdb
+    fi
+}
+
+
+if [ ! -f suite_test.go ]; then
+    echo "This script must be run from within the source directory."
+    exit 1
+fi
+
+case "$1" in
+
+    start)
+        start $2
+        ;;
+
+    stop)
+        stop $2
+        ;;
+
+esac
+
+# vim:ts=4:sw=4:et
diff --git a/vendor/gopkg.in/mgo.v2/testdb/supervisord.conf b/vendor/gopkg.in/mgo.v2/testdb/supervisord.conf
new file mode 100644
index 00000000..1c2b859a
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/supervisord.conf
@@ -0,0 +1,65 @@
+[supervisord]
+logfile = %(here)s/supervisord.log
+pidfile = %(here)s/supervisord.pid
+directory = %(here)s
+#nodaemon = true
+
+[inet_http_server]
+port = 127.0.0.1:9001
+
+[supervisorctl]
+serverurl = http://127.0.0.1:9001
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+[program:db1]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --dbpath %(here)s/db1 --bind_ip=127.0.0.1 --port 40001
+
+[program:db2]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --dbpath %(here)s/db2 --bind_ip=127.0.0.1 --port 40002 --auth 
+
+[program:db3]
+command = mongod -nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --dbpath %(here)s/db3 --bind_ip=127.0.0.1 --port 40003 --auth --sslMode preferSSL --sslCAFile %(here)s/server.pem --sslPEMKeyFile %(here)s/server.pem
+
+[program:rs1a]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs1 --dbpath %(here)s/rs1a --bind_ip=127.0.0.1 --port 40011
+[program:rs1b]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs1 --dbpath %(here)s/rs1b --bind_ip=127.0.0.1 --port 40012
+[program:rs1c]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs1 --dbpath %(here)s/rs1c --bind_ip=127.0.0.1 --port 40013
+ 
+[program:rs2a]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs2 --dbpath %(here)s/rs2a --bind_ip=127.0.0.1 --port 40021
+[program:rs2b]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs2 --dbpath %(here)s/rs2b --bind_ip=127.0.0.1 --port 40022
+[program:rs2c]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs2 --dbpath %(here)s/rs2c --bind_ip=127.0.0.1 --port 40023
+
+[program:rs3a]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs3 --dbpath %(here)s/rs3a --bind_ip=127.0.0.1 --port 40031 --auth --keyFile=%(here)s/keyfile
+[program:rs3b]                                                                                                                                                                                                      
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs3 --dbpath %(here)s/rs3b --bind_ip=127.0.0.1 --port 40032 --auth --keyFile=%(here)s/keyfile
+[program:rs3c]                                                                                                                                                                                                      
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs3 --dbpath %(here)s/rs3c --bind_ip=127.0.0.1 --port 40033 --auth --keyFile=%(here)s/keyfile
+
+[program:rs4a]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --shardsvr --replSet rs4 --dbpath %(here)s/rs4a --bind_ip=127.0.0.1 --port 40041
+
+[program:cfg1]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --configsvr --dbpath %(here)s/cfg1 --bind_ip=127.0.0.1 --port 40101
+
+[program:cfg2]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --configsvr --dbpath %(here)s/cfg2 --bind_ip=127.0.0.1 --port 40102
+
+[program:cfg3]
+command = mongod --nohttpinterface --noprealloc --nojournal --smallfiles --nssize=1 --oplogSize=1 --configsvr --dbpath %(here)s/cfg3 --bind_ip=127.0.0.1 --port 40103 --auth --keyFile=%(here)s/keyfile
+
+[program:s1]
+command = mongos --configdb 127.0.0.1:40101 --bind_ip=127.0.0.1 --port 40201 --chunkSize 1
+
+[program:s2]
+command = mongos --configdb 127.0.0.1:40102 --bind_ip=127.0.0.1 --port 40202 --chunkSize 1
+
+[program:s3]
+command = mongos --configdb 127.0.0.1:40103 --bind_ip=127.0.0.1 --port 40203 --chunkSize 1 --keyFile=%(here)s/keyfile
diff --git a/vendor/gopkg.in/mgo.v2/testdb/wait.js b/vendor/gopkg.in/mgo.v2/testdb/wait.js
new file mode 100644
index 00000000..de0d6607
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testdb/wait.js
@@ -0,0 +1,58 @@
+// We know the master of the first set (pri=1), but not of the second.
+var settings = {}
+var rs1cfg = {_id: "rs1",
+              members: [{_id: 1, host: "127.0.0.1:40011", priority: 1},
+                        {_id: 2, host: "127.0.0.1:40012", priority: 0},
+                        {_id: 3, host: "127.0.0.1:40013", priority: 0}]}
+var rs2cfg = {_id: "rs2",
+              members: [{_id: 1, host: "127.0.0.1:40021", priority: 1},
+                        {_id: 2, host: "127.0.0.1:40022", priority: 1},
+                        {_id: 3, host: "127.0.0.1:40023", priority: 0}]}
+var rs3cfg = {_id: "rs3",
+              members: [{_id: 1, host: "127.0.0.1:40031", priority: 1},
+                        {_id: 2, host: "127.0.0.1:40032", priority: 1},
+                        {_id: 3, host: "127.0.0.1:40033", priority: 1}],
+              settings: settings}
+
+for (var i = 0; i != 60; i++) {
+	try {
+		rs1a = new Mongo("127.0.0.1:40011").getDB("admin")
+		rs2a = new Mongo("127.0.0.1:40021").getDB("admin")
+		rs3a = new Mongo("127.0.0.1:40031").getDB("admin")
+		rs3a.auth("root", "rapadura")
+		db1 = new Mongo("127.0.0.1:40001").getDB("admin")
+		db2 = new Mongo("127.0.0.1:40002").getDB("admin")
+		break
+	} catch(err) {
+		print("Can't connect yet...")
+	}
+	sleep(1000)
+}
+
+function countHealthy(rs) {
+    var status = rs.runCommand({replSetGetStatus: 1})
+    var count = 0
+    if (typeof status.members != "undefined") {
+        for (var i = 0; i != status.members.length; i++) {
+            var m = status.members[i]
+            if (m.health == 1 && (m.state == 1 || m.state == 2)) {
+                count += 1
+            }
+        }
+    }
+    return count
+}
+
+var totalRSMembers = rs1cfg.members.length + rs2cfg.members.length + rs3cfg.members.length
+
+for (var i = 0; i != 60; i++) {
+    var count = countHealthy(rs1a) + countHealthy(rs2a) + countHealthy(rs3a)
+    print("Replica sets have", count, "healthy nodes.")
+    if (count == totalRSMembers) {
+        quit(0)
+    }
+    sleep(1000)
+}
+
+print("Replica sets didn't sync up properly.")
+quit(12)
diff --git a/vendor/gopkg.in/mgo.v2/testserver/testserver.go b/vendor/gopkg.in/mgo.v2/testserver/testserver.go
new file mode 100644
index 00000000..cab88d7b
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/testserver/testserver.go
@@ -0,0 +1,196 @@
+package testserver
+
+import (
+	"bytes"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"strconv"
+	"time"
+
+	"gopkg.in/mgo.v2"
+	"gopkg.in/tomb.v2"
+)
+
+// TestServer controls a MongoDB server process to be used within test suites.
+//
+// The test server is started when Session is called the first time and should
+// remain running for the duration of all tests, with the Wipe method being
+// called between tests (before each of them) to clear stored data. After all tests
+// are done, the Stop method should be called to stop the test server.
+//
+// Before the TestServer is used the SetPath method must be called to define
+// the location for the database files to be stored.
+type TestServer struct {
+	session *mgo.Session
+	output  bytes.Buffer
+	server  *exec.Cmd
+	dbpath  string
+	host    string
+	tomb    tomb.Tomb
+}
+
+// SetPath defines the path to the directory where the database files will be
+// stored if it is started. The directory path itself is not created or removed
+// by the test helper.
+func (ts *TestServer) SetPath(dbpath string) {
+	ts.dbpath = dbpath
+}
+
+func (ts *TestServer) start() {
+	if ts.server != nil {
+		panic("TestServer already started")
+	}
+	if ts.dbpath == "" {
+		panic("TestServer.SetPath must be called before using the server")
+	}
+	mgo.SetStats(true)
+	l, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		panic("unable to listen on a local address: " + err.Error())
+	}
+	addr := l.Addr().(*net.TCPAddr)
+	l.Close()
+	ts.host = addr.String()
+
+	args := []string{
+		"--dbpath", ts.dbpath,
+		"--bind_ip", "127.0.0.1",
+		"--port", strconv.Itoa(addr.Port),
+		"--nssize", "1",
+		"--noprealloc",
+		"--smallfiles",
+		"--nojournal",
+	}
+	ts.tomb = tomb.Tomb{}
+	ts.server = exec.Command("mongod", args...)
+	ts.server.Stdout = &ts.output
+	ts.server.Stderr = &ts.output
+	err = ts.server.Start()
+	if err != nil {
+		panic(err)
+	}
+	ts.tomb.Go(ts.monitor)
+	ts.Wipe()
+}
+
+func (ts *TestServer) monitor() error {
+	ts.server.Process.Wait()
+	if ts.tomb.Alive() {
+		// Present some debugging information.
+		fmt.Fprintf(os.Stderr, "---- mongod process died unexpectedly:\n")
+		fmt.Fprintf(os.Stderr, "%s", ts.output.Bytes())
+		fmt.Fprintf(os.Stderr, "---- mongod processes running right now:\n")
+		cmd := exec.Command("/bin/sh", "-c", "ps auxw | grep mongod")
+		cmd.Stdout = os.Stderr
+		cmd.Stderr = os.Stderr
+		cmd.Run()
+		fmt.Fprintf(os.Stderr, "----------------------------------------\n")
+
+		panic("mongod process died unexpectedly")
+	}
+	return nil
+}
+
+// Stop stops the test server process, if it is running.
+//
+// It's okay to call Stop multiple times. After the test server is
+// stopped it cannot be restarted.
+//
+// All database sessions must be closed before or while the Stop method
+// is running. Otherwise Stop will panic after a timeout informing that
+// there is a session leak.
+func (ts *TestServer) Stop() {
+	if ts.session != nil {
+		ts.checkSessions()
+		if ts.session != nil {
+			ts.session.Close()
+			ts.session = nil
+		}
+	}
+	if ts.server != nil {
+		ts.tomb.Kill(nil)
+		ts.server.Process.Kill()
+		select {
+		case <-ts.tomb.Dead():
+		case <-time.After(5 * time.Second):
+			panic("timeout waiting for mongod process to die")
+		}
+		ts.server = nil
+	}
+}
+
+// Session returns a new session to the server. The returned session
+// must be closed after the test is done with it.
+//
+// The first Session obtained from a TestServer will start it.
+func (ts *TestServer) Session() *mgo.Session {
+	if ts.server == nil {
+		ts.start()
+	}
+	if ts.session == nil {
+		mgo.ResetStats()
+		var err error
+		ts.session, err = mgo.Dial(ts.host + "/test")
+		if err != nil {
+			panic(err)
+		}
+	}
+	return ts.session.Copy()
+}
+
+// checkSessions ensures all mgo sessions opened were properly closed.
+// For slightly faster tests, it may be disabled setting the
+// environmnet variable CHECK_SESSIONS to 0.
+func (ts *TestServer) checkSessions() {
+	if check := os.Getenv("CHECK_SESSIONS"); check == "0" || ts.server == nil || ts.session == nil {
+		return
+	}
+	ts.session.Close()
+	ts.session = nil
+	for i := 0; i < 100; i++ {
+		stats := mgo.GetStats()
+		if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 {
+			return
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	panic("There are mgo sessions still alive.")
+}
+
+// Wipe drops all created databases and their data.
+//
+// The MongoDB server remains running if it was prevoiusly running,
+// or stopped if it was previously stopped.
+//
+// All database sessions must be closed before or while the Wipe method
+// is running. Otherwise Wipe will panic after a timeout informing that
+// there is a session leak.
+func (ts *TestServer) Wipe() {
+	if ts.server == nil || ts.session == nil {
+		return
+	}
+	ts.checkSessions()
+	sessionUnset := ts.session == nil
+	session := ts.Session()
+	defer session.Close()
+	if sessionUnset {
+		ts.session.Close()
+		ts.session = nil
+	}
+	names, err := session.DatabaseNames()
+	if err != nil {
+		panic(err)
+	}
+	for _, name := range names {
+		switch name {
+		case "admin", "local", "config":
+		default:
+			err = session.DB(name).DropDatabase()
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+}
diff --git a/vendor/gopkg.in/mgo.v2/txn/chaos.go b/vendor/gopkg.in/mgo.v2/txn/chaos.go
new file mode 100644
index 00000000..c98adb91
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/txn/chaos.go
@@ -0,0 +1,68 @@
+package txn
+
+import (
+	mrand "math/rand"
+	"time"
+)
+
+var chaosEnabled = false
+var chaosSetting Chaos
+
+// Chaos holds parameters for the failure injection mechanism.
+type Chaos struct {
+	// KillChance is the 0.0 to 1.0 chance that a given checkpoint
+	// within the algorithm will raise an interruption that will
+	// stop the procedure.
+	KillChance float64
+
+	// SlowdownChance is the 0.0 to 1.0 chance that a given checkpoint
+	// within the algorithm will be delayed by Slowdown before
+	// continuing.
+	SlowdownChance float64
+	Slowdown       time.Duration
+
+	// If Breakpoint is set, the above settings will only affect the
+	// named breakpoint.
+	Breakpoint string
+}
+
+// SetChaos sets the failure injection parameters to c.
+func SetChaos(c Chaos) {
+	chaosSetting = c
+	chaosEnabled = c.KillChance > 0 || c.SlowdownChance > 0
+}
+
+func chaos(bpname string) {
+	if !chaosEnabled {
+		return
+	}
+	switch chaosSetting.Breakpoint {
+	case "", bpname:
+		kc := chaosSetting.KillChance
+		if kc > 0 && mrand.Intn(1000) < int(kc*1000) {
+			panic(chaosError{})
+		}
+		if bpname == "insert" {
+			return
+		}
+		sc := chaosSetting.SlowdownChance
+		if sc > 0 && mrand.Intn(1000) < int(sc*1000) {
+			time.Sleep(chaosSetting.Slowdown)
+		}
+	}
+}
+
+type chaosError struct{}
+
+func (f *flusher) handleChaos(err *error) {
+	v := recover()
+	if v == nil {
+		return
+	}
+	if _, ok := v.(chaosError); ok {
+		f.debugf("Killed by chaos!")
+		*err = ErrChaos
+		return
+	}
+	panic(v)
+}
diff --git a/vendor/gopkg.in/mgo.v2/txn/debug.go b/vendor/gopkg.in/mgo.v2/txn/debug.go
new file mode 100644
index 00000000..8224bb31
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/txn/debug.go
@@ -0,0 +1,109 @@
+package txn
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"sync/atomic"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+var (
+	debugEnabled bool
+	logger       log_Logger
+)
+
+type log_Logger interface {
+	Output(calldepth int, s string) error
+}
+
+// Specify the *log.Logger where logged messages should be sent to.
+func SetLogger(l log_Logger) {
+	logger = l
+}
+
+// SetDebug enables or disables debugging.
+func SetDebug(debug bool) {
+	debugEnabled = debug
+}
+
+var ErrChaos = fmt.Errorf("interrupted by chaos")
+
+var debugId uint32
+
+func debugPrefix() string {
+	d := atomic.AddUint32(&debugId, 1) - 1
+	s := make([]byte, 0, 10)
+	for i := uint(0); i < 8; i++ {
+		s = append(s, "abcdefghijklmnop"[(d>>(4*i))&0xf])
+		if d>>(4*(i+1)) == 0 {
+			break
+		}
+	}
+	s = append(s, ')', ' ')
+	return string(s)
+}
+
+func logf(format string, args ...interface{}) {
+	if logger != nil {
+		logger.Output(2, fmt.Sprintf(format, argsForLog(args)...))
+	}
+}
+
+func debugf(format string, args ...interface{}) {
+	if debugEnabled && logger != nil {
+		logger.Output(2, fmt.Sprintf(format, argsForLog(args)...))
+	}
+}
+
+func argsForLog(args []interface{}) []interface{} {
+	for i, arg := range args {
+		switch v := arg.(type) {
+		case bson.ObjectId:
+			args[i] = v.Hex()
+		case []bson.ObjectId:
+			lst := make([]string, len(v))
+			for j, id := range v {
+				lst[j] = id.Hex()
+			}
+			args[i] = lst
+		case map[docKey][]bson.ObjectId:
+			buf := &bytes.Buffer{}
+			var dkeys docKeys
+			for dkey := range v {
+				dkeys = append(dkeys, dkey)
+			}
+			sort.Sort(dkeys)
+			for i, dkey := range dkeys {
+				if i > 0 {
+					buf.WriteByte(' ')
+				}
+				buf.WriteString(fmt.Sprintf("%v: {", dkey))
+				for j, id := range v[dkey] {
+					if j > 0 {
+						buf.WriteByte(' ')
+					}
+					buf.WriteString(id.Hex())
+				}
+				buf.WriteByte('}')
+			}
+			args[i] = buf.String()
+		case map[docKey][]int64:
+			buf := &bytes.Buffer{}
+			var dkeys docKeys
+			for dkey := range v {
+				dkeys = append(dkeys, dkey)
+			}
+			sort.Sort(dkeys)
+			for i, dkey := range dkeys {
+				if i > 0 {
+					buf.WriteByte(' ')
+				}
+				buf.WriteString(fmt.Sprintf("%v: %v", dkey, v[dkey]))
+			}
+			args[i] = buf.String()
+		}
+	}
+	return args
+}
diff --git a/vendor/gopkg.in/mgo.v2/txn/flusher.go b/vendor/gopkg.in/mgo.v2/txn/flusher.go
new file mode 100644
index 00000000..b890e60c
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/txn/flusher.go
@@ -0,0 +1,985 @@
+package txn
+
+import (
+	"fmt"
+
+	"gopkg.in/mgo.v2"
+	"gopkg.in/mgo.v2/bson"
+)
+
+func flush(r *Runner, t *transaction) error {
+	f := &flusher{
+		Runner:   r,
+		goal:     t,
+		goalKeys: make(map[docKey]bool),
+		queue:    make(map[docKey][]token),
+		debugId:  debugPrefix(),
+	}
+	for _, dkey := range f.goal.docKeys() {
+		f.goalKeys[dkey] = true
+	}
+	return f.run()
+}
+
+type flusher struct {
+	*Runner
+	goal     *transaction
+	goalKeys map[docKey]bool
+	queue    map[docKey][]token
+	debugId  string
+}
+
+func (f *flusher) run() (err error) {
+	if chaosEnabled {
+		defer f.handleChaos(&err)
+	}
+
+	f.debugf("Processing %s", f.goal)
+	seen := make(map[bson.ObjectId]*transaction)
+	if err := f.recurse(f.goal, seen); err != nil {
+		return err
+	}
+	if f.goal.done() {
+		return nil
+	}
+
+	// Sparse workloads will generally be managed entirely by recurse.
+	// Getting here means one or more transactions have dependencies
+	// and perhaps cycles.
+
+	// Build successors data for Tarjan's sort. Must consider
+	// that entries in txn-queue are not necessarily valid.
+	successors := make(map[bson.ObjectId][]bson.ObjectId)
+	ready := true
+	for _, dqueue := range f.queue {
+	NextPair:
+		for i := 0; i < len(dqueue); i++ {
+			pred := dqueue[i]
+			predid := pred.id()
+			predt := seen[predid]
+			if predt == nil || predt.Nonce != pred.nonce() {
+				continue
+			}
+			predsuccids, ok := successors[predid]
+			if !ok {
+				successors[predid] = nil
+			}
+
+			for j := i + 1; j < len(dqueue); j++ {
+				succ := dqueue[j]
+				succid := succ.id()
+				succt := seen[succid]
+				if succt == nil || succt.Nonce != succ.nonce() {
+					continue
+				}
+				if _, ok := successors[succid]; !ok {
+					successors[succid] = nil
+				}
+
+				// Found a valid pred/succ pair.
+				i = j - 1
+				for _, predsuccid := range predsuccids {
+					if predsuccid == succid {
+						continue NextPair
+					}
+				}
+				successors[predid] = append(predsuccids, succid)
+				if succid == f.goal.Id {
+					// There are still pre-requisites to handle.
+					ready = false
+				}
+				continue NextPair
+			}
+		}
+	}
+	f.debugf("Queues: %v", f.queue)
+	f.debugf("Successors: %v", successors)
+	if ready {
+		f.debugf("Goal %s has no real pre-requisites", f.goal)
+		return f.advance(f.goal, nil, true)
+	}
+
+	// Robert Tarjan's algorithm for detecting strongly-connected
+	// components is used for topological sorting and detecting
+	// cycles at once. The order in which transactions are applied
+	// in commonly affected documents must be a global agreement.
+	sorted := tarjanSort(successors)
+	if debugEnabled {
+		f.debugf("Tarjan output: %v", sorted)
+	}
+	pull := make(map[bson.ObjectId]*transaction)
+	for i := len(sorted) - 1; i >= 0; i-- {
+		scc := sorted[i]
+		f.debugf("Flushing %v", scc)
+		if len(scc) == 1 {
+			pull[scc[0]] = seen[scc[0]]
+		}
+		for _, id := range scc {
+			if err := f.advance(seen[id], pull, true); err != nil {
+				return err
+			}
+		}
+		if len(scc) > 1 {
+			for _, id := range scc {
+				pull[id] = seen[id]
+			}
+		}
+	}
+	return nil
+}
+
+func (f *flusher) recurse(t *transaction, seen map[bson.ObjectId]*transaction) error {
+	seen[t.Id] = t
+	err := f.advance(t, nil, false)
+	if err != errPreReqs {
+		return err
+	}
+	for _, dkey := range t.docKeys() {
+		for _, dtt := range f.queue[dkey] {
+			id := dtt.id()
+			if seen[id] != nil {
+				continue
+			}
+			qt, err := f.load(id)
+			if err != nil {
+				return err
+			}
+			err = f.recurse(qt, seen)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (f *flusher) advance(t *transaction, pull map[bson.ObjectId]*transaction, force bool) error {
+	for {
+		switch t.State {
+		case tpreparing, tprepared:
+			revnos, err := f.prepare(t, force)
+			if err != nil {
+				return err
+			}
+			if t.State != tprepared {
+				continue
+			}
+			if err = f.assert(t, revnos, pull); err != nil {
+				return err
+			}
+			if t.State != tprepared {
+				continue
+			}
+			if err = f.checkpoint(t, revnos); err != nil {
+				return err
+			}
+		case tapplying:
+			return f.apply(t, pull)
+		case taborting:
+			return f.abortOrReload(t, nil, pull)
+		case tapplied, taborted:
+			return nil
+		default:
+			panic(fmt.Errorf("transaction in unknown state: %q", t.State))
+		}
+	}
+	panic("unreachable")
+}
+
+type stash string
+
+const (
+	stashStable stash = ""
+	stashInsert stash = "insert"
+	stashRemove stash = "remove"
+)
+
+type txnInfo struct {
+	Queue  []token       `bson:"txn-queue"`
+	Revno  int64         `bson:"txn-revno,omitempty"`
+	Insert bson.ObjectId `bson:"txn-insert,omitempty"`
+	Remove bson.ObjectId `bson:"txn-remove,omitempty"`
+}
+
+type stashState string
+
+const (
+	stashNew       stashState = ""
+	stashInserting stashState = "inserting"
+)
+
+var txnFields = bson.D{{"txn-queue", 1}, {"txn-revno", 1}, {"txn-remove", 1}, {"txn-insert", 1}}
+
+var errPreReqs = fmt.Errorf("transaction has pre-requisites and force is false")
+
+// prepare injects t's id onto txn-queue for all affected documents
+// and collects the current txn-queue and txn-revno values during
+// the process. If the prepared txn-queue indicates that there are
+// pre-requisite transactions to be applied and the force parameter
+// is false, errPreReqs will be returned. Otherwise, the current
+// tip revision numbers for all the documents are returned.
+func (f *flusher) prepare(t *transaction, force bool) (revnos []int64, err error) {
+	if t.State != tpreparing {
+		return f.rescan(t, force)
+	}
+	f.debugf("Preparing %s", t)
+
+	// dkeys being sorted means stable iteration across all runners. This
+	// isn't strictly required, but reduces the chances of cycles.
+	dkeys := t.docKeys()
+
+	revno := make(map[docKey]int64)
+	info := txnInfo{}
+	tt := tokenFor(t)
+NextDoc:
+	for _, dkey := range dkeys {
+		change := mgo.Change{
+			Update:    bson.D{{"$addToSet", bson.D{{"txn-queue", tt}}}},
+			ReturnNew: true,
+		}
+		c := f.tc.Database.C(dkey.C)
+		cquery := c.FindId(dkey.Id).Select(txnFields)
+
+	RetryDoc:
+		change.Upsert = false
+		chaos("")
+		if _, err := cquery.Apply(change, &info); err == nil {
+			if info.Remove == "" {
+				// Fast path, unless workload is insert/remove heavy.
+				revno[dkey] = info.Revno
+				f.queue[dkey] = info.Queue
+				f.debugf("[A] Prepared document %v with revno %d and queue: %v", dkey, info.Revno, info.Queue)
+				continue NextDoc
+			} else {
+				// Handle remove in progress before preparing it.
+				if err := f.loadAndApply(info.Remove); err != nil {
+					return nil, err
+				}
+				goto RetryDoc
+			}
+		} else if err != mgo.ErrNotFound {
+			return nil, err
+		}
+
+		// Document missing. Use stash collection.
+		change.Upsert = true
+		chaos("")
+		_, err := f.sc.FindId(dkey).Apply(change, &info)
+		if err != nil {
+			return nil, err
+		}
+		if info.Insert != "" {
+			// Handle insert in progress before preparing it.
+			if err := f.loadAndApply(info.Insert); err != nil {
+				return nil, err
+			}
+			goto RetryDoc
+		}
+
+		// Must confirm stash is still in use and is the same one
+		// prepared, since applying a remove overwrites the stash.
+		docFound := false
+		stashFound := false
+		if err = c.FindId(dkey.Id).Select(txnFields).One(&info); err == nil {
+			docFound = true
+		} else if err != mgo.ErrNotFound {
+			return nil, err
+		} else if err = f.sc.FindId(dkey).One(&info); err == nil {
+			stashFound = true
+			if info.Revno == 0 {
+				// Missing revno in the stash only happens when it
+				// has been upserted, in which case it defaults to -1.
+				// Txn-inserted documents get revno -1 while in the stash
+				// for the first time, and -revno-1 == 2 when they go live.
+				info.Revno = -1
+			}
+		} else if err != mgo.ErrNotFound {
+			return nil, err
+		}
+
+		if docFound && info.Remove == "" || stashFound && info.Insert == "" {
+			for _, dtt := range info.Queue {
+				if dtt != tt {
+					continue
+				}
+				// Found tt properly prepared.
+				if stashFound {
+					f.debugf("[B] Prepared document %v on stash with revno %d and queue: %v", dkey, info.Revno, info.Queue)
+				} else {
+					f.debugf("[B] Prepared document %v with revno %d and queue: %v", dkey, info.Revno, info.Queue)
+				}
+				revno[dkey] = info.Revno
+				f.queue[dkey] = info.Queue
+				continue NextDoc
+			}
+		}
+
+		// The stash wasn't valid and tt got overwriten. Try again.
+		f.unstashToken(tt, dkey)
+		goto RetryDoc
+	}
+
+	// Save the prepared nonce onto t.
+	nonce := tt.nonce()
+	qdoc := bson.D{{"_id", t.Id}, {"s", tpreparing}}
+	udoc := bson.D{{"$set", bson.D{{"s", tprepared}, {"n", nonce}}}}
+	chaos("set-prepared")
+	err = f.tc.Update(qdoc, udoc)
+	if err == nil {
+		t.State = tprepared
+		t.Nonce = nonce
+	} else if err == mgo.ErrNotFound {
+		f.debugf("Can't save nonce of %s: LOST RACE", tt)
+		if err := f.reload(t); err != nil {
+			return nil, err
+		} else if t.State == tpreparing {
+			panic("can't save nonce yet transaction is still preparing")
+		} else if t.State != tprepared {
+			return t.Revnos, nil
+		}
+		tt = t.token()
+	} else if err != nil {
+		return nil, err
+	}
+
+	prereqs, found := f.hasPreReqs(tt, dkeys)
+	if !found {
+		// Must only happen when reloading above.
+		return f.rescan(t, force)
+	} else if prereqs && !force {
+		f.debugf("Prepared queue with %s [has prereqs & not forced].", tt)
+		return nil, errPreReqs
+	}
+	revnos = assembledRevnos(t.Ops, revno)
+	if !prereqs {
+		f.debugf("Prepared queue with %s [no prereqs]. Revnos: %v", tt, revnos)
+	} else {
+		f.debugf("Prepared queue with %s [forced] Revnos: %v", tt, revnos)
+	}
+	return revnos, nil
+}
+
+func (f *flusher) unstashToken(tt token, dkey docKey) error {
+	qdoc := bson.D{{"_id", dkey}, {"txn-queue", tt}}
+	udoc := bson.D{{"$pull", bson.D{{"txn-queue", tt}}}}
+	chaos("")
+	if err := f.sc.Update(qdoc, udoc); err == nil {
+		chaos("")
+		err = f.sc.Remove(bson.D{{"_id", dkey}, {"txn-queue", bson.D{}}})
+	} else if err != mgo.ErrNotFound {
+		return err
+	}
+	return nil
+}
+
+func (f *flusher) rescan(t *transaction, force bool) (revnos []int64, err error) {
+	f.debugf("Rescanning %s", t)
+	if t.State != tprepared {
+		panic(fmt.Errorf("rescanning transaction in invalid state: %q", t.State))
+	}
+
+	// dkeys being sorted means stable iteration across all
+	// runners. This isn't strictly required, but reduces the chances
+	// of cycles.
+	dkeys := t.docKeys()
+
+	tt := t.token()
+	if !force {
+		prereqs, found := f.hasPreReqs(tt, dkeys)
+		if found && prereqs {
+			// Its state is already known.
+			return nil, errPreReqs
+		}
+	}
+
+	revno := make(map[docKey]int64)
+	info := txnInfo{}
+	for _, dkey := range dkeys {
+		const retries = 3
+		retry := -1
+
+	RetryDoc:
+		retry++
+		c := f.tc.Database.C(dkey.C)
+		if err := c.FindId(dkey.Id).Select(txnFields).One(&info); err == mgo.ErrNotFound {
+			// Document is missing. Look in stash.
+			chaos("")
+			if err := f.sc.FindId(dkey).One(&info); err == mgo.ErrNotFound {
+				// Stash also doesn't exist. Maybe someone applied it.
+				if err := f.reload(t); err != nil {
+					return nil, err
+				} else if t.State != tprepared {
+					return t.Revnos, err
+				}
+				// Not applying either.
+				if retry < retries {
+					// Retry since there might be an insert/remove race.
+					goto RetryDoc
+				}
+				// Neither the doc nor the stash seem to exist.
+				return nil, fmt.Errorf("cannot find document %v for applying transaction %s", dkey, t)
+			} else if err != nil {
+				return nil, err
+			}
+			// Stash found.
+			if info.Insert != "" {
+				// Handle insert in progress before assuming ordering is good.
+				if err := f.loadAndApply(info.Insert); err != nil {
+					return nil, err
+				}
+				goto RetryDoc
+			}
+			if info.Revno == 0 {
+				// Missing revno in the stash means -1.
+				info.Revno = -1
+			}
+		} else if err != nil {
+			return nil, err
+		} else if info.Remove != "" {
+			// Handle remove in progress before assuming ordering is good.
+			if err := f.loadAndApply(info.Remove); err != nil {
+				return nil, err
+			}
+			goto RetryDoc
+		}
+		revno[dkey] = info.Revno
+
+		found := false
+		for _, id := range info.Queue {
+			if id == tt {
+				found = true
+				break
+			}
+		}
+		f.queue[dkey] = info.Queue
+		if !found {
+			// Rescanned transaction id was not in the queue. This could mean one
+			// of three things:
+			//  1) The transaction was applied and popped by someone else. This is
+			//     the common case.
+			//  2) We've read an out-of-date queue from the stash. This can happen
+			//     when someone else was paused for a long while preparing another
+			//     transaction for this document, and improperly upserted to the
+			//     stash when unpaused (after someone else inserted the document).
+			//     This is rare but possible.
+			//  3) There's an actual bug somewhere, or outside interference. Worst
+			//     possible case.
+			f.debugf("Rescanned document %v misses %s in queue: %v", dkey, tt, info.Queue)
+			err := f.reload(t)
+			if t.State == tpreparing || t.State == tprepared {
+				if retry < retries {
+					// Case 2.
+					goto RetryDoc
+				}
+				// Case 3.
+				return nil, fmt.Errorf("cannot find transaction %s in queue for document %v", t, dkey)
+			}
+			// Case 1.
+			return t.Revnos, err
+		}
+	}
+
+	prereqs, found := f.hasPreReqs(tt, dkeys)
+	if !found {
+		panic("rescanning loop guarantees that this can't happen")
+	} else if prereqs && !force {
+		f.debugf("Rescanned queue with %s: has prereqs, not forced", tt)
+		return nil, errPreReqs
+	}
+	revnos = assembledRevnos(t.Ops, revno)
+	if !prereqs {
+		f.debugf("Rescanned queue with %s: no prereqs, revnos: %v", tt, revnos)
+	} else {
+		f.debugf("Rescanned queue with %s: has prereqs, forced, revnos: %v", tt, revnos)
+	}
+	return revnos, nil
+}
+
+func assembledRevnos(ops []Op, revno map[docKey]int64) []int64 {
+	revnos := make([]int64, len(ops))
+	for i, op := range ops {
+		dkey := op.docKey()
+		revnos[i] = revno[dkey]
+		drevno := revno[dkey]
+		switch {
+		case op.Insert != nil && drevno < 0:
+			revno[dkey] = -drevno + 1
+		case op.Update != nil && drevno >= 0:
+			revno[dkey] = drevno + 1
+		case op.Remove && drevno >= 0:
+			revno[dkey] = -drevno - 1
+		}
+	}
+	return revnos
+}
+
+func (f *flusher) hasPreReqs(tt token, dkeys docKeys) (prereqs, found bool) {
+	found = true
+NextDoc:
+	for _, dkey := range dkeys {
+		for _, dtt := range f.queue[dkey] {
+			if dtt == tt {
+				continue NextDoc
+			} else if dtt.id() != tt.id() {
+				prereqs = true
+			}
+		}
+		found = false
+	}
+	return
+}
+
+func (f *flusher) reload(t *transaction) error {
+	var newt transaction
+	query := f.tc.FindId(t.Id)
+	query.Select(bson.D{{"s", 1}, {"n", 1}, {"r", 1}})
+	if err := query.One(&newt); err != nil {
+		return fmt.Errorf("failed to reload transaction: %v", err)
+	}
+	t.State = newt.State
+	t.Nonce = newt.Nonce
+	t.Revnos = newt.Revnos
+	f.debugf("Reloaded %s: %q", t, t.State)
+	return nil
+}
+
+func (f *flusher) loadAndApply(id bson.ObjectId) error {
+	t, err := f.load(id)
+	if err != nil {
+		return err
+	}
+	return f.advance(t, nil, true)
+}
+
+// assert verifies that all assertions in t match the content that t
+// will be applied upon. If an assertion fails, the transaction state
+// is changed to aborted.
+func (f *flusher) assert(t *transaction, revnos []int64, pull map[bson.ObjectId]*transaction) error {
+	f.debugf("Asserting %s with revnos %v", t, revnos)
+	if t.State != tprepared {
+		panic(fmt.Errorf("asserting transaction in invalid state: %q", t.State))
+	}
+	qdoc := make(bson.D, 3)
+	revno := make(map[docKey]int64)
+	for i, op := range t.Ops {
+		dkey := op.docKey()
+		if _, ok := revno[dkey]; !ok {
+			revno[dkey] = revnos[i]
+		}
+		if op.Assert == nil {
+			continue
+		}
+		if op.Assert == DocMissing {
+			if revnos[i] >= 0 {
+				return f.abortOrReload(t, revnos, pull)
+			}
+			continue
+		}
+		if op.Insert != nil {
+			return fmt.Errorf("Insert can only Assert txn.DocMissing", op.Assert)
+		}
+		// if revnos[i] < 0 { abort }?
+
+		qdoc = append(qdoc[:0], bson.DocElem{"_id", op.Id})
+		if op.Assert != DocMissing {
+			var revnoq interface{}
+			if n := revno[dkey]; n == 0 {
+				revnoq = bson.D{{"$exists", false}}
+			} else {
+				revnoq = n
+			}
+			// XXX Add tt to the query here, once we're sure it's all working.
+			//     Not having it increases the chances of breaking on bad logic.
+			qdoc = append(qdoc, bson.DocElem{"txn-revno", revnoq})
+			if op.Assert != DocExists {
+				qdoc = append(qdoc, bson.DocElem{"$or", []interface{}{op.Assert}})
+			}
+		}
+
+		c := f.tc.Database.C(op.C)
+		if err := c.Find(qdoc).Select(bson.D{{"_id", 1}}).One(nil); err == mgo.ErrNotFound {
+			// Assertion failed or someone else started applying.
+			return f.abortOrReload(t, revnos, pull)
+		} else if err != nil {
+			return err
+		}
+	}
+	f.debugf("Asserting %s succeeded", t)
+	return nil
+}
+
+func (f *flusher) abortOrReload(t *transaction, revnos []int64, pull map[bson.ObjectId]*transaction) (err error) {
+	f.debugf("Aborting or reloading %s (was %q)", t, t.State)
+	if t.State == tprepared {
+		qdoc := bson.D{{"_id", t.Id}, {"s", tprepared}}
+		udoc := bson.D{{"$set", bson.D{{"s", taborting}}}}
+		chaos("set-aborting")
+		if err = f.tc.Update(qdoc, udoc); err == nil {
+			t.State = taborting
+		} else if err == mgo.ErrNotFound {
+			if err = f.reload(t); err != nil || t.State != taborting {
+				f.debugf("Won't abort %s. Reloaded state: %q", t, t.State)
+				return err
+			}
+		} else {
+			return err
+		}
+	} else if t.State != taborting {
+		panic(fmt.Errorf("aborting transaction in invalid state: %q", t.State))
+	}
+
+	if len(revnos) > 0 {
+		if pull == nil {
+			pull = map[bson.ObjectId]*transaction{t.Id: t}
+		}
+		seen := make(map[docKey]bool)
+		for i, op := range t.Ops {
+			dkey := op.docKey()
+			if seen[op.docKey()] {
+				continue
+			}
+			seen[dkey] = true
+
+			pullAll := tokensToPull(f.queue[dkey], pull, "")
+			if len(pullAll) == 0 {
+				continue
+			}
+			udoc := bson.D{{"$pullAll", bson.D{{"txn-queue", pullAll}}}}
+			chaos("")
+			if revnos[i] < 0 {
+				err = f.sc.UpdateId(dkey, udoc)
+			} else {
+				c := f.tc.Database.C(dkey.C)
+				err = c.UpdateId(dkey.Id, udoc)
+			}
+			if err != nil && err != mgo.ErrNotFound {
+				return err
+			}
+		}
+	}
+	udoc := bson.D{{"$set", bson.D{{"s", taborted}}}}
+	chaos("set-aborted")
+	if err := f.tc.UpdateId(t.Id, udoc); err != nil && err != mgo.ErrNotFound {
+		return err
+	}
+	t.State = taborted
+	f.debugf("Aborted %s", t)
+	return nil
+}
+
+func (f *flusher) checkpoint(t *transaction, revnos []int64) error {
+	var debugRevnos map[docKey][]int64
+	if debugEnabled {
+		debugRevnos = make(map[docKey][]int64)
+		for i, op := range t.Ops {
+			dkey := op.docKey()
+			debugRevnos[dkey] = append(debugRevnos[dkey], revnos[i])
+		}
+		f.debugf("Ready to apply %s. Saving revnos %v", t, debugRevnos)
+	}
+
+	// Save in t the txn-revno values the transaction must run on.
+	qdoc := bson.D{{"_id", t.Id}, {"s", tprepared}}
+	udoc := bson.D{{"$set", bson.D{{"s", tapplying}, {"r", revnos}}}}
+	chaos("set-applying")
+	err := f.tc.Update(qdoc, udoc)
+	if err == nil {
+		t.State = tapplying
+		t.Revnos = revnos
+		f.debugf("Ready to apply %s. Saving revnos %v: DONE", t, debugRevnos)
+	} else if err == mgo.ErrNotFound {
+		f.debugf("Ready to apply %s. Saving revnos %v: LOST RACE", t, debugRevnos)
+		return f.reload(t)
+	}
+	return nil
+}
+
+func (f *flusher) apply(t *transaction, pull map[bson.ObjectId]*transaction) error {
+	f.debugf("Applying transaction %s", t)
+	if t.State != tapplying {
+		panic(fmt.Errorf("applying transaction in invalid state: %q", t.State))
+	}
+	if pull == nil {
+		pull = map[bson.ObjectId]*transaction{t.Id: t}
+	}
+
+	logRevnos := append([]int64(nil), t.Revnos...)
+	logDoc := bson.D{{"_id", t.Id}}
+
+	tt := tokenFor(t)
+	for i := range t.Ops {
+		op := &t.Ops[i]
+		dkey := op.docKey()
+		dqueue := f.queue[dkey]
+		revno := t.Revnos[i]
+
+		var opName string
+		if debugEnabled {
+			opName = op.name()
+			f.debugf("Applying %s op %d (%s) on %v with txn-revno %d", t, i, opName, dkey, revno)
+		}
+
+		c := f.tc.Database.C(op.C)
+
+		qdoc := bson.D{{"_id", dkey.Id}, {"txn-revno", revno}, {"txn-queue", tt}}
+		if op.Insert != nil {
+			qdoc[0].Value = dkey
+			if revno == -1 {
+				qdoc[1].Value = bson.D{{"$exists", false}}
+			}
+		} else if revno == 0 {
+			// There's no document with revno 0. The only way to see it is
+			// when an existent document participates in a transaction the
+			// first time. Txn-inserted documents get revno -1 while in the
+			// stash for the first time, and -revno-1 == 2 when they go live.
+			qdoc[1].Value = bson.D{{"$exists", false}}
+		}
+
+		pullAll := tokensToPull(dqueue, pull, tt)
+
+		var d bson.D
+		var outcome string
+		var err error
+		switch {
+		case op.Update != nil:
+			if revno < 0 {
+				err = mgo.ErrNotFound
+				f.debugf("Won't try to apply update op; negative revision means the document is missing or stashed")
+			} else {
+				newRevno := revno + 1
+				logRevnos[i] = newRevno
+				if d, err = objToDoc(op.Update); err != nil {
+					return err
+				}
+				if d, err = addToDoc(d, "$pullAll", bson.D{{"txn-queue", pullAll}}); err != nil {
+					return err
+				}
+				if d, err = addToDoc(d, "$set", bson.D{{"txn-revno", newRevno}}); err != nil {
+					return err
+				}
+				chaos("")
+				err = c.Update(qdoc, d)
+			}
+		case op.Remove:
+			if revno < 0 {
+				err = mgo.ErrNotFound
+			} else {
+				newRevno := -revno - 1
+				logRevnos[i] = newRevno
+				nonce := newNonce()
+				stash := txnInfo{}
+				change := mgo.Change{
+					Update:    bson.D{{"$push", bson.D{{"n", nonce}}}},
+					Upsert:    true,
+					ReturnNew: true,
+				}
+				if _, err = f.sc.FindId(dkey).Apply(change, &stash); err != nil {
+					return err
+				}
+				change = mgo.Change{
+					Update:    bson.D{{"$set", bson.D{{"txn-remove", t.Id}}}},
+					ReturnNew: true,
+				}
+				var info txnInfo
+				if _, err = c.Find(qdoc).Apply(change, &info); err == nil {
+					// The document still exists so the stash previously
+					// observed was either out of date or necessarily
+					// contained the token being applied.
+					f.debugf("Marked document %v to be removed on revno %d with queue: %v", dkey, info.Revno, info.Queue)
+					updated := false
+					if !hasToken(stash.Queue, tt) {
+						var set, unset bson.D
+						if revno == 0 {
+							// Missing revno in stash means -1.
+							set = bson.D{{"txn-queue", info.Queue}}
+							unset = bson.D{{"n", 1}, {"txn-revno", 1}}
+						} else {
+							set = bson.D{{"txn-queue", info.Queue}, {"txn-revno", newRevno}}
+							unset = bson.D{{"n", 1}}
+						}
+						qdoc := bson.D{{"_id", dkey}, {"n", nonce}}
+						udoc := bson.D{{"$set", set}, {"$unset", unset}}
+						if err = f.sc.Update(qdoc, udoc); err == nil {
+							updated = true
+						} else if err != mgo.ErrNotFound {
+							return err
+						}
+					}
+					if updated {
+						f.debugf("Updated stash for document %v with revno %d and queue: %v", dkey, newRevno, info.Queue)
+					} else {
+						f.debugf("Stash for document %v was up-to-date", dkey)
+					}
+					err = c.Remove(qdoc)
+				}
+			}
+		case op.Insert != nil:
+			if revno >= 0 {
+				err = mgo.ErrNotFound
+			} else {
+				newRevno := -revno + 1
+				logRevnos[i] = newRevno
+				if d, err = objToDoc(op.Insert); err != nil {
+					return err
+				}
+				change := mgo.Change{
+					Update:    bson.D{{"$set", bson.D{{"txn-insert", t.Id}}}},
+					ReturnNew: true,
+				}
+				chaos("")
+				var info txnInfo
+				if _, err = f.sc.Find(qdoc).Apply(change, &info); err == nil {
+					f.debugf("Stash for document %v has revno %d and queue: %v", dkey, info.Revno, info.Queue)
+					d = setInDoc(d, bson.D{{"_id", op.Id}, {"txn-revno", newRevno}, {"txn-queue", info.Queue}})
+					// Unlikely yet unfortunate race in here if this gets seriously
+					// delayed. If someone inserts+removes meanwhile, this will
+					// reinsert, and there's no way to avoid that while keeping the
+					// collection clean or compromising sharding. applyOps can solve
+					// the former, but it can't shard (SERVER-1439).
+					chaos("insert")
+					err = c.Insert(d)
+					if err == nil || mgo.IsDup(err) {
+						if err == nil {
+							f.debugf("New document %v inserted with revno %d and queue: %v", dkey, info.Revno, info.Queue)
+						} else {
+							f.debugf("Document %v already existed", dkey)
+						}
+						chaos("")
+						if err = f.sc.Remove(qdoc); err == nil {
+							f.debugf("Stash for document %v removed", dkey)
+						}
+					}
+				}
+			}
+		case op.Assert != nil:
+			// Pure assertion. No changes to apply.
+		}
+		if err == nil {
+			outcome = "DONE"
+		} else if err == mgo.ErrNotFound || mgo.IsDup(err) {
+			outcome = "MISS"
+			err = nil
+		} else {
+			outcome = err.Error()
+		}
+		if debugEnabled {
+			f.debugf("Applying %s op %d (%s) on %v with txn-revno %d: %s", t, i, opName, dkey, revno, outcome)
+		}
+		if err != nil {
+			return err
+		}
+
+		if f.lc != nil && op.isChange() {
+			// Add change to the log document.
+			var dr bson.D
+			for li := range logDoc {
+				elem := &logDoc[li]
+				if elem.Name == op.C {
+					dr = elem.Value.(bson.D)
+					break
+				}
+			}
+			if dr == nil {
+				logDoc = append(logDoc, bson.DocElem{op.C, bson.D{{"d", []interface{}{}}, {"r", []int64{}}}})
+				dr = logDoc[len(logDoc)-1].Value.(bson.D)
+			}
+			dr[0].Value = append(dr[0].Value.([]interface{}), op.Id)
+			dr[1].Value = append(dr[1].Value.([]int64), logRevnos[i])
+		}
+	}
+	t.State = tapplied
+
+	if f.lc != nil {
+		// Insert log document into the changelog collection.
+		f.debugf("Inserting %s into change log", t)
+		err := f.lc.Insert(logDoc)
+		if err != nil && !mgo.IsDup(err) {
+			return err
+		}
+	}
+
+	// It's been applied, so errors are ignored here. It's fine for someone
+	// else to win the race and mark it as applied, and it's also fine for
+	// it to remain pending until a later point when someone will perceive
+	// it has been applied and mark it at such.
+	f.debugf("Marking %s as applied", t)
+	chaos("set-applied")
+	f.tc.Update(bson.D{{"_id", t.Id}, {"s", tapplying}}, bson.D{{"$set", bson.D{{"s", tapplied}}}})
+	return nil
+}
+
+func tokensToPull(dqueue []token, pull map[bson.ObjectId]*transaction, dontPull token) []token {
+	var result []token
+	for j := len(dqueue) - 1; j >= 0; j-- {
+		dtt := dqueue[j]
+		if dtt == dontPull {
+			continue
+		}
+		if _, ok := pull[dtt.id()]; ok {
+			// It was handled before and this is a leftover invalid
+			// nonce in the queue. Cherry-pick it out.
+			result = append(result, dtt)
+		}
+	}
+	return result
+}
+
+func objToDoc(obj interface{}) (d bson.D, err error) {
+	data, err := bson.Marshal(obj)
+	if err != nil {
+		return nil, err
+	}
+	err = bson.Unmarshal(data, &d)
+	if err != nil {
+		return nil, err
+	}
+	return d, err
+}
+
+func addToDoc(doc bson.D, key string, add bson.D) (bson.D, error) {
+	for i := range doc {
+		elem := &doc[i]
+		if elem.Name != key {
+			continue
+		}
+		if old, ok := elem.Value.(bson.D); ok {
+			elem.Value = append(old, add...)
+			return doc, nil
+		} else {
+			return nil, fmt.Errorf("invalid %q value in change document: %#v", key, elem.Value)
+		}
+	}
+	return append(doc, bson.DocElem{key, add}), nil
+}
+
+func setInDoc(doc bson.D, set bson.D) bson.D {
+	dlen := len(doc)
+NextS:
+	for s := range set {
+		sname := set[s].Name
+		for d := 0; d < dlen; d++ {
+			if doc[d].Name == sname {
+				doc[d].Value = set[s].Value
+				continue NextS
+			}
+		}
+		doc = append(doc, set[s])
+	}
+	return doc
+}
+
+func hasToken(tokens []token, tt token) bool {
+	for _, ttt := range tokens {
+		if ttt == tt {
+			return true
+		}
+	}
+	return false
+}
+
+func (f *flusher) debugf(format string, args ...interface{}) {
+	if !debugEnabled {
+		return
+	}
+	debugf(f.debugId+format, args...)
+}
diff --git a/vendor/gopkg.in/mgo.v2/txn/tarjan.go b/vendor/gopkg.in/mgo.v2/txn/tarjan.go
new file mode 100644
index 00000000..e56541c9
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/txn/tarjan.go
@@ -0,0 +1,94 @@
+package txn
+
+import (
+	"gopkg.in/mgo.v2/bson"
+	"sort"
+)
+
+func tarjanSort(successors map[bson.ObjectId][]bson.ObjectId) [][]bson.ObjectId {
+	// http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+	data := &tarjanData{
+		successors: successors,
+		nodes:      make([]tarjanNode, 0, len(successors)),
+		index:      make(map[bson.ObjectId]int, len(successors)),
+	}
+
+	for id := range successors {
+		id := bson.ObjectId(string(id))
+		if _, seen := data.index[id]; !seen {
+			data.strongConnect(id)
+		}
+	}
+
+	// Sort connected components to stabilize the algorithm.
+	for _, ids := range data.output {
+		if len(ids) > 1 {
+			sort.Sort(idList(ids))
+		}
+	}
+	return data.output
+}
+
+type tarjanData struct {
+	successors map[bson.ObjectId][]bson.ObjectId
+	output     [][]bson.ObjectId
+
+	nodes []tarjanNode
+	stack []bson.ObjectId
+	index map[bson.ObjectId]int
+}
+
+type tarjanNode struct {
+	lowlink int
+	stacked bool
+}
+
+type idList []bson.ObjectId
+
+func (l idList) Len() int           { return len(l) }
+func (l idList) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }
+func (l idList) Less(i, j int) bool { return l[i] < l[j] }
+
+func (data *tarjanData) strongConnect(id bson.ObjectId) *tarjanNode {
+	index := len(data.nodes)
+	data.index[id] = index
+	data.stack = append(data.stack, id)
+	data.nodes = append(data.nodes, tarjanNode{index, true})
+	node := &data.nodes[index]
+
+	for _, succid := range data.successors[id] {
+		succindex, seen := data.index[succid]
+		if !seen {
+			succnode := data.strongConnect(succid)
+			if succnode.lowlink < node.lowlink {
+				node.lowlink = succnode.lowlink
+			}
+		} else if data.nodes[succindex].stacked {
+			// Part of the current strongly-connected component.
+			if succindex < node.lowlink {
+				node.lowlink = succindex
+			}
+		}
+	}
+
+	if node.lowlink == index {
+		// Root node; pop stack and output new
+		// strongly-connected component.
+		var scc []bson.ObjectId
+		i := len(data.stack) - 1
+		for {
+			stackid := data.stack[i]
+			stackindex := data.index[stackid]
+			data.nodes[stackindex].stacked = false
+			scc = append(scc, stackid)
+			if stackindex == index {
+				break
+			}
+			i--
+		}
+		data.stack = data.stack[:i]
+		data.output = append(data.output, scc)
+	}
+
+	return node
+}
diff --git a/vendor/gopkg.in/mgo.v2/txn/txn.go b/vendor/gopkg.in/mgo.v2/txn/txn.go
new file mode 100644
index 00000000..925708a8
--- /dev/null
+++ b/vendor/gopkg.in/mgo.v2/txn/txn.go
@@ -0,0 +1,613 @@
+// The txn package implements support for multi-document transactions.
+//
+// For details check the following blog post:
+//
+//     http://blog.labix.org/2012/08/22/multi-doc-transactions-for-mongodb
+//
+package txn
+
+import (
+	"encoding/binary"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+
+	"gopkg.in/mgo.v2"
+	"gopkg.in/mgo.v2/bson"
+
+	crand "crypto/rand"
+	mrand "math/rand"
+)
+
+type state int
+
+const (
+	tpreparing state = 1 // One or more documents not prepared
+	tprepared  state = 2 // Prepared but not yet ready to run
+	taborting  state = 3 // Assertions failed, cleaning up
+	tapplying  state = 4 // Changes are in progress
+	taborted   state = 5 // Pre-conditions failed, nothing done
+	tapplied   state = 6 // All changes applied
+)
+
+func (s state) String() string {
+	switch s {
+	case tpreparing:
+		return "preparing"
+	case tprepared:
+		return "prepared"
+	case taborting:
+		return "aborting"
+	case tapplying:
+		return "applying"
+	case taborted:
+		return "aborted"
+	case tapplied:
+		return "applied"
+	}
+	panic(fmt.Errorf("unknown state: %d", s))
+}
+
+var rand *mrand.Rand
+var randmu sync.Mutex
+
+func init() {
+	var seed int64
+	err := binary.Read(crand.Reader, binary.BigEndian, &seed)
+	if err != nil {
+		panic(err)
+	}
+	rand = mrand.New(mrand.NewSource(seed))
+}
+
+type transaction struct {
+	Id     bson.ObjectId `bson:"_id"`
+	State  state         `bson:"s"`
+	Info   interface{}   `bson:"i,omitempty"`
+	Ops    []Op          `bson:"o"`
+	Nonce  string        `bson:"n,omitempty"`
+	Revnos []int64       `bson:"r,omitempty"`
+
+	docKeysCached docKeys
+}
+
+func (t *transaction) String() string {
+	if t.Nonce == "" {
+		return t.Id.Hex()
+	}
+	return string(t.token())
+}
+
+func (t *transaction) done() bool {
+	return t.State == tapplied || t.State == taborted
+}
+
+func (t *transaction) token() token {
+	if t.Nonce == "" {
+		panic("transaction has no nonce")
+	}
+	return tokenFor(t)
+}
+
+func (t *transaction) docKeys() docKeys {
+	if t.docKeysCached != nil {
+		return t.docKeysCached
+	}
+	dkeys := make(docKeys, 0, len(t.Ops))
+NextOp:
+	for _, op := range t.Ops {
+		dkey := op.docKey()
+		for i := range dkeys {
+			if dkey == dkeys[i] {
+				continue NextOp
+			}
+		}
+		dkeys = append(dkeys, dkey)
+	}
+	sort.Sort(dkeys)
+	t.docKeysCached = dkeys
+	return dkeys
+}
+
+// tokenFor returns a unique transaction token that
+// is composed by t's id and a nonce. If t already has
+// a nonce assigned to it, it will be used, otherwise
+// a new nonce will be generated.
+func tokenFor(t *transaction) token {
+	nonce := t.Nonce
+	if nonce == "" {
+		nonce = newNonce()
+	}
+	return token(t.Id.Hex() + "_" + nonce)
+}
+
+func newNonce() string {
+	randmu.Lock()
+	r := rand.Uint32()
+	randmu.Unlock()
+	n := make([]byte, 8)
+	for i := uint(0); i < 8; i++ {
+		n[i] = "0123456789abcdef"[(r>>(4*i))&0xf]
+	}
+	return string(n)
+}
+
+type token string
+
+func (tt token) id() bson.ObjectId { return bson.ObjectIdHex(string(tt[:24])) }
+func (tt token) nonce() string     { return string(tt[25:]) }
+
+// Op represents an operation to a single document that may be
+// applied as part of a transaction with other operations.
+type Op struct {
+	// C and Id identify the collection and document this operation
+	// refers to. Id is matched against the "_id" document field.
+	C  string      `bson:"c"`
+	Id interface{} `bson:"d"`
+
+	// Assert optionally holds a query document that is used to
+	// test the operation document at the time the transaction is
+	// going to be applied. The assertions for all operations in
+	// a transaction are tested before any changes take place,
+	// and the transaction is entirely aborted if any of them
+	// fails. This is also the only way to prevent a transaction
+	// from being being applied (the transaction continues despite
+	// the outcome of Insert, Update, and Remove).
+	Assert interface{} `bson:"a,omitempty"`
+
+	// The Insert, Update and Remove fields describe the mutation
+	// intended by the operation. At most one of them may be set
+	// per operation. If none are set, Assert must be set and the
+	// operation becomes a read-only test.
+	//
+	// Insert holds the document to be inserted at the time the
+	// transaction is applied. The Id field will be inserted
+	// into the document automatically as its _id field. The
+	// transaction will continue even if the document already
+	// exists. Use Assert with txn.DocMissing if the insertion is
+	// required.
+	//
+	// Update holds the update document to be applied at the time
+	// the transaction is applied. The transaction will continue
+	// even if a document with Id is missing. Use Assert to
+	// test for the document presence or its contents.
+	//
+	// Remove indicates whether to remove the document with Id.
+	// The transaction continues even if the document doesn't yet
+	// exist at the time the transaction is applied. Use Assert
+	// with txn.DocExists to make sure it will be removed.
+	Insert interface{} `bson:"i,omitempty"`
+	Update interface{} `bson:"u,omitempty"`
+	Remove bool        `bson:"r,omitempty"`
+}
+
+func (op *Op) isChange() bool {
+	return op.Update != nil || op.Insert != nil || op.Remove
+}
+
+func (op *Op) docKey() docKey {
+	return docKey{op.C, op.Id}
+}
+
+func (op *Op) name() string {
+	switch {
+	case op.Update != nil:
+		return "update"
+	case op.Insert != nil:
+		return "insert"
+	case op.Remove:
+		return "remove"
+	case op.Assert != nil:
+		return "assert"
+	}
+	return "none"
+}
+
+const (
+	// DocExists and DocMissing may be used on an operation's
+	// Assert value to assert that the document with the given
+	// Id exists or does not exist, respectively.
+	DocExists  = "d+"
+	DocMissing = "d-"
+)
+
+// A Runner applies operations as part of a transaction onto any number
+// of collections within a database. See the Run method for details.
+type Runner struct {
+	tc *mgo.Collection // txns
+	sc *mgo.Collection // stash
+	lc *mgo.Collection // log
+}
+
+// NewRunner returns a new transaction runner that uses tc to hold its
+// transactions.
+//
+// Multiple transaction collections may exist in a single database, but
+// all collections that are touched by operations in a given transaction
+// collection must be handled exclusively by it.
+//
+// A second collection with the same name of tc but suffixed by ".stash"
+// will be used for implementing the transactional behavior of insert
+// and remove operations.
+func NewRunner(tc *mgo.Collection) *Runner {
+	return &Runner{tc, tc.Database.C(tc.Name + ".stash"), nil}
+}
+
+var ErrAborted = fmt.Errorf("transaction aborted")
+
+// Run creates a new transaction with ops and runs it immediately.
+// The id parameter specifies the transaction id, and may be written
+// down ahead of time to later verify the success of the change and
+// resume it, when the procedure is interrupted for any reason. If
+// empty, a random id will be generated.
+// The info parameter, if not nil, is included under the "i"
+// field of the transaction document.
+//
+// Operations across documents are not atomically applied, but are
+// guaranteed to be eventually all applied in the order provided or
+// all aborted, as long as the affected documents are only modified
+// through transactions. If documents are simultaneously modified
+// by transactions and out of transactions the behavior is undefined.
+//
+// If Run returns no errors, all operations were applied successfully.
+// If it returns ErrAborted, one or more operations can't be applied
+// and the transaction was entirely aborted with no changes performed.
+// Otherwise, if the transaction is interrupted while running for any
+// reason, it may be resumed explicitly or by attempting to apply
+// another transaction on any of the documents targeted by ops, as
+// long as the interruption was made after the transaction document
+// itself was inserted. Run Resume with the obtained transaction id
+// to confirm whether the transaction was applied or not.
+//
+// Any number of transactions may be run concurrently, with one
+// runner or many.
+func (r *Runner) Run(ops []Op, id bson.ObjectId, info interface{}) (err error) {
+	const efmt = "error in transaction op %d: %s"
+	for i := range ops {
+		op := &ops[i]
+		if op.C == "" || op.Id == nil {
+			return fmt.Errorf(efmt, i, "C or Id missing")
+		}
+		changes := 0
+		if op.Insert != nil {
+			changes++
+		}
+		if op.Update != nil {
+			changes++
+		}
+		if op.Remove {
+			changes++
+		}
+		if changes > 1 {
+			return fmt.Errorf(efmt, i, "more than one of Insert/Update/Remove set")
+		}
+		if changes == 0 && op.Assert == nil {
+			return fmt.Errorf(efmt, i, "none of Assert/Insert/Update/Remove set")
+		}
+	}
+	if id == "" {
+		id = bson.NewObjectId()
+	}
+
+	// Insert transaction sooner rather than later, to stay on the safer side.
+	t := transaction{
+		Id:    id,
+		Ops:   ops,
+		State: tpreparing,
+		Info:  info,
+	}
+	if err = r.tc.Insert(&t); err != nil {
+		return err
+	}
+	if err = flush(r, &t); err != nil {
+		return err
+	}
+	if t.State == taborted {
+		return ErrAborted
+	} else if t.State != tapplied {
+		panic(fmt.Errorf("invalid state for %s after flush: %q", &t, t.State))
+	}
+	return nil
+}
+
+// ResumeAll resumes all pending transactions. All ErrAborted errors
+// from individual transactions are ignored.
+func (r *Runner) ResumeAll() (err error) {
+	debugf("Resuming all unfinished transactions")
+	iter := r.tc.Find(bson.D{{"s", bson.D{{"$in", []state{tpreparing, tprepared, tapplying}}}}}).Iter()
+	var t transaction
+	for iter.Next(&t) {
+		if t.State == tapplied || t.State == taborted {
+			continue
+		}
+		debugf("Resuming %s from %q", t.Id, t.State)
+		if err := flush(r, &t); err != nil {
+			return err
+		}
+		if !t.done() {
+			panic(fmt.Errorf("invalid state for %s after flush: %q", &t, t.State))
+		}
+	}
+	return nil
+}
+
+// Resume resumes the transaction with id. It returns mgo.ErrNotFound
+// if the transaction is not found. Otherwise, it has the same semantics
+// of the Run method after the transaction is inserted.
+func (r *Runner) Resume(id bson.ObjectId) (err error) {
+	t, err := r.load(id)
+	if err != nil {
+		return err
+	}
+	if !t.done() {
+		debugf("Resuming %s from %q", t, t.State)
+		if err := flush(r, t); err != nil {
+			return err
+		}
+	}
+	if t.State == taborted {
+		return ErrAborted
+	} else if t.State != tapplied {
+		panic(fmt.Errorf("invalid state for %s after flush: %q", t, t.State))
+	}
+	return nil
+}
+
+// ChangeLog enables logging of changes to the given collection
+// every time a transaction that modifies content is done being
+// applied.
+//
+// Saved documents are in the format:
+//
+//     {"_id": <txn id>, <collection>: {"d": [<doc id>, ...], "r": [<doc revno>, ...]}}
+//
+// The document revision is the value of the txn-revno field after
+// the change has been applied. Negative values indicate the document
+// was not present in the collection. Revisions will not change when
+// updates or removes are applied to missing documents or inserts are
+// attempted when the document isn't present.
+func (r *Runner) ChangeLog(logc *mgo.Collection) {
+	r.lc = logc
+}
+
+// PurgeMissing removes from collections any state that refers to transaction
+// documents that for whatever reason have been lost from the system (removed
+// by accident or lost in a hard crash, for example).
+//
+// This method should very rarely be needed, if at all, and should never be
+// used during the normal operation of an application. Its purpose is to put
+// a system that has seen unavoidable corruption back in a working state.
+func (r *Runner) PurgeMissing(collections ...string) error {
+	type M map[string]interface{}
+	type S []interface{}
+	pipeline := []M{
+		{"$project": M{"_id": 1, "txn-queue": 1}},
+		{"$unwind": "$txn-queue"},
+		{"$sort": M{"_id": 1, "txn-queue": 1}},
+		//{"$group": M{"_id": M{"$substr": S{"$txn-queue", 0, 24}}, "docids": M{"$push": "$_id"}}},
+	}
+
+	type TRef struct {
+		DocId interface{} "_id"
+		TxnId string      "txn-queue"
+	}
+
+	found := make(map[bson.ObjectId]bool)
+
+	sort.Strings(collections)
+	for _, collection := range collections {
+		c := r.tc.Database.C(collection)
+		iter := c.Pipe(pipeline).Iter()
+		var tref TRef
+		for iter.Next(&tref) {
+			txnId := bson.ObjectIdHex(tref.TxnId[:24])
+			if found[txnId] {
+				continue
+			}
+			if r.tc.FindId(txnId).One(nil) == nil {
+				found[txnId] = true
+				continue
+			}
+			logf("WARNING: purging from document %s/%v the missing transaction id %s", collection, tref.DocId, txnId)
+			err := c.UpdateId(tref.DocId, M{"$pull": M{"txn-queue": M{"$regex": "^" + txnId.Hex() + "_*"}}})
+			if err != nil {
+				return fmt.Errorf("error purging missing transaction %s: %v", txnId.Hex(), err)
+			}
+		}
+		if err := iter.Close(); err != nil {
+			return fmt.Errorf("transaction queue iteration error for collection %s: %v", collection, err)
+		}
+	}
+
+	type StashTRef struct {
+		Id    docKey "_id"
+		TxnId string "txn-queue"
+	}
+
+	iter := r.sc.Pipe(pipeline).Iter()
+	var stref StashTRef
+	for iter.Next(&stref) {
+		txnId := bson.ObjectIdHex(stref.TxnId[:24])
+		if found[txnId] {
+			continue
+		}
+		if r.tc.FindId(txnId).One(nil) == nil {
+			found[txnId] = true
+			continue
+		}
+		logf("WARNING: purging from stash document %s/%v the missing transaction id %s", stref.Id.C, stref.Id.Id, txnId)
+		err := r.sc.UpdateId(stref.Id, M{"$pull": M{"txn-queue": M{"$regex": "^" + txnId.Hex() + "_*"}}})
+		if err != nil {
+			return fmt.Errorf("error purging missing transaction %s: %v", txnId.Hex(), err)
+		}
+	}
+	if err := iter.Close(); err != nil {
+		return fmt.Errorf("transaction stash iteration error: %v", err)
+	}
+
+	return nil
+}
+
+func (r *Runner) load(id bson.ObjectId) (*transaction, error) {
+	var t transaction
+	err := r.tc.FindId(id).One(&t)
+	if err == mgo.ErrNotFound {
+		return nil, fmt.Errorf("cannot find transaction %s", id)
+	} else if err != nil {
+		return nil, err
+	}
+	return &t, nil
+}
+
+type typeNature int
+
+const (
+	// The order of these values matters. Transactions
+	// from applications using different ordering will
+	// be incompatible with each other.
+	_ typeNature = iota
+	natureString
+	natureInt
+	natureFloat
+	natureBool
+	natureStruct
+)
+
+func valueNature(v interface{}) (value interface{}, nature typeNature) {
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.String:
+		return rv.String(), natureString
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return rv.Int(), natureInt
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return int64(rv.Uint()), natureInt
+	case reflect.Float32, reflect.Float64:
+		return rv.Float(), natureFloat
+	case reflect.Bool:
+		return rv.Bool(), natureBool
+	case reflect.Struct:
+		return v, natureStruct
+	}
+	panic("document id type unsupported by txn: " + rv.Kind().String())
+}
+
+type docKey struct {
+	C  string
+	Id interface{}
+}
+
+type docKeys []docKey
+
+func (ks docKeys) Len() int      { return len(ks) }
+func (ks docKeys) Swap(i, j int) { ks[i], ks[j] = ks[j], ks[i] }
+func (ks docKeys) Less(i, j int) bool {
+	a, b := ks[i], ks[j]
+	if a.C != b.C {
+		return a.C < b.C
+	}
+	return valuecmp(a.Id, b.Id) == -1
+}
+
+func valuecmp(a, b interface{}) int {
+	av, an := valueNature(a)
+	bv, bn := valueNature(b)
+	if an < bn {
+		return -1
+	}
+	if an > bn {
+		return 1
+	}
+
+	if av == bv {
+		return 0
+	}
+	var less bool
+	switch an {
+	case natureString:
+		less = av.(string) < bv.(string)
+	case natureInt:
+		less = av.(int64) < bv.(int64)
+	case natureFloat:
+		less = av.(float64) < bv.(float64)
+	case natureBool:
+		less = !av.(bool) && bv.(bool)
+	case natureStruct:
+		less = structcmp(av, bv) == -1
+	default:
+		panic("unreachable")
+	}
+	if less {
+		return -1
+	}
+	return 1
+}
+
+func structcmp(a, b interface{}) int {
+	av := reflect.ValueOf(a)
+	bv := reflect.ValueOf(b)
+
+	var ai, bi = 0, 0
+	var an, bn = av.NumField(), bv.NumField()
+	var avi, bvi interface{}
+	var af, bf reflect.StructField
+	for {
+		for ai < an {
+			af = av.Type().Field(ai)
+			if isExported(af.Name) {
+				avi = av.Field(ai).Interface()
+				ai++
+				break
+			}
+			ai++
+		}
+		for bi < bn {
+			bf = bv.Type().Field(bi)
+			if isExported(bf.Name) {
+				bvi = bv.Field(bi).Interface()
+				bi++
+				break
+			}
+			bi++
+		}
+		if n := valuecmp(avi, bvi); n != 0 {
+			return n
+		}
+		nameA := getFieldName(af)
+		nameB := getFieldName(bf)
+		if nameA < nameB {
+			return -1
+		}
+		if nameA > nameB {
+			return 1
+		}
+		if ai == an && bi == bn {
+			return 0
+		}
+		if ai == an || bi == bn {
+			if ai == bn {
+				return -1
+			}
+			return 1
+		}
+	}
+	panic("unreachable")
+}
+
+func isExported(name string) bool {
+	a := name[0]
+	return a >= 'A' && a <= 'Z'
+}
+
+func getFieldName(f reflect.StructField) string {
+	name := f.Tag.Get("bson")
+	if i := strings.Index(name, ","); i >= 0 {
+		name = name[:i]
+	}
+	if name == "" {
+		name = strings.ToLower(f.Name)
+	}
+	return name
+}
diff --git a/worker/detectors/os.go b/worker/detectors/os.go
new file mode 100644
index 00000000..29ed7845
--- /dev/null
+++ b/worker/detectors/os.go
@@ -0,0 +1,81 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package detectors exposes functions to register and use container
+// information extractors.
+package detectors
+
+import (
+	"fmt"
+	"sync"
+)
+
+// The OSDetector interface defines a way to detect an Operating System and
+// its version from input data
+type OSDetector interface {
+	// Detect detects an Operating System and its version from input data
+	Detect(map[string][]byte) (string, string)
+	// GetRequiredFiles returns the list of files required for Detect, without
+	// leading /
+	GetRequiredFiles() []string
+}
+
+var (
+	osDetectorsLock sync.Mutex
+	osDetectors     = make(map[string]OSDetector)
+)
+
+// RegisterOSDetector provides a way to dynamically register an implementation of a
+// OSDetector.
+//
+// If RegisterOSDetector is called twice with the same name if OSDetector is nil,
+// or if the name is blank, it panics.
+func RegisterOSDetector(name string, f OSDetector) {
+	if name == "" {
+		panic("Could not register a OSDetector with an empty name")
+	}
+	if f == nil {
+		panic("Could not register a nil OSDetector")
+	}
+
+	osDetectorsLock.Lock()
+	defer osDetectorsLock.Unlock()
+
+	if _, alreadyExists := osDetectors[name]; alreadyExists {
+		panic(fmt.Sprintf("Detector '%s' is already registered", name))
+	}
+	osDetectors[name] = f
+}
+
+// DetectOS finds the OS of the layer by using every registered OSDetector
+func DetectOS(data map[string][]byte) string {
+	for _, detector := range osDetectors {
+		OS, version := detector.Detect(data)
+		if OS != "" && version != "" {
+			return OS + ":" + version
+		}
+	}
+
+	return ""
+}
+
+// GetRequiredFilesOS returns the list of files required for Detect for every
+// registered OSDetector, without leading /
+func GetRequiredFilesOS() (files []string) {
+	for _, detector := range osDetectors {
+		files = append(files, detector.GetRequiredFiles()...)
+	}
+
+	return
+}
diff --git a/worker/detectors/os/apt_sources.go b/worker/detectors/os/apt_sources.go
new file mode 100644
index 00000000..21699b57
--- /dev/null
+++ b/worker/detectors/os/apt_sources.go
@@ -0,0 +1,81 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package os defines OSDetector for several sources.
+package os
+
+import (
+	"bufio"
+	"strings"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/worker/detectors"
+)
+
+// AptSourcesOSDetector implements OSDetector and detects the OS from the
+// /etc/apt/sources.list file.
+type AptSourcesOSDetector struct{}
+
+func init() {
+	detectors.RegisterOSDetector("apt-sources", &AptSourcesOSDetector{})
+}
+
+// Detect tries to detect OS/Version using /etc/apt/sources.list
+// Necessary to determine precise Debian version when it is an unstable version for instance
+func (detector *AptSourcesOSDetector) Detect(data map[string][]byte) (OS, version string) {
+	f, hasFile := data["etc/apt/sources.list"]
+	if !hasFile {
+		return
+	}
+
+	scanner := bufio.NewScanner(strings.NewReader(string(f)))
+	for scanner.Scan() {
+		// Format: man sources.list | https://wiki.debian.org/SourcesList)
+		// deb uri distribution component1 component2 component3
+		// deb-src uri distribution component1 component2 component3
+		line := strings.Split(scanner.Text(), " ")
+		if len(line) > 3 {
+			// Only consider main component
+			isMainComponent := false
+			for _, component := range line[3:] {
+				if component == "main" {
+					isMainComponent = true
+					break
+				}
+			}
+			if !isMainComponent {
+				continue
+			}
+
+			var found bool
+			version, found = database.DebianReleasesMapping[line[2]]
+			if found {
+				OS = "debian"
+				break
+			}
+			version, found = database.UbuntuReleasesMapping[line[2]]
+			if found {
+				OS = "ubuntu"
+				break
+			}
+		}
+	}
+
+	return
+}
+
+// GetRequiredFiles returns the list of files that are required for Detect()
+func (detector *AptSourcesOSDetector) GetRequiredFiles() []string {
+	return []string{"etc/apt/sources.list"}
+}
diff --git a/worker/detectors/os/apt_sources_test.go b/worker/detectors/os/apt_sources_test.go
new file mode 100644
index 00000000..323c554f
--- /dev/null
+++ b/worker/detectors/os/apt_sources_test.go
@@ -0,0 +1,38 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import "testing"
+
+var aptSourcesOSTests = []osTest{
+	osTest{
+		expectedOS:      "debian",
+		expectedVersion: "unstable",
+		data: map[string][]byte{
+			"etc/os-release": []byte(
+				`PRETTY_NAME="Debian GNU/Linux stretch/sid"
+NAME="Debian GNU/Linux"
+ID=debian
+HOME_URL="https://www.debian.org/"
+SUPPORT_URL="https://www.debian.org/support/"
+BUG_REPORT_URL="https://bugs.debian.org/"`),
+			"etc/apt/sources.list": []byte(`deb http://httpredir.debian.org/debian unstable main`),
+		},
+	},
+}
+
+func TestAptSourcesOSDetector(t *testing.T) {
+	testOSDetector(t, &AptSourcesOSDetector{}, aptSourcesOSTests)
+}
diff --git a/worker/detectors/os/lsb_release.go b/worker/detectors/os/lsb_release.go
new file mode 100644
index 00000000..d523d8fa
--- /dev/null
+++ b/worker/detectors/os/lsb_release.go
@@ -0,0 +1,75 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import (
+	"bufio"
+	"regexp"
+	"strings"
+
+	"github.com/coreos/clair/worker/detectors"
+)
+
+var (
+	lsbReleaseOSRegexp      = regexp.MustCompile(`^DISTRIB_ID=(.*)`)
+	lsbReleaseVersionRegexp = regexp.MustCompile(`^DISTRIB_RELEASE=(.*)`)
+)
+
+// AptSourcesOSDetector implements OSDetector and detects the OS from the
+// /etc/lsb-release file.
+type LsbReleaseOSDetector struct{}
+
+func init() {
+	detectors.RegisterOSDetector("lsb-release", &LsbReleaseOSDetector{})
+}
+
+// Detect tries to detect OS/Version using "/etc/lsb-release"
+// Necessary for Ubuntu Precise for instance
+func (detector *LsbReleaseOSDetector) Detect(data map[string][]byte) (OS, version string) {
+	f, hasFile := data["etc/lsb-release"]
+	if !hasFile {
+		return
+	}
+
+	scanner := bufio.NewScanner(strings.NewReader(string(f)))
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		r := lsbReleaseOSRegexp.FindStringSubmatch(line)
+		if len(r) == 2 {
+			OS = strings.Replace(strings.ToLower(r[1]), "\"", "", -1)
+		}
+
+		r = lsbReleaseVersionRegexp.FindStringSubmatch(line)
+		if len(r) == 2 {
+			version = strings.Replace(strings.ToLower(r[1]), "\"", "", -1)
+
+			// We care about the .04 for Ubuntu but not for Debian / CentOS
+			if OS == "centos" || OS == "debian" {
+				i := strings.Index(version, ".")
+				if i >= 0 {
+					version = version[:i]
+				}
+			}
+		}
+	}
+
+	return
+}
+
+// GetRequiredFiles returns the list of files that are required for Detect()
+func (detector *LsbReleaseOSDetector) GetRequiredFiles() []string {
+	return []string{"etc/lsb-release"}
+}
diff --git a/worker/detectors/os/lsb_release_test.go b/worker/detectors/os/lsb_release_test.go
new file mode 100644
index 00000000..ee54a07a
--- /dev/null
+++ b/worker/detectors/os/lsb_release_test.go
@@ -0,0 +1,46 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import "testing"
+
+var lsbReleaseOSTests = []osTest{
+	osTest{
+		expectedOS:      "ubuntu",
+		expectedVersion: "12.04",
+		data: map[string][]byte{
+			"etc/lsb-release": []byte(
+				`DISTRIB_ID=Ubuntu
+DISTRIB_RELEASE=12.04
+DISTRIB_CODENAME=precise
+DISTRIB_DESCRIPTION="Ubuntu 12.04 LTS"`),
+		},
+	},
+	osTest{ // We don't care about the minor version of Debian
+		expectedOS:      "debian",
+		expectedVersion: "7",
+		data: map[string][]byte{
+			"etc/lsb-release": []byte(
+				`DISTRIB_ID=Debian
+DISTRIB_RELEASE=7.1
+DISTRIB_CODENAME=wheezy
+DISTRIB_DESCRIPTION="Debian 7.1"`),
+		},
+	},
+}
+
+func TestLsbReleaseOSDetector(t *testing.T) {
+	testOSDetector(t, &LsbReleaseOSDetector{}, lsbReleaseOSTests)
+}
diff --git a/worker/detectors/os/os_release.go b/worker/detectors/os/os_release.go
new file mode 100644
index 00000000..6ff39d0f
--- /dev/null
+++ b/worker/detectors/os/os_release.go
@@ -0,0 +1,70 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import (
+	"bufio"
+	"regexp"
+	"strings"
+
+	"github.com/coreos/clair/worker/detectors"
+)
+
+var (
+	osReleaseOSRegexp      = regexp.MustCompile(`^ID=(.*)`)
+	osReleaseVersionRegexp = regexp.MustCompile(`^VERSION_ID=(.*)`)
+)
+
+// OsReleaseOSDetector implements OSDetector and detects the OS from the
+// /etc/os-release and usr/lib/os-release files.
+type OsReleaseOSDetector struct{}
+
+func init() {
+	detectors.RegisterOSDetector("os-release", &OsReleaseOSDetector{})
+}
+
+// Detect tries to detect OS/Version using "/etc/os-release" and "/usr/lib/os-release"
+// Typically for Debian / Ubuntu
+// /etc/debian_version can't be used, it does not make any difference between testing and unstable, it returns stretch/sid
+func (detector *OsReleaseOSDetector) Detect(data map[string][]byte) (OS, version string) {
+	for _, filePath := range detector.GetRequiredFiles() {
+		f, hasFile := data[filePath]
+		if !hasFile {
+			continue
+		}
+
+		scanner := bufio.NewScanner(strings.NewReader(string(f)))
+		for scanner.Scan() {
+			line := scanner.Text()
+
+			r := osReleaseOSRegexp.FindStringSubmatch(line)
+			if len(r) == 2 {
+				OS = strings.Replace(strings.ToLower(r[1]), "\"", "", -1)
+			}
+
+			r = osReleaseVersionRegexp.FindStringSubmatch(line)
+			if len(r) == 2 {
+				version = strings.Replace(strings.ToLower(r[1]), "\"", "", -1)
+			}
+		}
+	}
+
+	return
+}
+
+// GetRequiredFiles returns the list of files that are required for Detect()
+func (detector *OsReleaseOSDetector) GetRequiredFiles() []string {
+	return []string{"etc/os-release", "usr/lib/os-release"}
+}
diff --git a/worker/detectors/os/os_release_test.go b/worker/detectors/os/os_release_test.go
new file mode 100644
index 00000000..431dab10
--- /dev/null
+++ b/worker/detectors/os/os_release_test.go
@@ -0,0 +1,75 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import "testing"
+
+var osReleaseOSTests = []osTest{
+	osTest{
+		expectedOS:      "debian",
+		expectedVersion: "8",
+		data: map[string][]byte{
+			"etc/os-release": []byte(
+				`PRETTY_NAME="Debian GNU/Linux 8 (jessie)"
+NAME="Debian GNU/Linux"
+VERSION_ID="8"
+VERSION="8 (jessie)"
+ID=debian
+HOME_URL="http://www.debian.org/"
+SUPPORT_URL="http://www.debian.org/support/"
+BUG_REPORT_URL="https://bugs.debian.org/"`),
+		},
+	},
+	osTest{
+		expectedOS:      "ubuntu",
+		expectedVersion: "15.10",
+		data: map[string][]byte{
+			"etc/os-release": []byte(
+				`NAME="Ubuntu"
+VERSION="15.10 (Wily Werewolf)"
+ID=ubuntu
+ID_LIKE=debian
+PRETTY_NAME="Ubuntu Wily Werewolf (development branch)"
+VERSION_ID="15.10"
+HOME_URL="http://www.ubuntu.com/"
+SUPPORT_URL="http://help.ubuntu.com/"
+BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"`),
+		},
+	},
+	osTest{ // Doesn't have quotes around VERSION_ID
+		expectedOS:      "fedora",
+		expectedVersion: "20",
+		data: map[string][]byte{
+			"etc/os-release": []byte(
+				`NAME=Fedora
+VERSION="20 (Heisenbug)"
+ID=fedora
+VERSION_ID=20
+PRETTY_NAME="Fedora 20 (Heisenbug)"
+ANSI_COLOR="0;34"
+CPE_NAME="cpe:/o:fedoraproject:fedora:20"
+HOME_URL="https://fedoraproject.org/"
+BUG_REPORT_URL="https://bugzilla.redhat.com/"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=20
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=20`),
+		},
+	},
+}
+
+func TestOsReleaseOSDetector(t *testing.T) {
+	testOSDetector(t, &OsReleaseOSDetector{}, osReleaseOSTests)
+}
diff --git a/worker/detectors/os/redhat_release.go b/worker/detectors/os/redhat_release.go
new file mode 100644
index 00000000..b95a63b8
--- /dev/null
+++ b/worker/detectors/os/redhat_release.go
@@ -0,0 +1,59 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/coreos/clair/worker/detectors"
+)
+
+var redhatReleaseRegexp = regexp.MustCompile(`(?P<os>[^\s]*) (Linux release|release) (?P<version>[\d]+)`)
+
+// RedhatReleaseOSDetector implements OSDetector and detects the OS from the
+// /etc/centos-release, /etc/redhat-release and /etc/system-release files.
+type RedhatReleaseOSDetector struct{}
+
+func init() {
+	detectors.RegisterOSDetector("redhat-release", &RedhatReleaseOSDetector{})
+}
+
+// Detect tries to detect OS/Version using "/etc/centos-release", "/etc/redhat-release" and "/etc/system-release"
+// Typically for CentOS and Red-Hat like systems
+// eg. CentOS release 5.11 (Final)
+// eg. CentOS release 6.6 (Final)
+// eg. CentOS Linux release 7.1.1503 (Core)
+func (detector *RedhatReleaseOSDetector) Detect(data map[string][]byte) (OS, version string) {
+	for _, filePath := range detector.GetRequiredFiles() {
+		f, hasFile := data[filePath]
+		if !hasFile {
+			continue
+		}
+
+		r := redhatReleaseRegexp.FindStringSubmatch(string(f))
+		if len(r) == 4 {
+			OS = strings.ToLower(r[1])
+			version = r[3]
+		}
+	}
+
+	return
+}
+
+// GetRequiredFiles returns the list of files that are required for Detect()
+func (detector *RedhatReleaseOSDetector) GetRequiredFiles() []string {
+	return []string{"etc/centos-release", "etc/redhat-release", "etc/system-release"}
+}
diff --git a/worker/detectors/os/redhat_release_test.go b/worker/detectors/os/redhat_release_test.go
new file mode 100644
index 00000000..84b96919
--- /dev/null
+++ b/worker/detectors/os/redhat_release_test.go
@@ -0,0 +1,38 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import "testing"
+
+var redhatReleaseTests = []osTest{
+	osTest{
+		expectedOS:      "centos",
+		expectedVersion: "6",
+		data: map[string][]byte{
+			"etc/centos-release": []byte(`CentOS release 6.6 (Final)`),
+		},
+	},
+	osTest{
+		expectedOS:      "centos",
+		expectedVersion: "7",
+		data: map[string][]byte{
+			"etc/system-release": []byte(`CentOS Linux release 7.1.1503 (Core)`),
+		},
+	},
+}
+
+func TestRedhatReleaseOSDetector(t *testing.T) {
+	testOSDetector(t, &RedhatReleaseOSDetector{}, redhatReleaseTests)
+}
diff --git a/worker/detectors/os/test.go b/worker/detectors/os/test.go
new file mode 100644
index 00000000..8d1ef369
--- /dev/null
+++ b/worker/detectors/os/test.go
@@ -0,0 +1,36 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package os
+
+import (
+	"testing"
+
+	"github.com/coreos/clair/worker/detectors"
+	"github.com/stretchr/testify/assert"
+)
+
+type osTest struct {
+	expectedOS      string
+	expectedVersion string
+	data            map[string][]byte
+}
+
+func testOSDetector(t *testing.T, detector detectors.OSDetector, tests []osTest) {
+	for _, test := range tests {
+		os, version := detector.Detect(test.data)
+		assert.Equal(t, test.expectedOS, os)
+		assert.Equal(t, test.expectedVersion, version)
+	}
+}
diff --git a/worker/detectors/packages.go b/worker/detectors/packages.go
new file mode 100644
index 00000000..4f8ab1d4
--- /dev/null
+++ b/worker/detectors/packages.go
@@ -0,0 +1,79 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package detectors
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/coreos/clair/database"
+)
+
+// The PackagesDetector interface defines a way to detect packages from input data
+type PackagesDetector interface {
+	// Detect detects packages from the input data
+	Detect(map[string][]byte) ([]*database.Package, error)
+	// GetRequiredFiles returns the list of files required for Detect, without
+	// leading /
+	GetRequiredFiles() []string
+}
+
+var (
+	packagesDetectorsLock sync.Mutex
+	packagesDetectors     = make(map[string]PackagesDetector)
+)
+
+// RegisterPackagesDetector makes a PackagesDetector available for DetectPackages
+func RegisterPackagesDetector(name string, f PackagesDetector) {
+	if name == "" {
+		panic("Could not register a PackagesDetector with an empty name")
+	}
+	if f == nil {
+		panic("Could not register a nil PackagesDetector")
+	}
+
+	packagesDetectorsLock.Lock()
+	defer packagesDetectorsLock.Unlock()
+
+	if _, alreadyExists := packagesDetectors[name]; alreadyExists {
+		panic(fmt.Sprintf("Detector '%s' is already registered", name))
+	}
+	packagesDetectors[name] = f
+}
+
+// DetectPackages detects packages using every registered PackagesDetector
+func DetectPackages(data map[string][]byte) ([]*database.Package, error) {
+	var packages []*database.Package
+
+	for _, detector := range packagesDetectors {
+		pkgs, err := detector.Detect(data)
+		if err != nil {
+			return []*database.Package{}, err
+		}
+		packages = append(packages, pkgs...)
+	}
+
+	return packages, nil
+}
+
+// GetRequiredFilesPackages returns the list of files required for Detect for every
+// registered PackagesDetector, without leading /
+func GetRequiredFilesPackages() (files []string) {
+	for _, detector := range packagesDetectors {
+		files = append(files, detector.GetRequiredFiles()...)
+	}
+
+	return
+}
diff --git a/worker/detectors/packages/dpkg.go b/worker/detectors/packages/dpkg.go
new file mode 100644
index 00000000..eaeb77c7
--- /dev/null
+++ b/worker/detectors/packages/dpkg.go
@@ -0,0 +1,116 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package packages defines PackagesDetector for several sources.
+package packages
+
+import (
+	"bufio"
+	"regexp"
+	"strings"
+
+	"github.com/coreos/pkg/capnslog"
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+	"github.com/coreos/clair/worker/detectors"
+)
+
+var (
+	log = capnslog.NewPackageLogger("github.com/coreos/clair", "worker/detectors/packages")
+
+	dpkgSrcCaptureRegexp      = regexp.MustCompile(`Source: (?P<name>[^\s]*)( \((?P<version>.*)\))?`)
+	dpkgSrcCaptureRegexpNames = dpkgSrcCaptureRegexp.SubexpNames()
+)
+
+// DpkgPackagesDetector implements PackagesDetector and detects dpkg packages
+type DpkgPackagesDetector struct{}
+
+func init() {
+	detectors.RegisterPackagesDetector("dpkg", &DpkgPackagesDetector{})
+}
+
+// Detect detects packages using var/lib/dpkg/status from the input data
+func (detector *DpkgPackagesDetector) Detect(data map[string][]byte) ([]*database.Package, error) {
+	f, hasFile := data["var/lib/dpkg/status"]
+	if !hasFile {
+		return []*database.Package{}, nil
+	}
+
+	// Create a map to store packages and ensure their uniqueness
+	packagesMap := make(map[string]*database.Package)
+
+	var pkg *database.Package
+	var err error
+	scanner := bufio.NewScanner(strings.NewReader(string(f)))
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		if strings.HasPrefix(line, "Package: ") {
+			// Package line
+			// Defines the name of the package
+
+			pkg = &database.Package{
+				Name: strings.TrimSpace(strings.TrimPrefix(line, "Package: ")),
+			}
+		} else if pkg != nil && strings.HasPrefix(line, "Source: ") {
+			// Source line (Optionnal)
+			// Gives the name of the source package
+			// May also specifies a version
+
+			srcCapture := dpkgSrcCaptureRegexp.FindAllStringSubmatch(line, -1)[0]
+			md := map[string]string{}
+			for i, n := range srcCapture {
+				md[dpkgSrcCaptureRegexpNames[i]] = strings.TrimSpace(n)
+			}
+
+			pkg.Name = md["name"]
+			if md["version"] != "" {
+				pkg.Version, err = types.NewVersion(md["version"])
+				if err != nil {
+					log.Warningf("could not parse package version '%s': %s. skipping", line[1], err.Error())
+				}
+			}
+		} else if pkg != nil && strings.HasPrefix(line, "Version: ") && pkg.Version.String() == "" {
+			// Version line
+			// Defines the version of the package
+			// This version is less important than a version retrieved from a Source line
+			// because the Debian vulnerabilities often skips the epoch from the Version field
+			// which is not present in the Source version, and because +bX revisions don't matter
+			pkg.Version, err = types.NewVersion(strings.TrimPrefix(line, "Version: "))
+			if err != nil {
+				log.Warningf("could not parse package version '%s': %s. skipping", line[1], err.Error())
+			}
+		}
+
+		// Add the package to the result array if we have all the informations
+		if pkg != nil && pkg.Name != "" && pkg.Version.String() != "" {
+			packagesMap[pkg.Key()] = pkg
+			pkg = nil
+		}
+	}
+
+	// Convert the map to a slice
+	packages := make([]*database.Package, 0, len(packagesMap))
+	for _, pkg := range packagesMap {
+		packages = append(packages, pkg)
+	}
+
+	return packages, nil
+}
+
+// GetRequiredFiles returns the list of files required for Detect, without
+// leading /
+func (detector *DpkgPackagesDetector) GetRequiredFiles() []string {
+	return []string{"var/lib/dpkg/status"}
+}
diff --git a/worker/detectors/packages/dpkg_test.go b/worker/detectors/packages/dpkg_test.go
new file mode 100644
index 00000000..8ec01548
--- /dev/null
+++ b/worker/detectors/packages/dpkg_test.go
@@ -0,0 +1,49 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package packages
+
+import (
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+)
+
+var dpkgPackagesTests = []packagesTest{
+	// Test an Ubuntu dpkg status file
+	packagesTest{
+		packages: []*database.Package{
+			&database.Package{
+				Name:    "pam", // Two packages from this source are installed, it should only appear one time
+				Version: types.NewVersionUnsafe("1.1.8-3.1ubuntu3"),
+			},
+			&database.Package{
+				Name:    "makedev",                                 // The source name and the package name are equals
+				Version: types.NewVersionUnsafe("2.3.1-93ubuntu1"), // The version comes from the "Version:" line
+			},
+			&database.Package{
+				Name:    "gcc-5",
+				Version: types.NewVersionUnsafe("5.1.1-12ubuntu1"), // The version comes from the "Source:" line
+			},
+		},
+		data: map[string][]byte{
+			"var/lib/dpkg/status": loadFileForTest("testdata/dpkg_status"),
+		},
+	},
+}
+
+func TestDpkgPackagesDetector(t *testing.T) {
+	testPackagesDetector(t, &DpkgPackagesDetector{}, dpkgPackagesTests)
+}
diff --git a/worker/detectors/packages/rpm.go b/worker/detectors/packages/rpm.go
new file mode 100644
index 00000000..5edf92b3
--- /dev/null
+++ b/worker/detectors/packages/rpm.go
@@ -0,0 +1,112 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package packages
+
+import (
+	"bufio"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/coreos/clair/database"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/utils"
+	"github.com/coreos/clair/utils/types"
+	"github.com/coreos/clair/worker/detectors"
+)
+
+// RpmPackagesDetector implements PackagesDetector and detects rpm packages
+// It requires the "rpm" binary to be in the PATH
+type RpmPackagesDetector struct{}
+
+func init() {
+	detectors.RegisterPackagesDetector("rpm", &RpmPackagesDetector{})
+}
+
+// Detect detects packages using var/lib/rpm/Packages from the input data
+func (detector *RpmPackagesDetector) Detect(data map[string][]byte) ([]*database.Package, error) {
+	f, hasFile := data["var/lib/rpm/Packages"]
+	if !hasFile {
+		return []*database.Package{}, nil
+	}
+
+	// Create a map to store packages and ensure their uniqueness
+	packagesMap := make(map[string]*database.Package)
+
+	// Write the required "Packages" file to disk
+	tmpDir, err := ioutil.TempDir(os.TempDir(), "rpm")
+	defer os.RemoveAll(tmpDir)
+	if err != nil {
+		log.Errorf("could not create temporary folder for RPM detection: %s", err)
+		return []*database.Package{}, cerrors.ErrFilesystem
+	}
+
+	err = ioutil.WriteFile(tmpDir+"/Packages", f, 0700)
+	if err != nil {
+		log.Errorf("could not create temporary file for RPM detection: %s", err)
+		return []*database.Package{}, cerrors.ErrFilesystem
+	}
+
+	// Query RPM
+	// We actually extract binary package names instead of source package names here because RHSA refers to package names
+	// In the dpkg system, we extract the source instead
+	out, err := utils.Exec(tmpDir, "rpm", "--dbpath", tmpDir, "-qa", "--qf", "%{NAME} %{EPOCH}:%{VERSION}-%{RELEASE}\n")
+	if err != nil {
+		log.Errorf("could not query RPM: %s. output: %s", err, string(out))
+		// Do not bubble up because we probably won't be able to fix it,
+		// the database must be corrupted
+		return []*database.Package{}, nil
+	}
+
+	scanner := bufio.NewScanner(strings.NewReader(string(out)))
+	for scanner.Scan() {
+		line := strings.Split(scanner.Text(), " ")
+		if len(line) != 2 {
+			// We may see warnings on some RPM versions:
+			// "warning: Generating 12 missing index(es), please wait..."
+			continue
+		}
+
+		// Ignore gpg-pubkey packages which are fake packages used to store GPG keys - they are not versionned properly.
+		if line[0] == "gpg-pubkey" {
+			continue
+		}
+
+		// Parse version
+		version, err := types.NewVersion(strings.Replace(line[1], "(none):", "", -1))
+		if err != nil {
+			log.Warningf("could not parse package version '%s': %s. skipping", line[1], err.Error())
+			continue
+		}
+
+		// Add package
+		pkg := &database.Package{Name: line[0], Version: version}
+		packagesMap[pkg.Key()] = pkg
+	}
+
+	// Convert the map to a slice
+	packages := make([]*database.Package, 0, len(packagesMap))
+	for _, pkg := range packagesMap {
+		packages = append(packages, pkg)
+	}
+
+	return packages, nil
+}
+
+// GetRequiredFiles returns the list of files required for Detect, without
+// leading /
+func (detector *RpmPackagesDetector) GetRequiredFiles() []string {
+	return []string{"var/lib/rpm/Packages"}
+}
diff --git a/worker/detectors/packages/rpm_test.go b/worker/detectors/packages/rpm_test.go
new file mode 100644
index 00000000..4ef3b0a1
--- /dev/null
+++ b/worker/detectors/packages/rpm_test.go
@@ -0,0 +1,46 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package packages
+
+import (
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+)
+
+var rpmPackagesTests = []packagesTest{
+	// Test a CentOS 7 RPM database
+	// Memo: Use the following command on a RPM-based system to shrink a database: rpm -qa --qf "%{NAME}\n" |tail -n +3| xargs rpm -e --justdb
+	packagesTest{
+		packages: []*database.Package{
+			&database.Package{
+				Name:    "centos-release", // Two packages from this source are installed, it should only appear one time
+				Version: types.NewVersionUnsafe("7-1.1503.el7.centos.2.8"),
+			},
+			&database.Package{
+				Name:    "filesystem", // Two packages from this source are installed, it should only appear one time
+				Version: types.NewVersionUnsafe("3.2-18.el7"),
+			},
+		},
+		data: map[string][]byte{
+			"var/lib/rpm/Packages": loadFileForTest("testdata/rpm_Packages"),
+		},
+	},
+}
+
+func TestRpmPackagesDetector(t *testing.T) {
+	testPackagesDetector(t, &RpmPackagesDetector{}, rpmPackagesTests)
+}
diff --git a/worker/detectors/packages/test.go b/worker/detectors/packages/test.go
new file mode 100644
index 00000000..5527c9f1
--- /dev/null
+++ b/worker/detectors/packages/test.go
@@ -0,0 +1,48 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package packages
+
+import (
+	"io/ioutil"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/worker/detectors"
+	"github.com/stretchr/testify/assert"
+)
+
+type packagesTest struct {
+	packages []*database.Package
+	data     map[string][]byte
+}
+
+func loadFileForTest(name string) []byte {
+	_, filename, _, _ := runtime.Caller(0)
+	d, _ := ioutil.ReadFile(path.Join(path.Dir(filename)) + "/" + name)
+	return d
+}
+
+func testPackagesDetector(t *testing.T, detector detectors.PackagesDetector, tests []packagesTest) {
+	for _, test := range tests {
+		packages, err := detector.Detect(test.data)
+		if assert.Nil(t, err) && assert.Len(t, packages, len(test.packages)) {
+			for _, expectedPkg := range test.packages {
+				assert.Contains(t, packages, expectedPkg)
+			}
+		}
+	}
+}
diff --git a/worker/detectors/packages/testdata/dpkg_status b/worker/detectors/packages/testdata/dpkg_status
new file mode 100644
index 00000000..d19e2500
--- /dev/null
+++ b/worker/detectors/packages/testdata/dpkg_status
@@ -0,0 +1,85 @@
+Package: libpam-runtime
+Status: install ok installed
+Priority: required
+Section: admin
+Installed-Size: 300
+Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
+Architecture: all
+Multi-Arch: foreign
+Source: pam
+Version: 1.1.8-3.1ubuntu3
+Replaces: libpam0g-dev, libpam0g-util
+Depends: debconf (>= 0.5) | debconf-2.0, debconf (>= 1.5.19) | cdebconf, libpam-modules (>= 1.0.1-6)
+Conflicts: libpam0g-util
+Conffiles:
+/etc/pam.conf 87fc76f18e98ee7d3848f6b81b3391e5
+/etc/pam.d/other 31aa7f2181889ffb00b87df4126d1701
+Description: Runtime support for the PAM library
+Contains configuration files and  directories required for
+authentication  to work on Debian systems.  This package is required
+on almost all installations.
+Homepage: http://pam.sourceforge.net/
+Original-Maintainer: Steve Langasek <vorlon@debian.org>
+
+Package: libpam-modules-bin
+Status: install ok installed
+Priority: required
+Section: admin
+Installed-Size: 299
+Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
+Architecture: amd64
+Multi-Arch: foreign
+Source: pam
+Version: 1.1.8-3.1ubuntu3
+Replaces: libpam-modules (<< 1.1.3-8)
+Depends: libaudit1 (>= 1:2.2.1), libc6 (>= 2.14), libpam0g (>= 0.99.7.1), libselinux1 (>= 1.32)
+Description: Pluggable Authentication Modules for PAM - helper binaries
+This package contains helper binaries used by the standard set of PAM
+modules in the libpam-modules package.
+Homepage: http://pam.sourceforge.net/
+Original-Maintainer: Steve Langasek <vorlon@debian.org>
+
+Package: makedev
+Status: install ok installed
+Priority: required
+Section: admin
+Installed-Size: 125
+Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
+Architecture: all
+Multi-Arch: foreign
+Version: 2.3.1-93ubuntu1
+Depends: base-passwd (>= 3.0.4)
+Conflicts: udev (<= 0.024-7)
+Description: creates device files in /dev
+The MAKEDEV executable is used to create device files, often in /dev.
+.
+Device files are special files through which applications can interact
+with hardware.
+.
+This package is not necessary for most modern Linux systems, where the udev
+subsystem provides a more dynamic mechanism for device file management.
+Original-Maintainer: Debian QA Group <packages@qa.debian.org>
+
+Package: libgcc1
+Status: install ok installed
+Priority: required
+Section: libs
+Installed-Size: 131
+Maintainer: Ubuntu Core developers <ubuntu-devel-discuss@lists.ubuntu.com>
+Architecture: amd64
+Multi-Arch: same
+Source: gcc-5 (5.1.1-12ubuntu1)
+Version: 1:5.1.1-12ubuntu1
+Depends: gcc-5-base (= 5.1.1-12ubuntu1), libc6 (>= 2.14)
+Pre-Depends: multiarch-support
+Breaks: gcc-4.3 (<< 4.3.6-1), gcc-4.4 (<< 4.4.6-4), gcc-4.5 (<< 4.5.3-2)
+Description: GCC support library
+Shared version of the support library, a library of internal subroutines
+that GCC uses to overcome shortcomings of particular machines, or
+special needs for some languages.
+Homepage: http://gcc.gnu.org/
+Original-Maintainer: Debian GCC Maintainers <debian-gcc@lists.debian.org>
+
+Package: invalidpkg
+Source: invalidpkg-5 (5.#)
+Version: 1:5.#
diff --git a/worker/detectors/packages/testdata/rpm_Packages b/worker/detectors/packages/testdata/rpm_Packages
new file mode 100644
index 00000000..35a61a82
Binary files /dev/null and b/worker/detectors/packages/testdata/rpm_Packages differ
diff --git a/worker/testdata/DistUpgrade/blank.tar.gz b/worker/testdata/DistUpgrade/blank.tar.gz
new file mode 100644
index 00000000..231a8d13
Binary files /dev/null and b/worker/testdata/DistUpgrade/blank.tar.gz differ
diff --git a/worker/testdata/DistUpgrade/jessie.tar.gz b/worker/testdata/DistUpgrade/jessie.tar.gz
new file mode 100644
index 00000000..42e72ffe
Binary files /dev/null and b/worker/testdata/DistUpgrade/jessie.tar.gz differ
diff --git a/worker/testdata/DistUpgrade/wheezy.tar.gz b/worker/testdata/DistUpgrade/wheezy.tar.gz
new file mode 100644
index 00000000..e3df8220
Binary files /dev/null and b/worker/testdata/DistUpgrade/wheezy.tar.gz differ
diff --git a/worker/worker.go b/worker/worker.go
new file mode 100644
index 00000000..915465b6
--- /dev/null
+++ b/worker/worker.go
@@ -0,0 +1,302 @@
+// Copyright 2015 clair authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package worker implements the logic to extract useful informations from a
+// container layer and store it in the database.
+package worker
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/coreos/pkg/capnslog"
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils"
+	cerrors "github.com/coreos/clair/utils/errors"
+	"github.com/coreos/clair/worker/detectors"
+)
+
+const (
+	// Version (integer) represents the worker version.
+	// Increased each time the engine changes.
+	Version = 1
+
+	// maxFileSize is the maximum size of a single file we should extract.
+	maxFileSize = 200 * 1024 * 1024 // 200 MiB
+)
+
+var (
+	log = capnslog.NewPackageLogger("github.com/coreos/clair", "worker")
+
+	// ErrUnsupported is the error that should be raised when an OS or package
+	// manager is not supported.
+	ErrUnsupported = errors.New("worker: OS and/or package manager are not supported")
+
+	// ErrParentUnknown is the error that should be raised when a parent layer
+	// has yet to be processed for the current layer.
+	ErrParentUnknown = errors.New("worker: parent layer is unknown, it must be processed first")
+
+	// SupportedOS is the list of operating system names that the worker supports.
+	SupportedOS = []string{"debian", "ubuntu", "centos"}
+)
+
+// Process detects the OS of a layer, the packages it installs/removes, and
+// then stores everything in the database.
+func Process(ID, parentID, path string) error {
+	if ID == "" {
+		return cerrors.NewBadRequestError("could not process a layer which does not have ID")
+	}
+	if path == "" {
+		return cerrors.NewBadRequestError("could not process a layer which does not have a path")
+	}
+
+	log.Debugf("layer %s: processing (Location: %s, Engine version: %d, Parent: %s)", ID, utils.CleanURL(path), Version, parentID)
+
+	// Check to see if the layer is already in the database.
+	layer, err := database.FindOneLayerByID(ID, []string{database.FieldLayerEngineVersion})
+	if err != nil && err != cerrors.ErrNotFound {
+		return err
+	}
+
+	var parent *database.Layer
+
+	if layer != nil {
+		// The layer is already in the database, check if we need to update it.
+		if layer.EngineVersion >= Version {
+			log.Debugf("layer %s: layer content has already been processed in the past with engine %d. Current engine is %d. skipping analysis", ID, layer.EngineVersion, Version)
+			return nil
+		}
+
+		log.Debugf("layer %s: layer content has been analyzed in the past with engine %d. Current engine is %d. analyzing again", ID, layer.EngineVersion, Version)
+	} else {
+		// The layer is a new one, create a base struct that we will fill.
+		layer = &database.Layer{ID: ID, EngineVersion: Version}
+
+		// Check to make sure that the parent's layer has already been processed.
+		if parentID != "" {
+			parent, err = database.FindOneLayerByID(parentID, []string{database.FieldLayerOS, database.FieldLayerPackages, database.FieldLayerPackages})
+			if err != nil && err != cerrors.ErrNotFound {
+				return err
+			}
+			if parent == nil {
+				log.Warningf("layer %s: the parent layer (%s) is unknown. it must be processed first", ID, parentID)
+				return ErrParentUnknown
+			}
+			layer.ParentNode = parent.GetNode()
+		}
+	}
+
+	// Analyze the content.
+	layer.OS, layer.InstalledPackagesNodes, layer.RemovedPackagesNodes, err = detectContent(ID, path, parent)
+	if err != nil {
+		return err
+	}
+
+	return database.InsertLayer(layer)
+}
+
+// detectContent downloads a layer's archive, extracts info from it and returns
+// an updated Layer struct.
+//
+// If parent is not nil, database.FieldLayerOS, database.FieldLayerPackages fields must be
+// has been selectioned.
+func detectContent(ID, path string, parent *database.Layer) (OS string, installedPackagesNodes, removedPackagesNodes []string, err error) {
+	data, err := getLayerData(path)
+	if err != nil {
+		log.Errorf("layer %s: failed to extract data from %s: %s", ID, path, err)
+		return
+	}
+
+	OS, err = detectOS(data, parent)
+	if err != nil {
+		return
+	}
+	log.Debugf("layer %s: OS is %s.", ID, OS)
+
+	packageList, err := detectors.DetectPackages(data)
+	if err != nil {
+		log.Errorf("layer %s: package list could not be determined: %s", ID, err)
+		return
+	}
+
+	// If there are any packages, that layer modified the package list.
+	if len(packageList) > 0 {
+		// It is possible that the OS could not be detected, in the case of a
+		// first layer setting MAINTAINER only for instance. However, if the OS
+		// is unknown and packages are detected, we have to return an error.
+		if OS == "" {
+			log.Errorf("layer %s: OS is unknown but %d packages have been detected", ID, len(packageList))
+			err = ErrUnsupported
+			return
+		}
+
+		// If the layer has no parent, it can only add packages, not remove them.
+		if parent == nil {
+			// Build a list of the layer packages' node values.
+			var installedPackages []*database.Package
+			for _, p := range packageList {
+				p.OS = OS
+				installedPackages = append(installedPackages, p)
+			}
+
+			// Insert that list into the database.
+			err = database.InsertPackages(installedPackages)
+			if err != nil {
+				return
+			}
+
+			// Set the InstalledPackageNodes field on content.
+			for _, p := range installedPackages {
+				if p.Node != "" {
+					installedPackagesNodes = append(installedPackagesNodes, p.Node)
+				}
+			}
+		} else {
+			installedPackagesNodes, removedPackagesNodes, err = detectAndInsertInstalledAndRemovedPackages(OS, packageList, parent)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	log.Debugf("layer %s: detected %d packages: installs %d and removes %d packages", ID, len(packageList), len(installedPackagesNodes), len(removedPackagesNodes))
+	return
+}
+
+// getLayerData downloads/opens a layer archive and extracts it into memory.
+func getLayerData(path string) (data map[string][]byte, err error) {
+	var layerReader io.ReadCloser
+	if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {
+		r, err := http.Get(path)
+		if err != nil {
+			return nil, cerrors.ErrCouldNotDownload
+		}
+		layerReader = r.Body
+	} else {
+		layerReader, err = os.Open(path)
+		if err != nil {
+			return nil, cerrors.ErrNotFound
+		}
+	}
+	defer layerReader.Close()
+
+	data, err = utils.SelectivelyExtractArchive(layerReader, append(detectors.GetRequiredFilesPackages(), detectors.GetRequiredFilesOS()...), maxFileSize)
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+func detectOS(data map[string][]byte, parent *database.Layer) (detectedOS string, err error) {
+	detectedOS = detectors.DetectOS(data)
+
+	// Attempt to detect the OS from the parent layer.
+	if detectedOS == "" && parent != nil {
+		detectedOS, err = parent.OperatingSystem()
+		if err != nil {
+			return "", err
+		}
+	}
+
+	// If the detectedOS is not in the supported OS list, the OS is unsupported.
+	if detectedOS != "" {
+		isSupported := false
+		for _, osPrefix := range SupportedOS {
+			if strings.HasPrefix(detectedOS, osPrefix) {
+				isSupported = true
+				break
+			}
+		}
+		if !isSupported {
+			return "", ErrUnsupported
+		}
+	}
+
+	return
+}
+
+// detectAndInsertInstalledAndRemovedPackages finds the installed and removed
+// package nodes and inserts the installed packages into the database.
+func detectAndInsertInstalledAndRemovedPackages(detectedOS string, packageList []*database.Package, parent *database.Layer) (installedNodes, removedNodes []string, err error) {
+	// Get the parent layer's packages.
+	parentPackageNodes, err := parent.AllPackages()
+	if err != nil {
+		return nil, nil, err
+	}
+	parentPackages, err := database.FindAllPackagesByNodes(parentPackageNodes, []string{database.FieldPackageName, database.FieldPackageVersion})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Map detected packages (name:version) string to packages.
+	packagesNVMapToPackage := make(map[string]*database.Package)
+	for _, p := range packageList {
+		packagesNVMapToPackage[p.Name+":"+p.Version.String()] = p
+	}
+
+	// Map parent's packages (name:version) string to nodes.
+	parentPackagesNVMapToNodes := make(map[string]string)
+	for _, p := range parentPackages {
+		parentPackagesNVMapToNodes[p.Name+":"+p.Version.String()] = p.Node
+	}
+
+	// Build a list of the parent layer's packages' node values.
+	var parentPackagesNV []string
+	for _, p := range parentPackages {
+		parentPackagesNV = append(parentPackagesNV, p.Name+":"+p.Version.String())
+	}
+
+	// Build a list of the layer packages' node values.
+	var layerPackagesNV []string
+	for _, p := range packageList {
+		layerPackagesNV = append(layerPackagesNV, p.Name+":"+p.Version.String())
+	}
+
+	// Calculate the installed and removed packages.
+	removedPackagesNV := utils.CompareStringLists(parentPackagesNV, layerPackagesNV)
+	installedPackagesNV := utils.CompareStringLists(layerPackagesNV, parentPackagesNV)
+
+	// Build a list of all the installed packages.
+	var installedPackages []*database.Package
+	for _, nv := range installedPackagesNV {
+		p, _ := packagesNVMapToPackage[nv]
+		p.OS = detectedOS
+		installedPackages = append(installedPackages, p)
+	}
+
+	// Insert that list into the database.
+	err = database.InsertPackages(installedPackages)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Build the list of installed package nodes.
+	for _, p := range installedPackages {
+		if p.Node != "" {
+			installedNodes = append(installedNodes, p.Node)
+		}
+	}
+
+	// Build the list of removed package nodes.
+	for _, nv := range removedPackagesNV {
+		node, _ := parentPackagesNVMapToNodes[nv]
+		removedNodes = append(removedNodes, node)
+	}
+
+	return
+}
diff --git a/worker/worker_test.go b/worker/worker_test.go
new file mode 100644
index 00000000..a80a601f
--- /dev/null
+++ b/worker/worker_test.go
@@ -0,0 +1,67 @@
+package worker
+
+import (
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/coreos/clair/database"
+	"github.com/coreos/clair/utils/types"
+	"github.com/stretchr/testify/assert"
+
+	// Register detectors
+	_ "github.com/coreos/clair/worker/detectors/os"
+	_ "github.com/coreos/clair/worker/detectors/packages"
+)
+
+func TestDistUpgrade(t *testing.T) {
+	database.Open("memstore", "")
+	defer database.Close()
+
+	_, f, _, _ := runtime.Caller(0)
+	path := path.Join(path.Dir(f)) + "/testdata/DistUpgrade/"
+
+	// blank.tar: MAINTAINER Quentin MACHU <quentin.machu.fr>
+	// wheezy.tar: FROM debian:wheezy
+	// jessie.tar: RUN sed -i "s/precise/trusty/" /etc/apt/sources.list && apt-get update && apt-get -y dist-upgrade
+	assert.Nil(t, Process("blank", "", path+"blank.tar.gz"))
+	assert.Nil(t, Process("wheezy", "blank", path+"wheezy.tar.gz"))
+	assert.Nil(t, Process("jessie", "wheezy", path+"jessie.tar.gz"))
+
+	wheezy, err := database.FindOneLayerByID("wheezy", database.FieldLayerAll)
+	if assert.Nil(t, err) {
+		assert.Equal(t, "debian:7", wheezy.OS)
+		assert.Len(t, wheezy.InstalledPackagesNodes, 52)
+		assert.Len(t, wheezy.RemovedPackagesNodes, 0)
+
+		jessie, err := database.FindOneLayerByID("jessie", database.FieldLayerAll)
+		if assert.Nil(t, err) {
+			assert.Equal(t, "debian:8", jessie.OS)
+			assert.Len(t, jessie.InstalledPackagesNodes, 66)
+			assert.Len(t, jessie.RemovedPackagesNodes, 44)
+
+			packageNodes, err := jessie.AllPackages()
+			if assert.Nil(t, err) {
+				// These packages haven't been upgraded
+				nonUpgradedPackages := []database.Package{
+					database.Package{Name: "libtext-wrapi18n-perl", Version: types.NewVersionUnsafe("0.06-7")},
+					database.Package{Name: "libtext-charwidth-perl", Version: types.NewVersionUnsafe("0.04-7")},
+					database.Package{Name: "libtext-iconv-perl", Version: types.NewVersionUnsafe("1.7-5")},
+					database.Package{Name: "mawk", Version: types.NewVersionUnsafe("1.3.3-17")},
+					database.Package{Name: "insserv", Version: types.NewVersionUnsafe("1.14.0-5")},
+					database.Package{Name: "db", Version: types.NewVersionUnsafe("5.1.29-5")},
+					database.Package{Name: "ustr", Version: types.NewVersionUnsafe("1.0.4-3")},
+					database.Package{Name: "xz-utils", Version: types.NewVersionUnsafe("5.1.1alpha+20120614-2")},
+				}
+				for _, p := range nonUpgradedPackages {
+					p.OS = "debian:7"
+					assert.Contains(t, packageNodes, p.GetNode(), "Jessie layer doesn't have %s but it should.", p)
+				}
+				for _, p := range nonUpgradedPackages {
+					p.OS = "debian:8"
+					assert.NotContains(t, packageNodes, p.GetNode(), "Jessie layer has %s but it shouldn't.", p)
+				}
+			}
+		}
+	}
+}