Initialise Harbor DB schema in Harbor UI/adminserver container

This commit fixes #5040, the harbor-db image will only contain empty databases, and harbor ui container will use migrate tool to run initial SQL scripts to do initialization. This is helpful for the case to configure Harbor against external DB or DBaaS like RDS for HA deployment However, this change will results some confusion as there are two tables to track schema versions have been using alembic for migration, for this release we'll try to use alembic to mock a `migration` table during upgrade so the migrator will be bypassed, in future we'll consider to consolidate to the golang based migrator. Another issue is that the UI and adminserver containers will access DB after start up in different congurations, can't ensure the sequence, so both of them will try to update the schema when started up.
2025-04-07 19:31:30 +00:00 · 2018-06-27 17:49:46 +08:00 · 2018-06-27 17:49:46 +08:00 · c9b1962b1e
commit c9b1962b1e
parent fcae81a034
189 changed files with 10914 additions and 17 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -99,7 +99,7 @@ script:
  - sudo ./admiral.sh 
  - cd .. 
  - go test -race -i ./src/ui ./src/adminserver ./src/jobservice
-  - sudo -E env "PATH=$PATH" ./tests/coverage4gotest.sh
+  - sudo -E env "PATH=$PATH" "POSTGRES_MIGRATION_SCRIPTS_PATH=/home/travis/gopath/src/github.com/vmware/harbor/make/migrations/postgresql/" ./tests/coverage4gotest.sh
  - goveralls -coverprofile=profile.cov -service=travis-ci
  - docker-compose -f make/docker-compose.test.yml down
  - sudo rm -rf /data/config/*
--- a/make/dev/adminserver/Dockerfile
+++ b/make/dev/adminserver/Dockerfile
@ -8,5 +8,7 @@ WORKDIR /go/src/github.com/vmware/harbor/src/adminserver

 RUN go build -a -o /go/bin/harbor_adminserver \
    && chmod u+x /go/bin/harbor_adminserver 
+
+COPY ./make/migrations /go/bin/migrations
 WORKDIR /go/bin/
 ENTRYPOINT ["/go/bin/harbor_adminserver"]
--- a/make/migrations/postgresql/0001_initial_schema.up.sql
+++ b/make/migrations/postgresql/0001_initial_schema.up.sql
@ -1,7 +1,3 @@
-CREATE DATABASE registry ENCODING 'UTF8';
-
-\c registry;
-
 create table access (
 access_id SERIAL PRIMARY KEY NOT NULL,
 access_code char(1),
--- a/make/photon/adminserver/Dockerfile
+++ b/make/photon/adminserver/Dockerfile
@ -7,6 +7,9 @@ RUN tdnf erase vim -y \
    && groupadd -r -g 10000 harbor && useradd --no-log-init -r -g 10000 -u 10000 harbor \
    && mkdir /harbor/
 COPY ./make/dev/adminserver/harbor_adminserver ./make/photon/adminserver/start.sh /harbor/
+#There is a race condition that both ui and adminserver may initialize schema
+COPY ./make/migrations /harbor/migrations
+
 HEALTHCHECK CMD curl --fail -s http://127.0.0.1:8080/api/ping || exit 1 

 RUN chmod u+x /harbor/harbor_adminserver /harbor/start.sh
--- a/make/photon/db/Dockerfile
+++ b/make/photon/db/Dockerfile
@ -26,10 +26,9 @@ RUN chmod u+x /entrypoint.sh /docker-healthcheck.sh
 ENTRYPOINT ["/entrypoint.sh"]
 HEALTHCHECK CMD ["/docker-healthcheck.sh"]

-COPY registry.sql /docker-entrypoint-initdb.d/
-
 COPY initial-notaryserver.sql /docker-entrypoint-initdb.d/ 
 COPY initial-notarysigner.sql /docker-entrypoint-initdb.d/
+COPY initial-registry.sql /docker-entrypoint-initdb.d/

 EXPOSE 5432
-CMD ["postgres"]
+CMD ["postgres"]
--- a/make/photon/db/initial-registry.sql
+++ b/make/photon/db/initial-registry.sql
@ -0,0 +1,2 @@
+CREATE DATABASE registry ENCODING 'UTF8';
+
--- a/make/photon/ui/Dockerfile
+++ b/make/photon/ui/Dockerfile
@ -11,6 +11,8 @@ HEALTHCHECK CMD curl --fail -s http://127.0.0.1:8080/api/ping || exit 1
 COPY ./make/dev/ui/harbor_ui ./src/favicon.ico ./make/photon/ui/start.sh ./UIVERSION /harbor/
 COPY ./src/ui/views /harbor/views
 COPY ./src/ui/static /harbor/static
+#There is a race condition that both ui and adminserver may initialize schema
+COPY ./make/migrations /harbor/migrations

 RUN chmod u+x /harbor/start.sh /harbor/harbor_ui
 WORKDIR /harbor/
--- a/src/Gopkg.lock
+++ b/src/Gopkg.lock
@ -134,6 +134,18 @@
  revision = "67c8dc210ce647e8d8a4206c7f5856ea2390f290"
  version = "v0.5.0"

+[[projects]]
+  name = "github.com/golang-migrate/migrate"
+  packages = [
+    ".",
+    "database",
+    "database/postgres",
+    "source",
+    "source/file"
+  ]
+  revision = "bcd996f3df28363f43e2d0935484c4559537a3eb"
+  version = "v3.3.0"
+
 [[projects]]
  name = "github.com/golang/protobuf"
  packages = ["proto"]
@ -275,6 +287,6 @@
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
-  inputs-digest = "e690fed3ef15e012cf97d5a1eb70fcb90ea051b54d7472e4c804291d08a58c80"
+  inputs-digest = "a53e62d0a95585213a5c0519e5c02c570201189b9332d9dfca730d5671619dab"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/src/Gopkg.toml
+++ b/src/Gopkg.toml
@ -78,4 +78,9 @@ ignored = ["github.com/vmware/harbor/tests*"]

 [[override]]
  name = "github.com/garyburd/redigo"
-  version = "=1.6.0"
+  version = "=1.6.0"
+
+
+[[constraint]]
+  name = "github.com/golang-migrate/migrate"
+  version = "=3.3.0"
--- a/src/adminserver/systemcfg/systemcfg.go
+++ b/src/adminserver/systemcfg/systemcfg.go
@ -289,7 +289,8 @@ func initCfgStore() (err error) {
 			return err
 		}
 		cfgdb := GetDatabaseFromCfg(cfgs)
-		if err = dao.InitDatabase(cfgdb); err != nil {
+		//Initialize the schema.
+		if err = dao.InitDatabase(cfgdb, true); err != nil {
 			return err
 		}
 		CfgStore, err = database.NewCfgStore()
--- a/src/common/dao/base.go
+++ b/src/common/dao/base.go
@ -40,6 +40,8 @@ type Database interface {
 	String() string
 	// Register registers the database which will be used
 	Register(alias ...string) error
+	// UpgradeSchema upgrades the DB schema to the latest version
+	UpgradeSchema() error
 }

 // InitClairDB ...
@ -60,8 +62,9 @@ func InitClairDB(clairDB *models.PostGreSQL) error {
 	return nil
 }

-// InitDatabase initializes the database
-func InitDatabase(database *models.Database) error {
+// InitDatabase initializes the database, there's an optional parm as a flag
+// to indicate whether it should initialize the schema.
+func InitDatabase(database *models.Database, initSchema ...bool) error {
 	db, err := getDatabase(database)
 	if err != nil {
 		return err
@ -71,6 +74,12 @@ func InitDatabase(database *models.Database) error {
 	if err := db.Register(); err != nil {
 		return err
 	}
+	if len(initSchema) > 0 && initSchema[0] {
+		err := db.UpgradeSchema()
+		if err != nil {
+			return err
+		}
+	}

 	version, err := GetSchemaVersion()
 	if err != nil {
@ -86,9 +95,10 @@ func InitDatabase(database *models.Database) error {
 }

 func getDatabase(database *models.Database) (db Database, err error) {
+
 	switch database.Type {
 	case "", "postgresql":
-		db = NewPQSQL(database.PostGreSQL.Host,
+		db = NewPGSQL(database.PostGreSQL.Host,
 			strconv.Itoa(database.PostGreSQL.Port),
 			database.PostGreSQL.Username,
 			database.PostGreSQL.Password,
--- a/src/common/dao/mysql.go
+++ b/src/common/dao/mysql.go
@ -72,6 +72,11 @@ func (m *mysql) Name() string {
 	return "MySQL"
 }

+// UpgradeSchema is not supported for MySQL, it assumes the schema is initialized and up to date in the DB instance.
+func (m *mysql) UpgradeSchema() error {
+	return nil
+}
+
 // String returns the details of database
 func (m *mysql) String() string {
 	return fmt.Sprintf("type-%s host-%s port-%s user-%s database-%s",
--- a/src/common/dao/pgsql.go
+++ b/src/common/dao/pgsql.go
@ -16,12 +16,20 @@ package dao

 import (
 	"fmt"
+	"os"

 	"github.com/astaxie/beego/orm"
+	"github.com/golang-migrate/migrate"
+	_ "github.com/golang-migrate/migrate/database/postgres" //import pgsql driver for migrator
+	_ "github.com/golang-migrate/migrate/source/file"       // import local file driver for migrator
+
 	_ "github.com/lib/pq" //register pgsql driver
 	"github.com/vmware/harbor/src/common/utils"
+	"github.com/vmware/harbor/src/common/utils/log"
 )

+const defaultMigrationPath = "migrations/postgresql/"
+
 type pgsql struct {
 	host     string
 	port     string
@ -51,8 +59,8 @@ func (p *pgsql) String() string {
 		p.Name(), p.host, p.port, p.database, pgsqlSSLMode(p.sslmode))
 }

-// NewPQSQL returns an instance of postgres
-func NewPQSQL(host string, port string, usr string, pwd string, database string, sslmode bool) Database {
+// NewPGSQL returns an instance of postgres
+func NewPGSQL(host string, port string, usr string, pwd string, database string, sslmode bool) Database {
 	return &pgsql{
 		host:     host,
 		port:     port,
@ -82,3 +90,33 @@ func (p *pgsql) Register(alias ...string) error {

 	return orm.RegisterDataBase(an, "postgres", info)
 }
+
+//UpgradeSchema calls migrate tool to upgrade schema to the latest based on the SQL scripts.
+func (p *pgsql) UpgradeSchema() error {
+	dbURL := fmt.Sprintf("postgres://%s:%s@%s:%s/%s?sslmode=%s", p.usr, p.pwd, p.host, p.port, p.database, pgsqlSSLMode(p.sslmode))
+	//For UT
+	path := os.Getenv("POSTGRES_MIGRATION_SCRIPTS_PATH")
+	if len(path) == 0 {
+		path = defaultMigrationPath
+	}
+	srcURL := fmt.Sprintf("file://%s", path)
+	m, err := migrate.New(srcURL, dbURL)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		srcErr, dbErr := m.Close()
+		if srcErr != nil || dbErr != nil {
+			log.Warningf("Failed to close migrator, source error: %v, db error: %v", srcErr, dbErr)
+		}
+	}()
+	log.Infof("Upgrading schema for pgsql ...")
+	err = m.Up()
+	if err == migrate.ErrNoChange {
+		log.Infof("No change in schema, skip.")
+	} else if err != nil { //migrate.ErrLockTimeout will be thrown when another process is doing migration and timeout.
+		log.Errorf("Failed to upgrade schema, error: %q", err)
+		return err
+	}
+	return nil
+}
--- a/src/common/dao/sqlite.go
+++ b/src/common/dao/sqlite.go
@ -54,3 +54,8 @@ func (s *sqlite) Name() string {
 func (s *sqlite) String() string {
 	return fmt.Sprintf("type-%s file:%s", s.Name(), s.file)
 }
+
+// UpgradeSchema is not supported for SQLite, it assumes the schema is initialized and up to date in the DB instance.
+func (s *sqlite) UpgradeSchema() error {
+	return nil
+}
--- a/src/common/dao/testutils.go
+++ b/src/common/dao/testutils.go
@ -89,6 +89,9 @@ func initDatabaseForTest(db *models.Database) {
 	if err := database.Register(alias); err != nil {
 		panic(err)
 	}
+	if err := database.UpgradeSchema(); err != nil {
+		panic(err)
+	}

 	if alias != "default" {
 		if err = globalOrm.Using(alias); err != nil {
--- a/src/ui/main.go
+++ b/src/ui/main.go
@ -91,7 +91,7 @@ func main() {
 	if err != nil {
 		log.Fatalf("failed to get database configuration: %v", err)
 	}
-	if err := dao.InitDatabase(database); err != nil {
+	if err := dao.InitDatabase(database, true); err != nil {
 		log.Fatalf("failed to initialize database: %v", err)
 	}
 	if config.WithClair() {
--- a/src/vendor/github.com/golang-migrate/migrate/.dockerignore
+++ b/src/vendor/github.com/golang-migrate/migrate/.dockerignore
@ -0,0 +1,13 @@
+# Project
+FAQ.md
+README.md
+LICENSE
+Makefile
+.gitignore
+.travis.yml
+CONTRIBUTING.md
+MIGRATIONS.md
+docker-deploy.sh
+
+# Golang
+testing
--- a/src/vendor/github.com/golang-migrate/migrate/.gitignore
+++ b/src/vendor/github.com/golang-migrate/migrate/.gitignore
@ -0,0 +1,7 @@
+.DS_Store
+cli/build
+cli/cli
+cli/migrate
+.coverage
+.godoc.pid
+vendor/
--- a/src/vendor/github.com/golang-migrate/migrate/.travis.yml
+++ b/src/vendor/github.com/golang-migrate/migrate/.travis.yml
@ -0,0 +1,82 @@
+language: go
+sudo: required
+
+go:
+  - "1.9.x"
+  - "1.10.x"
+
+go_import_path: github.com/golang-migrate/migrate
+
+env:
+  global:
+    - MIGRATE_TEST_CONTAINER_BOOT_TIMEOUT=60
+    - DOCKER_USERNAME=golangmigrate
+    -   secure: "oSOznzUrgr5h45qW4PONkREpisPAt40tnM+KFWtS/Ggu5UI2Ie0CmyYXWuBjbt7B97a4yN9Qzmn8FxJHJ7kk+ABOi3muhkxeIhr6esXbzHhX/Jhv0mj1xkzX7KoVN9oHBz3cOI/QeRyEAO68xjDHNE2kby4RTT9VBt6TQUakKVkqI5qkqLBTADepCjVC+9XhxVxUNyeWKU8ormaUfJBjoNVoDlwXekUPnJenfmfZqXxUInvBCfUyp7Pq+kurBORmg4yc6qOlRYuK67Xw+i5xpjbZouNlXPk0rq7pPy5zjhmZQ3kImoFPvNMeKViDcI6kSIJKtjdhms9/g/6MgXS9HlL5kFy8tYKbsyiHnHB1BsvaLAKXctbUZFDPstgMPADfnad2kZXPrNqIhfWKZrGRWidawCYJ1sKKwYxLMKrtA0umqgMoL90MmBOELhuGmvMV0cFJB+zo+K2YWjEiMGd8xRb5mC5aAy0ZcCehO46jGtpr217EJmMF8Ywr7cFqM2Shg5U2jev9qUpYiXwmPnJKDuoT2ZHuHmPgFIkYiWC5yeJnnmG5bed1sKBp93AFrJX+1Rx5oC4BpNegewmBZKpOSwls/D1uMAeQK3dPmQHLsT6o2VBLfeDGr+zY0R85ywwPZCv00vGol02zYoTqN7eFqr6Qhjr/qx5K1nnxJdFK3Ts="
+
+services:
+  - docker
+
+before_cache:
+  - mv $GOPATH/src/github.com/golang-migrate /tmp/golang-migrate
+  - rm -rf $GOPATH/pkg/**/github.com/golang-migrate
+
+cache:
+  directories:
+    - $GOPATH/pkg
+
+before_install:
+  # Download the binary to bin folder in $GOPATH
+  - curl -L -s https://github.com/golang/dep/releases/download/v0.4.1/dep-linux-amd64 -o $GOPATH/bin/dep
+  # Make the binary executable
+  - chmod +x $GOPATH/bin/dep
+
+install:
+  - dep ensure -vendor-only
+  - go get github.com/mattn/goveralls
+
+script:
+  - make test COVERAGE_DIR=/tmp/coverage
+
+after_success:
+  - mv /tmp/golang-migrate $GOPATH/src/github.com/golang-migrate
+  - goveralls -service=travis-ci -coverprofile /tmp/coverage/combined.txt
+  - make list-external-deps > dependency_tree.txt && cat dependency_tree.txt
+
+before_deploy:
+  - make build-cli
+  - gem install --no-ri --no-rdoc fpm 
+  - fpm -s dir -t deb -n migrate -v "$(git describe --tags 2>/dev/null | cut -c 2-)" --license MIT -m dhui@users.noreply.github.com --url https://github.com/golang-migrate/migrate --description='Database migrations' -a amd64 -p migrate.$(git describe --tags 2>/dev/null | cut -c 2-).deb --deb-no-default-config-files -f -C cli/build migrate.linux-amd64=/usr/bin/migrate
+
+deploy:
+  - provider: releases
+    api_key:
+      secure: hWH1HLPpzpfA8pXQ93T1qKQVFSpQp0as/JLQ7D91jHuJ8p+RxVeqblDrR6HQY/95R/nyiE9GJmvUolSuw5h449LSrGxPtVWhdh6EnkxlQHlen5XeMhVjRjFV0sE9qGe8v7uAkiTfRO61ktTWHrEAvw5qpyqnNISodmZS78XIasPODQbNlzwINhWhDTHIjXGb4FpizYaL3OGCanrxfR9fQyCaqKGGBjRq3Mfq8U6Yd4mApmsE+uJxgaZV8K5zBqpkSzQRWhcVGNL5DuLsU3gfSJOo7kZeA2G71SHffH577dBoqtCZ4VFv169CoUZehLWCb+7XKJZmHXVujCURATSySLGUOPc6EoLFAn3YtsCA04mS4bZVo5FZPWVwfhjmkhtDR4f6wscKp7r1HsFHSOgm59QfETQdrn4MnZ44H2Jd39axqndn5DvK9EcZVjPHynOPnueXP2u6mTuUgh2VyyWBCDO3CNo0fGlo7VJI69IkIWNSD87K9cHZWYMClyKZkUzS+PmRAhHRYbVd+9ZjKOmnU36kUHNDG/ft1D4ogsY+rhVtXB4lgWDM5adri+EIScYdYnB1/pQexLBigcJY9uE7nQTR0U6QgVNYvun7uRNs40E0c4voSfmPdFO0FlOD2y1oQhnaXfWLbu9nMcTcs4RFGrcC7NzkUN4/WjG8s285V6w=
+    skip_cleanup: true
+    on:
+      go: "1.10.x"
+      repo: golang-migrate/migrate
+      tags: true
+    file:
+      - cli/build/migrate.linux-amd64.tar.gz
+      - cli/build/migrate.darwin-amd64.tar.gz
+      - cli/build/migrate.windows-amd64.exe.tar.gz
+      - cli/build/sha256sum.txt
+      - dependency_tree.txt
+  - provider: packagecloud
+    repository: migrate
+    username: golang-migrate
+    token:
+      secure: aICwu3gJ1sJ1QVCD3elpg+Jxzt4P+Zj1uoh5f0sOwnjDNIZ4FwUT1cMrWloP8P2KD0iyCOawuZER27o/kQ21oX2OxHvQbYPReA2znLm7lHzCmypAAOHPxpgnQ4rMGHHJXd+OsxtdclGs67c+EbdBfoRRbK400Qz/vjPJEDeH4mh02ZHC2nw4Nk/wV4jjBIkIt9dGEx6NgOA17FCMa3MaPHlHeFIzU7IfTlDHbS0mCCYbg/wafWBWcbGqtZLWAYtJDmfjrAStmDLdAX5J5PsB7taGSGPZHmPmpGoVgrKt/tb9Xz1rFBGslTpGROOiO4CiMAvkEKFn8mxrBGjfSBqp7Dp3eeSalKXB1DJAbEXx2sEbMcvmnoR9o43meaAn+ZRts8lRL8S/skBloe6Nk8bx3NlJCGB9WPK1G56b7c/fZnJxQbrCw6hxDfbZwm8S2YPviFTo/z1BfZDhRsL74reKsN2kgnGo2W/k38vvzIpsssQ9DHN1b0TLCxolCNPtQ7oHcQ1ohcjP2UgYXk0FhqDoL+9LQva/DU4N9sKH0UbAaqsMVSErLeG8A4aauuFcVrWRBaDYyTag4dQqzTulEy7iru2kDDIBgSQ1gMW/yoBOIPK4oi6MtbTf1X39fzXFLS1cDd3LW61yAu3YrbjAetpfx2frIvrRAiL9TxWA1gnrs5o=
+    dist: ubuntu/xenial
+    package_glob: '*.deb'
+    skip_cleanup: true
+    on:
+      go: "1.10.x"
+      repo: golang-migrate/migrate
+      tags: true
+  - provider: script
+    script: ./docker-deploy.sh
+    on:
+      go: "1.10.x"
+      repo: golang-migrate/migrate
+      tags: true
--- a/src/vendor/github.com/golang-migrate/migrate/CONTRIBUTING.md
+++ b/src/vendor/github.com/golang-migrate/migrate/CONTRIBUTING.md
@ -0,0 +1,21 @@
+# Development, Testing and Contributing
+
+  1. Make sure you have a running Docker daemon
+     (Install for [MacOS](https://docs.docker.com/docker-for-mac/))
+  1. Fork this repo and `git clone` somewhere to `$GOPATH/src/github.com/golang-migrate/migrate`
+  1. Install [dep](https://github.com/golang/dep) and run `dep ensure` to pull dependencies
+  1. Confirm tests are working: `make test-short`
+  1. Write awesome code ...
+  1. `make test` to run all tests against all database versions
+  1. Push code and open Pull Request
+ 
+Some more helpful commands:
+
+  * You can specify which database/ source tests to run:
+    `make test-short SOURCE='file go_bindata' DATABASE='postgres cassandra'`
+  * After `make test`, run `make html-coverage` which opens a shiny test coverage overview.
+  * `make build-cli` builds the CLI in directory `cli/build/`.
+  * `make list-external-deps` lists all external dependencies for each package
+  * `make docs && make open-docs` opens godoc in your browser, `make kill-docs` kills the godoc server.
+    Repeatedly call `make docs` to refresh the server.
+  * Set the `DOCKER_API_VERSION` environment variable to the latest supported version if you get errors regarding the docker client API version being too new.
--- a/src/vendor/github.com/golang-migrate/migrate/Dockerfile
+++ b/src/vendor/github.com/golang-migrate/migrate/Dockerfile
@ -0,0 +1,31 @@
+FROM golang:1.10-alpine3.7 AS downloader
+ARG VERSION
+
+RUN apk add --no-cache git gcc musl-dev curl
+
+RUN curl -fsSL -o /usr/local/bin/dep https://github.com/golang/dep/releases/download/v0.4.1/dep-linux-amd64 && chmod +x /usr/local/bin/dep
+
+WORKDIR /go/src/github.com/golang-migrate/migrate
+
+COPY Gopkg.toml Gopkg.lock ./
+RUN dep ensure -vendor-only
+
+COPY *.go ./
+COPY cli ./cli
+COPY database ./database
+COPY source ./source
+
+ENV DATABASES="postgres mysql redshift cassandra spanner cockroachdb clickhouse"
+ENV SOURCES="file go_bindata github aws_s3 google_cloud_storage"
+
+RUN go build -a -o build/migrate.linux-386 -ldflags="-X main.Version=${VERSION}" -tags "$DATABASES $SOURCES" ./cli
+
+FROM alpine:3.7
+
+RUN apk add --no-cache ca-certificates
+
+COPY --from=downloader /go/src/github.com/golang-migrate/migrate/build/migrate.linux-386 /migrate
+RUN chmod u+x /migrate
+
+ENTRYPOINT ["/migrate"]
+CMD ["--help"]
--- a/src/vendor/github.com/golang-migrate/migrate/FAQ.md
+++ b/src/vendor/github.com/golang-migrate/migrate/FAQ.md
@ -0,0 +1,67 @@
+# FAQ
+
+#### How is the code base structured?
+  ```
+  /          package migrate (the heart of everything)
+  /cli       the CLI wrapper
+  /database  database driver and sub directories have the actual driver implementations
+  /source    source driver and sub directories have the actual driver implementations
+  ```
+
+#### Why is there no `source/driver.go:Last()`?
+  It's not needed. And unless the source has a "native" way to read a directory in reversed order,
+  it might be expensive to do a full directory scan in order to get the last element.
+
+#### What is a NilMigration? NilVersion?
+  NilMigration defines a migration without a body. NilVersion is defined as const -1.
+
+#### What is the difference between uint(version) and int(targetVersion)?
+  version refers to an existing migration version coming from a source and therefor can never be negative.
+  targetVersion can either be a version OR represent a NilVersion, which equals -1.
+
+#### What's the difference between Next/Previous and Up/Down?
+  ```
+  1_first_migration.up.extension           next ->  2_second_migration.up.extension      ...
+  1_first_migration.down.extension  <- previous     2_second_migration.down.extension    ...
+  ```
+
+#### Why two separate files (up and down) for a migration?
+  It makes all of our lives easier. No new markup/syntax to learn for users
+  and existing database utility tools continue to work as expected.
+
+#### How many migrations can migrate handle?
+  Whatever the maximum positive signed integer value is for your platform.
+  For 32bit it would be 2,147,483,647 migrations. Migrate only keeps references to
+  the currently run and pre-fetched migrations in memory. Please note that some
+  source drivers need to do build a full "directory" tree first, which puts some
+  heat on the memory consumption.
+
+#### Are the table tests in migrate_test.go bloated?
+  Yes and no. There are duplicate test cases for sure but they don't hurt here. In fact
+  the tests are very visual now and might help new users understand expected behaviors quickly.
+  Migrate from version x to y and y is the last migration? Just check out the test for
+  that particular case and know what's going on instantly.
+
+#### What is Docker being used for?
+  Only for testing. See [testing/docker.go](testing/docker.go)
+
+#### Why not just use docker-compose?
+  It doesn't give us enough runtime control for testing. We want to be able to bring up containers fast
+  and whenever we want, not just once at the beginning of all tests.
+
+#### Can I maintain my driver in my own repository?
+  Yes, technically thats possible. We want to encourage you to contribute your driver to this respository though.
+  The driver's functionality is dictated by migrate's interfaces. That means there should really
+  just be one driver for a database/ source. We want to prevent a future where several drivers doing the exact same thing,
+  just implemented a bit differently, co-exist somewhere on Github. If users have to do research first to find the
+  "best" available driver for a database in order to get started, we would have failed as an open source community.
+
+#### Can I mix multiple sources during a batch of migrations?
+  No.
+
+#### What does "dirty" database mean?
+  Before a migration runs, each database sets a dirty flag. Execution stops if a migration fails and the dirty state persists,
+  which prevents attempts to run more migrations on top of a failed migration. You need to manually fix the error
+  and then "force" the expected version.
+
+
--- a/src/vendor/github.com/golang-migrate/migrate/Gopkg.lock
+++ b/src/vendor/github.com/golang-migrate/migrate/Gopkg.lock
@ -0,0 +1,514 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "cloud.google.com/go"
+  packages = [
+    "civil",
+    "compute/metadata",
+    "iam",
+    "internal",
+    "internal/atomiccache",
+    "internal/fields",
+    "internal/optional",
+    "internal/protostruct",
+    "internal/trace",
+    "internal/version",
+    "longrunning",
+    "longrunning/autogen",
+    "spanner",
+    "spanner/admin/database/apiv1",
+    "storage"
+  ]
+  revision = "0fd7230b2a7505833d5f69b75cbd6c9582401479"
+  version = "v0.23.0"
+
+[[projects]]
+  name = "github.com/Microsoft/go-winio"
+  packages = ["."]
+  revision = "7da180ee92d8bd8bb8c37fc560e673e6557c392f"
+  version = "v0.4.7"
+
+[[projects]]
+  name = "github.com/Sirupsen/logrus"
+  packages = ["."]
+  revision = "d26492970760ca5d33129d2d799e34be5c4782eb"
+  version = "v0.11.0"
+
+[[projects]]
+  name = "github.com/aws/aws-sdk-go"
+  packages = [
+    "aws",
+    "aws/awserr",
+    "aws/awsutil",
+    "aws/client",
+    "aws/client/metadata",
+    "aws/corehandlers",
+    "aws/credentials",
+    "aws/credentials/ec2rolecreds",
+    "aws/credentials/endpointcreds",
+    "aws/credentials/stscreds",
+    "aws/defaults",
+    "aws/ec2metadata",
+    "aws/endpoints",
+    "aws/request",
+    "aws/session",
+    "aws/signer/v4",
+    "internal/sdkio",
+    "internal/sdkrand",
+    "internal/shareddefaults",
+    "private/protocol",
+    "private/protocol/query",
+    "private/protocol/query/queryutil",
+    "private/protocol/rest",
+    "private/protocol/restxml",
+    "private/protocol/xml/xmlutil",
+    "service/s3",
+    "service/s3/s3iface",
+    "service/sts"
+  ]
+  revision = "31a85efbe3bc741eb539d6310c8e66030b7c5cb7"
+  version = "v1.13.47"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cockroachdb/cockroach-go"
+  packages = ["crdb"]
+  revision = "59c0560478b705bf9bd12f9252224a0fad7c87df"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cznic/b"
+  packages = ["."]
+  revision = "35e9bbe41f07452a183c517a5fc5f3c9f45eaa0f"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cznic/fileutil"
+  packages = ["."]
+  revision = "6a051e75936f623600b67c2b1116b6b6c0ffb936"
+
+[[projects]]
+  name = "github.com/cznic/internal"
+  packages = [
+    "buffer",
+    "file",
+    "slice"
+  ]
+  revision = "cef02a853c3a93623c42eacd574e7ea05f55531b"
+  version = "1.0.0"
+
+[[projects]]
+  name = "github.com/cznic/lldb"
+  packages = ["."]
+  revision = "bea8611dd5c407f3c5eab9f9c68e887a27dc6f0e"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cznic/mathutil"
+  packages = ["."]
+  revision = "ca4c9f2c136954238c3158b92de72078c7672ecc"
+
+[[projects]]
+  name = "github.com/cznic/ql"
+  packages = [
+    ".",
+    "driver",
+    "vendored/github.com/camlistore/go4/lock"
+  ]
+  revision = "7a63cd7aa46ecd9f549b96983029576af2178f60"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cznic/sortutil"
+  packages = ["."]
+  revision = "4c7342852e65c2088c981288f2c5610d10b9f7f4"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cznic/strutil"
+  packages = ["."]
+  revision = "529a34b1c186b483642a7a230c67521d9aa4b0fb"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/cznic/zappy"
+  packages = ["."]
+  revision = "2533cb5b45cc6c07421468ce262899ddc9d53fb7"
+
+[[projects]]
+  name = "github.com/docker/distribution"
+  packages = [
+    "digestset",
+    "reference"
+  ]
+  revision = "b38e5838b7b2f2ad48e06ec4b500011976080621"
+
+[[projects]]
+  name = "github.com/docker/docker"
+  packages = [
+    "api",
+    "api/types",
+    "api/types/blkiodev",
+    "api/types/container",
+    "api/types/events",
+    "api/types/filters",
+    "api/types/image",
+    "api/types/mount",
+    "api/types/network",
+    "api/types/registry",
+    "api/types/strslice",
+    "api/types/swarm",
+    "api/types/time",
+    "api/types/versions",
+    "api/types/volume",
+    "client",
+    "pkg/ioutils",
+    "pkg/longpath",
+    "pkg/system",
+    "pkg/tlsconfig"
+  ]
+  revision = "90d35abf7b3535c1c319c872900fbd76374e521c"
+  version = "v17.05.0-ce-rc3"
+
+[[projects]]
+  name = "github.com/docker/go-connections"
+  packages = [
+    "nat",
+    "sockets",
+    "tlsconfig"
+  ]
+  revision = "e15c02316c12de00874640cd76311849de2aeed5"
+
+[[projects]]
+  name = "github.com/docker/go-units"
+  packages = ["."]
+  revision = "9e638d38cf6977a37a8ea0078f3ee75a7cdb2dd1"
+
+[[projects]]
+  name = "github.com/docker/libtrust"
+  packages = ["."]
+  revision = "9cbd2a1374f46905c68a4eb3694a130610adc62a"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/edsrzf/mmap-go"
+  packages = ["."]
+  revision = "0bce6a6887123b67a60366d2c9fe2dfb74289d2e"
+
+[[projects]]
+  name = "github.com/fsouza/fake-gcs-server"
+  packages = ["fakestorage"]
+  revision = "9162fe06459e3d9859987fc2802fa729ddb6dc53"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/go-ini/ini"
+  packages = ["."]
+  revision = "6529cf7c58879c08d927016dde4477f18a0634cb"
+  version = "v1.36.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/go-sql-driver/mysql"
+  packages = ["."]
+  revision = "7413002f368fba928eefaf762c91a2acfeabdf68"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/gocql/gocql"
+  packages = [
+    ".",
+    "internal/lru",
+    "internal/murmur",
+    "internal/streams"
+  ]
+  revision = "3c37daec2f4d3def4b3b21668c6c2e80d3265a69"
+
+[[projects]]
+  name = "github.com/golang/protobuf"
+  packages = [
+    "proto",
+    "protoc-gen-go/descriptor",
+    "ptypes",
+    "ptypes/any",
+    "ptypes/duration",
+    "ptypes/empty",
+    "ptypes/struct",
+    "ptypes/timestamp"
+  ]
+  revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/golang/snappy"
+  packages = ["."]
+  revision = "553a641470496b2327abcac10b36396bd98e45c9"
+
+[[projects]]
+  name = "github.com/google/go-github"
+  packages = ["github"]
+  revision = "e48060a28fac52d0f1cb758bc8b87c07bac4a87d"
+  version = "v15.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/google/go-querystring"
+  packages = ["query"]
+  revision = "53e6ce116135b80d037921a7fdd5138cf32d7a8a"
+
+[[projects]]
+  name = "github.com/googleapis/gax-go"
+  packages = ["."]
+  revision = "317e0006254c44a0ac427cc52a0e083ff0b9622f"
+  version = "v2.0.0"
+
+[[projects]]
+  name = "github.com/gorilla/context"
+  packages = ["."]
+  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
+  version = "v1.1"
+
+[[projects]]
+  name = "github.com/gorilla/mux"
+  packages = ["."]
+  revision = "e3702bed27f0d39777b0b37b664b6280e8ef8fbf"
+  version = "v1.6.2"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/hailocab/go-hostpool"
+  packages = ["."]
+  revision = "e80d13ce29ede4452c43dea11e79b9bc8a15b478"
+
+[[projects]]
+  name = "github.com/jmespath/go-jmespath"
+  packages = ["."]
+  revision = "0b12d6b5"
+
+[[projects]]
+  name = "github.com/kshvakov/clickhouse"
+  packages = [
+    ".",
+    "lib/binary",
+    "lib/column",
+    "lib/data",
+    "lib/protocol",
+    "lib/types",
+    "lib/writebuffer"
+  ]
+  revision = "8a2dd1e831a6c7381c11d40bcaf80ae98023c605"
+  version = "v1.3.3"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/lib/pq"
+  packages = [
+    ".",
+    "oid"
+  ]
+  revision = "d34b9ff171c21ad295489235aec8b6626023cd04"
+
+[[projects]]
+  name = "github.com/mattn/go-sqlite3"
+  packages = ["."]
+  revision = "6c771bb9887719704b210e87e934f08be014bdb1"
+  version = "v1.6.0"
+
+[[projects]]
+  name = "github.com/opencontainers/go-digest"
+  packages = ["."]
+  revision = "a6d0ee40d4207ea02364bd3b9e8e77b9159ba1eb"
+
+[[projects]]
+  name = "github.com/pkg/errors"
+  packages = ["."]
+  revision = "839d9e913e063e28dfd0e6c7b7512793e0a48be9"
+
+[[projects]]
+  name = "go.opencensus.io"
+  packages = [
+    "exporter/stackdriver/propagation",
+    "internal",
+    "internal/tagencoding",
+    "plugin/ocgrpc",
+    "plugin/ochttp",
+    "plugin/ochttp/propagation/b3",
+    "stats",
+    "stats/internal",
+    "stats/view",
+    "tag",
+    "trace",
+    "trace/internal",
+    "trace/propagation"
+  ]
+  revision = "c3ed530f775d85e577ca652cb052a52c078aad26"
+  version = "v0.11.0"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "context/ctxhttp",
+    "http/httpguts",
+    "http2",
+    "http2/hpack",
+    "idna",
+    "internal/socks",
+    "internal/timeseries",
+    "proxy",
+    "trace"
+  ]
+  revision = "2491c5de3490fced2f6cff376127c667efeed857"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/oauth2"
+  packages = [
+    ".",
+    "google",
+    "internal",
+    "jws",
+    "jwt"
+  ]
+  revision = "cdc340f7c179dbbfa4afd43b7614e8fcadde4269"
+
+[[projects]]
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows"
+  ]
+  revision = "8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9"
+
+[[projects]]
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable"
+  ]
+  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
+  version = "v0.3.0"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/tools"
+  packages = [
+    "godoc/vfs",
+    "godoc/vfs/mapfs"
+  ]
+  revision = "c06a8d8ed11aae27b08c1c109a509ada9de81240"
+
+[[projects]]
+  branch = "master"
+  name = "google.golang.org/api"
+  packages = [
+    "gensupport",
+    "googleapi",
+    "googleapi/internal/uritemplates",
+    "googleapi/transport",
+    "internal",
+    "iterator",
+    "option",
+    "storage/v1",
+    "transport",
+    "transport/grpc",
+    "transport/http"
+  ]
+  revision = "15aea8711db98e640b277da9771a9d74270c2edc"
+
+[[projects]]
+  name = "google.golang.org/appengine"
+  packages = [
+    ".",
+    "cloudsql",
+    "internal",
+    "internal/app_identity",
+    "internal/base",
+    "internal/datastore",
+    "internal/log",
+    "internal/modules",
+    "internal/remote_api",
+    "internal/socket",
+    "internal/urlfetch",
+    "socket",
+    "urlfetch"
+  ]
+  revision = "150dc57a1b433e64154302bdc40b6bb8aefa313a"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "google.golang.org/genproto"
+  packages = [
+    "googleapis/api/annotations",
+    "googleapis/iam/v1",
+    "googleapis/longrunning",
+    "googleapis/rpc/code",
+    "googleapis/rpc/errdetails",
+    "googleapis/rpc/status",
+    "googleapis/spanner/admin/database/v1",
+    "googleapis/spanner/v1"
+  ]
+  revision = "86e600f69ee4704c6efbf6a2a40a5c10700e76c2"
+
+[[projects]]
+  name = "google.golang.org/grpc"
+  packages = [
+    ".",
+    "balancer",
+    "balancer/base",
+    "balancer/roundrobin",
+    "channelz",
+    "codes",
+    "connectivity",
+    "credentials",
+    "credentials/oauth",
+    "encoding",
+    "encoding/proto",
+    "grpclb/grpc_lb_v1/messages",
+    "grpclog",
+    "internal",
+    "keepalive",
+    "metadata",
+    "naming",
+    "peer",
+    "resolver",
+    "resolver/dns",
+    "resolver/passthrough",
+    "stats",
+    "status",
+    "tap",
+    "transport"
+  ]
+  revision = "41344da2231b913fa3d983840a57a6b1b7b631a1"
+  version = "v1.12.0"
+
+[[projects]]
+  name = "gopkg.in/inf.v0"
+  packages = ["."]
+  revision = "d2d2541c53f18d2a059457998ce2876cc8e67cbf"
+  version = "v0.9.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "952240f227fe19a7d62faa43d3acad05b097803337542117c1c3bd81cc5ffd6d"
+  solver-name = "gps-cdcl"
+  solver-version = 1
--- a/src/vendor/github.com/golang-migrate/migrate/Gopkg.toml
+++ b/src/vendor/github.com/golang-migrate/migrate/Gopkg.toml
@ -0,0 +1,94 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/aws/aws-sdk-go"
+  version = "1.13.47"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/cockroachdb/cockroach-go"
+
+[[constraint]]
+  name = "github.com/cznic/ql"
+  version = "1.1.0"
+
+[[constraint]]
+  name = "github.com/docker/docker"
+  version = "v17.05.0-ce"
+
+[[constraint]]
+  name = "github.com/fsouza/fake-gcs-server"
+  version = "1.0.0"
+
+[[constraint]]
+  name = "github.com/go-sql-driver/mysql"
+  branch = "master"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/gocql/gocql"
+
+[[constraint]]
+  name = "github.com/google/go-github"
+  version = "15.0.0"
+
+[[constraint]]
+  name = "github.com/kshvakov/clickhouse"
+  version = "1.3.3"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/lib/pq"
+
+[[constraint]]
+  name = "github.com/mattn/go-sqlite3"
+  version = "1.6.0"
+
+[[constraint]]
+  branch = "master"
+  name = "golang.org/x/net"
+
+[[constraint]]
+  branch = "master"
+  name = "google.golang.org/api"
+
+[[constraint]]
+  branch = "master"
+  name = "google.golang.org/genproto"
+
+[[override]]
+  name = "cloud.google.com/go"
+  version = "0.23.0"
+
+[[override]]
+  branch = "master"
+  name = "golang.org/x/tools"
+
+[prune]
+  go-tests = true
+  unused-packages = true
--- a/src/vendor/github.com/golang-migrate/migrate/LICENSE
+++ b/src/vendor/github.com/golang-migrate/migrate/LICENSE
@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Matthias Kadenbach
+
+https://github.com/mattes/migrate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/src/vendor/github.com/golang-migrate/migrate/MIGRATIONS.md
+++ b/src/vendor/github.com/golang-migrate/migrate/MIGRATIONS.md
@ -0,0 +1,81 @@
+# Migrations
+
+## Migration Filename Format
+
+A single logical migration is represented as two separate migration files, one
+to migrate "up" to the specified version from the previous version, and a second
+to migrate back "down" to the previous version.  These migrations can be provided
+by any one of the supported [migration sources](./README.md#migration-sources).
+
+The ordering and direction of the migration files is determined by the filenames
+used for them.  `migrate` expects the filenames of migrations to have the format:
+
+    {version}_{title}.up.{extension}
+    {version}_{title}.down.{extension}
+
+The `title` of each migration is unused, and is only for readability.  Similarly,
+the `extension` of the migration files is not checked by the library, and should
+be an appropriate format for the database in use (`.sql` for SQL variants, for
+instance).
+
+Versions of migrations may be represented as any 64 bit unsigned integer.
+All migrations are applied upward in order of increasing version number, and
+downward by decreasing version number.
+
+Common versioning schemes include incrementing integers:
+
+    1_initialize_schema.down.sql
+    1_initialize_schema.up.sql
+    2_add_table.down.sql
+    2_add_table.up.sql
+    ...
+
+Or timestamps at an appropriate resolution:
+
+    1500360784_initialize_schema.down.sql
+    1500360784_initialize_schema.up.sql
+    1500445949_add_table.down.sql
+    1500445949_add_table.up.sql
+    ...
+
+But any scheme resulting in distinct, incrementing integers as versions is valid.
+
+It is suggested that the version number of corresponding `up` and `down` migration
+files be equivalent for clarity, but they are allowed to differ so long as the
+relative ordering of the migrations is preserved.
+
+The migration files are permitted to be empty, so in the event that a migration
+is a no-op or is irreversible, it is recommended to still include both migration
+files, and either leaving them empty or adding a comment as appropriate.
+
+## Migration Content Format
+
+The format of the migration files themselves varies between database systems.
+Different databases have different semantics around schema changes and when and
+how they are allowed to occur (for instance, if schema changes can occur within
+a transaction).
+
+As such, the `migrate` library has little to no checking around the format of
+migration sources.  The migration files are generally processed directly by the
+drivers as raw operations.
+
+## Reversibility of Migrations
+
+Best practice for writing schema migration is that all migrations should be
+reversible.  It should in theory be possible for run migrations down and back up
+through any and all versions with the state being fully cleaned and recreated
+by doing so.
+
+By adhering to this recommended practice, development and deployment of new code
+is cleaner and easier (cleaning database state for a new feature should be as
+easy as migrating down to a prior version, and back up to the latest).
+
+As opposed to some other migration libraries, `migrate` represents up and down
+migrations as separate files.  This prevents any non-standard file syntax from
+being introduced which may result in unintended behavior or errors, depending
+on what database is processing the file.
+
+While it is technically possible for an up or down migration to exist on its own
+without an equivalently versioned counterpart, it is strongly recommended to
+always include a down migration which cleans up the state of the corresponding
+up migration.
--- a/src/vendor/github.com/golang-migrate/migrate/Makefile
+++ b/src/vendor/github.com/golang-migrate/migrate/Makefile
@ -0,0 +1,117 @@
+SOURCE ?= file go_bindata github aws_s3 google_cloud_storage godoc_vfs
+DATABASE ?= postgres mysql redshift cassandra spanner cockroachdb clickhouse
+VERSION ?= $(shell git describe --tags 2>/dev/null | cut -c 2-)
+TEST_FLAGS ?=
+REPO_OWNER ?= $(shell cd .. && basename "$$(pwd)")
+COVERAGE_DIR ?= .coverage
+
+
+build-cli: clean
+	-mkdir ./cli/build
+	cd ./cli && GOOS=linux GOARCH=amd64 go build -a -o build/migrate.linux-amd64 -ldflags='-X main.Version=$(VERSION) -extldflags "-static"' -tags '$(DATABASE) $(SOURCE)' .
+	cd ./cli && GOOS=darwin GOARCH=amd64 go build -a -o build/migrate.darwin-amd64 -ldflags='-X main.Version=$(VERSION) -extldflags "-static"' -tags '$(DATABASE) $(SOURCE)' .
+	cd ./cli && GOOS=windows GOARCH=amd64 go build -a -o build/migrate.windows-amd64.exe -ldflags='-X main.Version=$(VERSION) -extldflags "-static"' -tags '$(DATABASE) $(SOURCE)' .
+	cd ./cli/build && find . -name 'migrate*' | xargs -I{} tar czf {}.tar.gz {}
+	cd ./cli/build && shasum -a 256 * > sha256sum.txt
+	cat ./cli/build/sha256sum.txt
+
+
+clean:
+	-rm -r ./cli/build
+
+
+test-short:
+	make test-with-flags --ignore-errors TEST_FLAGS='-short'
+
+
+test:
+	@-rm -r $(COVERAGE_DIR)
+	@mkdir $(COVERAGE_DIR)
+	make test-with-flags TEST_FLAGS='-v -race -covermode atomic -coverprofile $$(COVERAGE_DIR)/_$$(RAND).txt -bench=. -benchmem -timeout 20m'
+	@echo 'mode: atomic' > $(COVERAGE_DIR)/combined.txt
+	@cat $(COVERAGE_DIR)/_*.txt | grep -v 'mode: atomic' >> $(COVERAGE_DIR)/combined.txt
+
+
+test-with-flags:
+	@echo SOURCE: $(SOURCE) 
+	@echo DATABASE: $(DATABASE)
+
+	@go test $(TEST_FLAGS) .
+	@go test $(TEST_FLAGS) ./cli/...
+	@go test $(TEST_FLAGS) ./testing/...
+
+	@echo -n '$(SOURCE)' | tr -s ' ' '\n' | xargs -I{} go test $(TEST_FLAGS) ./source/{}
+	@go test $(TEST_FLAGS) ./source/testing/...
+	@go test $(TEST_FLAGS) ./source/stub/...
+
+	@echo -n '$(DATABASE)' | tr -s ' ' '\n' | xargs -I{} go test $(TEST_FLAGS) ./database/{}
+	@go test $(TEST_FLAGS) ./database/testing/...
+	@go test $(TEST_FLAGS) ./database/stub/...
+
+
+kill-orphaned-docker-containers:
+	docker rm -f $(shell docker ps -aq --filter label=migrate_test)
+
+
+html-coverage:
+	go tool cover -html=$(COVERAGE_DIR)/combined.txt
+
+
+list-external-deps:
+	$(call external_deps,'.')
+	$(call external_deps,'./cli/...')
+	$(call external_deps,'./testing/...')
+
+	$(foreach v, $(SOURCE), $(call external_deps,'./source/$(v)/...'))
+	$(call external_deps,'./source/testing/...')
+	$(call external_deps,'./source/stub/...')
+
+	$(foreach v, $(DATABASE), $(call external_deps,'./database/$(v)/...'))
+	$(call external_deps,'./database/testing/...')
+	$(call external_deps,'./database/stub/...')
+
+
+restore-import-paths:
+	find . -name '*.go' -type f -execdir sed -i '' s%\"github.com/$(REPO_OWNER)/migrate%\"github.com/mattes/migrate%g '{}' \;
+
+
+rewrite-import-paths:
+	find . -name '*.go' -type f -execdir sed -i '' s%\"github.com/mattes/migrate%\"github.com/$(REPO_OWNER)/migrate%g '{}' \;
+
+
+# example: fswatch -0 --exclude .godoc.pid --event Updated . | xargs -0 -n1 -I{} make docs
+docs:
+	-make kill-docs
+	nohup godoc -play -http=127.0.0.1:6064 </dev/null >/dev/null 2>&1 & echo $$! > .godoc.pid
+	cat .godoc.pid  
+
+
+kill-docs:
+	@cat .godoc.pid
+	kill -9 $$(cat .godoc.pid)
+	rm .godoc.pid
+
+
+open-docs:
+	open http://localhost:6064/pkg/github.com/$(REPO_OWNER)/migrate
+
+
+# example: make release V=0.0.0
+release:
+	git tag v$(V)
+	@read -p "Press enter to confirm and push to origin ..." && git push origin v$(V)
+
+
+define external_deps
+	@echo '-- $(1)';  go list -f '{{join .Deps "\n"}}' $(1) | grep -v github.com/$(REPO_OWNER)/migrate | xargs go list -f '{{if not .Standard}}{{.ImportPath}}{{end}}'
+
+endef
+
+
+.PHONY: build-cli clean test-short test test-with-flags html-coverage \
+        restore-import-paths rewrite-import-paths list-external-deps release \
+        docs kill-docs open-docs kill-orphaned-docker-containers
+
+SHELL = /bin/bash
+RAND = $(shell echo $$RANDOM)
+
--- a/src/vendor/github.com/golang-migrate/migrate/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/README.md
@ -0,0 +1,147 @@
+[![Build Status](https://img.shields.io/travis/golang-migrate/migrate/master.svg)](https://travis-ci.org/golang-migrate/migrate)
+[![GoDoc](https://godoc.org/github.com/golang-migrate/migrate?status.svg)](https://godoc.org/github.com/golang-migrate/migrate)
+[![Coverage Status](https://img.shields.io/coveralls/github/golang-migrate/migrate/master.svg)](https://coveralls.io/github/golang-migrate/migrate?branch=master)
+[![packagecloud.io](https://img.shields.io/badge/deb-packagecloud.io-844fec.svg)](https://packagecloud.io/golang-migrate/migrate?filter=debs)
+[![GitHub Release](https://img.shields.io/github/release/golang-migrate/migrate.svg)](https://github.com/golang-migrate/migrate/releases)
+
+
+# migrate
+
+__Database migrations written in Go. Use as [CLI](#cli-usage) or import as [library](#use-in-your-go-project).__
+
+ * Migrate reads migrations from [sources](#migration-sources)
+   and applies them in correct order to a [database](#databases).
+ * Drivers are "dumb", migrate glues everything together and makes sure the logic is bulletproof.
+   (Keeps the drivers lightweight, too.)
+ * Database drivers don't assume things or try to correct user input. When in doubt, fail.
+
+
+Looking for [v1](https://github.com/golang-migrate/migrate/tree/v1)?
+
+
+## Databases
+
+Database drivers run migrations. [Add a new database?](database/driver.go)
+
+  * [PostgreSQL](database/postgres)
+  * [Redshift](database/redshift)
+  * [Ql](database/ql)
+  * [Cassandra](database/cassandra)
+  * [SQLite](database/sqlite3) ([todo #165](https://github.com/mattes/migrate/issues/165))
+  * [MySQL/ MariaDB](database/mysql)
+  * [Neo4j](database/neo4j) ([todo #167](https://github.com/mattes/migrate/issues/167))
+  * [MongoDB](database/mongodb) ([todo #169](https://github.com/mattes/migrate/issues/169))
+  * [CrateDB](database/crate) ([todo #170](https://github.com/mattes/migrate/issues/170))
+  * [Shell](database/shell) ([todo #171](https://github.com/mattes/migrate/issues/171))
+  * [Google Cloud Spanner](database/spanner)
+  * [CockroachDB](database/cockroachdb)
+  * [ClickHouse](database/clickhouse)
+
+
+## Migration Sources
+
+Source drivers read migrations from local or remote sources. [Add a new source?](source/driver.go)
+
+  * [Filesystem](source/file) - read from fileystem
+  * [Go-Bindata](source/go_bindata) - read from embedded binary data ([jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata))
+  * [Github](source/github) - read from remote Github repositories
+  * [AWS S3](source/aws_s3) - read from Amazon Web Services S3
+  * [Google Cloud Storage](source/google_cloud_storage) - read from Google Cloud Platform Storage
+
+
+
+## CLI usage
+
+  * Simple wrapper around this library.
+  * Handles ctrl+c (SIGINT) gracefully.
+  * No config search paths, no config files, no magic ENV var injections.
+
+__[CLI Documentation](cli)__
+
+### Basic usage:
+
+```
+$ migrate -database postgres://localhost:5432/database up 2
+```
+
+### Docker usage
+
+```
+$ docker run -v {{ migration dir }}:/migrations --network host migrate/migrate 
+    -path=/migrations/ -database postgres://localhost:5432/database up 2
+```
+
+## Use in your Go project
+
+ * API is stable and frozen for this release (v3.x).
+ * Package migrate has no external dependencies.
+ * Only import the drivers you need.
+   (check [dependency_tree.txt](https://github.com/golang-migrate/migrate/releases) for each driver)
+ * To help prevent database corruptions, it supports graceful stops via `GracefulStop chan bool`.
+ * Bring your own logger.
+ * Uses `io.Reader` streams internally for low memory overhead.
+ * Thread-safe and no goroutine leaks.
+
+__[Go Documentation](https://godoc.org/github.com/golang-migrate/migrate)__
+
+```go
+import (
+    "github.com/golang-migrate/migrate"
+    _ "github.com/golang-migrate/migrate/database/postgres"
+    _ "github.com/golang-migrate/migrate/source/github"
+)
+
+func main() {
+    m, err := migrate.New(
+        "github://mattes:personal-access-token@mattes/migrate_test",
+        "postgres://localhost:5432/database?sslmode=enable")
+    m.Steps(2)
+}
+```
+
+Want to use an existing database client?
+
+```go
+import (
+    "database/sql"
+    _ "github.com/lib/pq"
+    "github.com/golang-migrate/migrate"
+    "github.com/golang-migrate/migrate/database/postgres"
+    _ "github.com/golang-migrate/migrate/source/file"
+)
+
+func main() {
+    db, err := sql.Open("postgres", "postgres://localhost:5432/database?sslmode=enable")
+    driver, err := postgres.WithInstance(db, &postgres.Config{})
+    m, err := migrate.NewWithDatabaseInstance(
+        "file:///migrations",
+        "postgres", driver)
+    m.Steps(2)
+}
+```
+
+## Migration files
+
+Each migration has an up and down migration. [Why?](FAQ.md#why-two-separate-files-up-and-down-for-a-migration)
+
+```
+1481574547_create_users_table.up.sql
+1481574547_create_users_table.down.sql
+```
+
+[Best practices: How to write migrations.](MIGRATIONS.md)
+
+
+
+## Development and Contributing
+
+Yes, please! [`Makefile`](Makefile) is your friend,
+read the [development guide](CONTRIBUTING.md).
+
+Also have a look at the [FAQ](FAQ.md).
+
+
+
+---
+
+Looking for alternatives? [https://awesome-go.com/#database](https://awesome-go.com/#database).
--- a/src/vendor/github.com/golang-migrate/migrate/cli/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/README.md
@ -0,0 +1,111 @@
+# migrate CLI
+
+## Installation
+
+#### With Go toolchain
+
+```
+$ go get -u -d github.com/golang-migrate/migrate/cli github.com/lib/pq
+$ go build -tags 'postgres' -o /usr/local/bin/migrate github.com/golang-migrate/migrate/cli
+```
+
+Note: This example builds the cli which will only work with postgres.  In order
+to build the cli for use with other databases, replace the `postgres` build tag
+with the appropriate database tag(s) for the databases desired.  The tags
+correspond to the names of the sub-packages underneath the
+[`database`](../database) package.
+
+#### MacOS
+
+We have not released support for homebrew yet, but there is a live issue here: [todo #156](https://github.com/mattes/migrate/issues/156)
+
+Any help to make this happen would be appreciated!
+
+#### Linux (*.deb package)
+
+```
+$ curl -L https://packagecloud.io/golang-migrate/migrate/gpgkey | apt-key add -
+$ echo "deb https://packagecloud.io/golang-migrate/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list
+$ apt-get update
+$ apt-get install -y migrate
+```
+
+#### Download pre-build binary (Windows, MacOS, or Linux)
+
+[Release Downloads](https://github.com/golang-migrate/migrate/releases)
+
+```
+$ curl -L https://github.com/golang-migrate/migrate/releases/download/$version/migrate.$platform-amd64.tar.gz | tar xvz
+```
+
+
+
+## Usage
+
+```
+$ migrate -help
+Usage: migrate OPTIONS COMMAND [arg...]
+       migrate [ -version | -help ]
+
+Options:
+  -source          Location of the migrations (driver://url)
+  -path            Shorthand for -source=file://path
+  -database        Run migrations against this database (driver://url)
+  -prefetch N      Number of migrations to load in advance before executing (default 10)
+  -lock-timeout N  Allow N seconds to acquire database lock (default 15)
+  -verbose         Print verbose logging
+  -version         Print version
+  -help            Print usage
+
+Commands:
+  create [-ext E] [-dir D] NAME
+               Create a set of timestamped up/down migrations titled NAME, in directory D with extension E
+  goto V       Migrate to version V
+  up [N]       Apply all or N up migrations
+  down [N]     Apply all or N down migrations
+  drop         Drop everyting inside database
+  force V      Set version V but don't run migration (ignores dirty state)
+  version      Print current migration version
+```
+
+
+So let's say you want to run the first two migrations
+
+```
+$ migrate -database postgres://localhost:5432/database up 2
+```
+
+If your migrations are hosted on github
+
+```
+$ migrate -source github://mattes:personal-access-token@mattes/migrate_test \
+    -database postgres://localhost:5432/database down 2
+```
+
+The CLI will gracefully stop at a safe point when SIGINT (ctrl+c) is received.
+Send SIGKILL for immediate halt.
+
+
+
+## Reading CLI arguments from somewhere else
+
+##### ENV variables
+
+```
+$ migrate -database "$MY_MIGRATE_DATABASE"
+```
+
+##### JSON files
+
+Check out https://stedolan.github.io/jq/
+
+```
+$ migrate -database "$(cat config.json | jq '.database')"
+```
+
+##### YAML files
+
+````
+$ migrate -database "$(cat config/database.yml | ruby -ryaml -e "print YAML.load(STDIN.read)['database']")"
+$ migrate -database "$(cat config/database.yml | python -c 'import yaml,sys;print yaml.safe_load(sys.stdin)["database"]')"
+```
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_aws-s3.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_aws-s3.go
@ -0,0 +1,7 @@
+// +build aws_s3
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/source/aws_s3"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_cassandra.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_cassandra.go
@ -0,0 +1,7 @@
+// +build cassandra
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/cassandra"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_clickhouse.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_clickhouse.go
@ -0,0 +1,8 @@
+// +build clickhouse
+
+package main
+
+import (
+	_ "github.com/kshvakov/clickhouse"
+	_ "github.com/golang-migrate/migrate/database/clickhouse"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_cockroachdb.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_cockroachdb.go
@ -0,0 +1,7 @@
+// +build cockroachdb
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/cockroachdb"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_github.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_github.go
@ -0,0 +1,7 @@
+// +build github
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/source/github"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_go-bindata.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_go-bindata.go
@ -0,0 +1,7 @@
+// +build go_bindata
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/source/go_bindata"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_godoc-vfs.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_godoc-vfs.go
@ -0,0 +1,7 @@
+// +build godoc_vfs
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/source/godoc_vfs"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_google-cloud-storage.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_google-cloud-storage.go
@ -0,0 +1,7 @@
+// +build google_cloud_storage
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/source/google_cloud_storage"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_mysql.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_mysql.go
@ -0,0 +1,7 @@
+// +build mysql
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/mysql"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_postgres.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_postgres.go
@ -0,0 +1,7 @@
+// +build postgres
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/postgres"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_ql.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_ql.go
@ -0,0 +1,7 @@
+// +build ql
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/ql"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_redshift.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_redshift.go
@ -0,0 +1,7 @@
+// +build redshift
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/redshift"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_spanner.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_spanner.go
@ -0,0 +1,7 @@
+// +build spanner
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/spanner"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/build_sqlite3.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/build_sqlite3.go
@ -0,0 +1,7 @@
+// +build sqlite3
+
+package main
+
+import (
+	_ "github.com/golang-migrate/migrate/database/sqlite3"
+)
--- a/src/vendor/github.com/golang-migrate/migrate/cli/commands.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/commands.go
@ -0,0 +1,166 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"github.com/golang-migrate/migrate"
+	_ "github.com/golang-migrate/migrate/database/stub" // TODO remove again
+	_ "github.com/golang-migrate/migrate/source/file"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func nextSeq(matches []string, dir string, seqDigits int) (string, error) {
+	if seqDigits <= 0 {
+		return "", errors.New("Digits must be positive")
+	}
+
+	nextSeq := 1
+	if len(matches) > 0 {
+		filename := matches[len(matches)-1]
+		matchSeqStr := strings.TrimPrefix(filename, dir)
+		idx := strings.Index(matchSeqStr, "_")
+		if idx < 1 { // Using 1 instead of 0 since there should be at least 1 digit
+			return "", errors.New("Malformed migration filename: " + filename)
+		}
+		matchSeqStr = matchSeqStr[0:idx]
+		var err error
+		nextSeq, err = strconv.Atoi(matchSeqStr)
+		if err != nil {
+			return "", err
+		}
+		nextSeq++
+	}
+	if nextSeq <= 0 {
+		return "", errors.New("Next sequence number must be positive")
+	}
+
+	nextSeqStr := strconv.Itoa(nextSeq)
+	if len(nextSeqStr) > seqDigits {
+		return "", fmt.Errorf("Next sequence number %s too large. At most %d digits are allowed", nextSeqStr, seqDigits)
+	}
+	padding := seqDigits - len(nextSeqStr)
+	if padding > 0 {
+		nextSeqStr = strings.Repeat("0", padding) + nextSeqStr
+	}
+	return nextSeqStr, nil
+}
+
+func createCmd(dir string, startTime time.Time, format string, name string, ext string, seq bool, seqDigits int) {
+	var base string
+	if seq && format != defaultTimeFormat {
+		log.fatalErr(errors.New("The seq and format options are mutually exclusive"))
+	}
+	if seq {
+		if seqDigits <= 0 {
+			log.fatalErr(errors.New("Digits must be positive"))
+		}
+		matches, err := filepath.Glob(dir + "*" + ext)
+		if err != nil {
+			log.fatalErr(err)
+		}
+		nextSeqStr, err := nextSeq(matches, dir, seqDigits)
+		if err != nil {
+			log.fatalErr(err)
+		}
+		base = fmt.Sprintf("%v%v_%v.", dir, nextSeqStr, name)
+	} else {
+		switch format {
+		case "":
+			log.fatal("Time format may not be empty")
+		case "unix":
+			base = fmt.Sprintf("%v%v_%v.", dir, startTime.Unix(), name)
+		case "unixNano":
+			base = fmt.Sprintf("%v%v_%v.", dir, startTime.UnixNano(), name)
+		default:
+			base = fmt.Sprintf("%v%v_%v.", dir, startTime.Format(format), name)
+		}
+	}
+
+	os.MkdirAll(dir, os.ModePerm)
+	createFile(base + "up" + ext)
+	createFile(base + "down" + ext)
+}
+
+func createFile(fname string) {
+	if _, err := os.Create(fname); err != nil {
+		log.fatalErr(err)
+	}
+}
+
+func gotoCmd(m *migrate.Migrate, v uint) {
+	if err := m.Migrate(v); err != nil {
+		if err != migrate.ErrNoChange {
+			log.fatalErr(err)
+		} else {
+			log.Println(err)
+		}
+	}
+}
+
+func upCmd(m *migrate.Migrate, limit int) {
+	if limit >= 0 {
+		if err := m.Steps(limit); err != nil {
+			if err != migrate.ErrNoChange {
+				log.fatalErr(err)
+			} else {
+				log.Println(err)
+			}
+		}
+	} else {
+		if err := m.Up(); err != nil {
+			if err != migrate.ErrNoChange {
+				log.fatalErr(err)
+			} else {
+				log.Println(err)
+			}
+		}
+	}
+}
+
+func downCmd(m *migrate.Migrate, limit int) {
+	if limit >= 0 {
+		if err := m.Steps(-limit); err != nil {
+			if err != migrate.ErrNoChange {
+				log.fatalErr(err)
+			} else {
+				log.Println(err)
+			}
+		}
+	} else {
+		if err := m.Down(); err != nil {
+			if err != migrate.ErrNoChange {
+				log.fatalErr(err)
+			} else {
+				log.Println(err)
+			}
+		}
+	}
+}
+
+func dropCmd(m *migrate.Migrate) {
+	if err := m.Drop(); err != nil {
+		log.fatalErr(err)
+	}
+}
+
+func forceCmd(m *migrate.Migrate, v int) {
+	if err := m.Force(v); err != nil {
+		log.fatalErr(err)
+	}
+}
+
+func versionCmd(m *migrate.Migrate) {
+	v, dirty, err := m.Version()
+	if err != nil {
+		log.fatalErr(err)
+	}
+	if dirty {
+		log.Printf("%v (dirty)\n", v)
+	} else {
+		log.Println(v)
+	}
+}
--- a/src/vendor/github.com/golang-migrate/migrate/cli/commands_test.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/commands_test.go
@ -0,0 +1,45 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestNextSeq(t *testing.T) {
+	cases := []struct {
+		name           string
+		matches        []string
+		dir            string
+		seqDigits      int
+		expected       string
+		expectedErrStr string
+	}{
+		{"Bad digits", []string{}, "migrationDir", 0, "", "Digits must be positive"},
+		{"Single digit initialize", []string{}, "migrationDir", 1, "1", ""},
+		{"Single digit malformed", []string{"bad"}, "migrationDir", 1, "", "Malformed migration filename: bad"},
+		{"Single digit no int", []string{"bad_bad"}, "migrationDir", 1, "", "strconv.Atoi: parsing \"bad\": invalid syntax"},
+		{"Single digit negative seq", []string{"-5_test"}, "migrationDir", 1, "", "Next sequence number must be positive"},
+		{"Single digit increment", []string{"3_test", "4_test"}, "migrationDir", 1, "5", ""},
+		{"Single digit overflow", []string{"9_test"}, "migrationDir", 1, "", "Next sequence number 10 too large. At most 1 digits are allowed"},
+		{"Zero-pad initialize", []string{}, "migrationDir", 6, "000001", ""},
+		{"Zero-pad malformed", []string{"bad"}, "migrationDir", 6, "", "Malformed migration filename: bad"},
+		{"Zero-pad no int", []string{"bad_bad"}, "migrationDir", 6, "", "strconv.Atoi: parsing \"bad\": invalid syntax"},
+		{"Zero-pad negative seq", []string{"-000005_test"}, "migrationDir", 6, "", "Next sequence number must be positive"},
+		{"Zero-pad increment", []string{"000003_test", "000004_test"}, "migrationDir", 6, "000005", ""},
+		{"Zero-pad overflow", []string{"999999_test"}, "migrationDir", 6, "", "Next sequence number 1000000 too large. At most 6 digits are allowed"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			nextSeq, err := nextSeq(c.matches, c.dir, c.seqDigits)
+			if nextSeq != c.expected {
+				t.Error("Incorrect nextSeq: " + nextSeq + " != " + c.expected)
+			}
+			if err != nil {
+				if err.Error() != c.expectedErrStr {
+					t.Error("Incorrect error: " + err.Error() + " != " + c.expectedErrStr)
+				}
+			} else if c.expectedErrStr != "" {
+				t.Error("Expected error: " + c.expectedErrStr + " but got nil instead")
+			}
+		})
+	}
+}
--- a/src/vendor/github.com/golang-migrate/migrate/cli/examples/Dockerfile
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/examples/Dockerfile
@ -0,0 +1,12 @@
+FROM ubuntu:xenial
+
+RUN apt-get update && \
+    apt-get install -y curl apt-transport-https
+
+RUN curl -L https://packagecloud.io/golang-migrate/migrate/gpgkey | apt-key add - && \
+    echo "deb https://packagecloud.io/golang-migrate/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list && \
+    apt-get update && \
+    apt-get install -y migrate
+
+RUN migrate -version
+
--- a/src/vendor/github.com/golang-migrate/migrate/cli/log.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/log.go
@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	logpkg "log"
+	"os"
+)
+
+type Log struct {
+	verbose bool
+}
+
+func (l *Log) Printf(format string, v ...interface{}) {
+	if l.verbose {
+		logpkg.Printf(format, v...)
+	} else {
+		fmt.Fprintf(os.Stderr, format, v...)
+	}
+}
+
+func (l *Log) Println(args ...interface{}) {
+	if l.verbose {
+		logpkg.Println(args...)
+	} else {
+		fmt.Fprintln(os.Stderr, args...)
+	}
+}
+
+func (l *Log) Verbose() bool {
+	return l.verbose
+}
+
+func (l *Log) fatalf(format string, v ...interface{}) {
+	l.Printf(format, v...)
+	os.Exit(1)
+}
+
+func (l *Log) fatal(args ...interface{}) {
+	l.Println(args...)
+	os.Exit(1)
+}
+
+func (l *Log) fatalErr(err error) {
+	l.fatal("error:", err)
+}
--- a/src/vendor/github.com/golang-migrate/migrate/cli/main.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/main.go
@ -0,0 +1,250 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+	"github.com/golang-migrate/migrate/source"
+)
+
+const defaultTimeFormat = "20060102150405"
+
+// set main log
+var log = &Log{}
+
+func main() {
+	helpPtr := flag.Bool("help", false, "")
+	versionPtr := flag.Bool("version", false, "")
+	verbosePtr := flag.Bool("verbose", false, "")
+	prefetchPtr := flag.Uint("prefetch", 10, "")
+	lockTimeoutPtr := flag.Uint("lock-timeout", 15, "")
+	pathPtr := flag.String("path", "", "")
+	databasePtr := flag.String("database", "", "")
+	sourcePtr := flag.String("source", "", "")
+
+	flag.Usage = func() {
+		fmt.Fprint(os.Stderr,
+			`Usage: migrate OPTIONS COMMAND [arg...]
+       migrate [ -version | -help ]
+
+Options:
+  -source          Location of the migrations (driver://url)
+  -path            Shorthand for -source=file://path 
+  -database        Run migrations against this database (driver://url)
+  -prefetch N      Number of migrations to load in advance before executing (default 10)
+  -lock-timeout N  Allow N seconds to acquire database lock (default 15)
+  -verbose         Print verbose logging
+  -version         Print version
+  -help            Print usage
+
+Commands:
+  create [-ext E] [-dir D] [-seq] [-digits N] [-format] NAME
+			   Create a set of timestamped up/down migrations titled NAME, in directory D with extension E.
+			   Use -seq option to generate sequential up/down migrations with N digits.
+			   Use -format option to specify a Go time format string.
+  goto V       Migrate to version V
+  up [N]       Apply all or N up migrations
+  down [N]     Apply all or N down migrations
+  drop         Drop everyting inside database
+  force V      Set version V but don't run migration (ignores dirty state)
+  version      Print current migration version
+
+Source drivers: `+strings.Join(source.List(), ", ")+`
+Database drivers: `+strings.Join(database.List(), ", ")+"\n")
+	}
+
+	flag.Parse()
+
+	// initialize logger
+	log.verbose = *verbosePtr
+
+	// show cli version
+	if *versionPtr {
+		fmt.Fprintln(os.Stderr, Version)
+		os.Exit(0)
+	}
+
+	// show help
+	if *helpPtr {
+		flag.Usage()
+		os.Exit(0)
+	}
+
+	// translate -path into -source if given
+	if *sourcePtr == "" && *pathPtr != "" {
+		*sourcePtr = fmt.Sprintf("file://%v", *pathPtr)
+	}
+
+	// initialize migrate
+	// don't catch migraterErr here and let each command decide
+	// how it wants to handle the error
+	migrater, migraterErr := migrate.New(*sourcePtr, *databasePtr)
+	defer func() {
+		if migraterErr == nil {
+			migrater.Close()
+		}
+	}()
+	if migraterErr == nil {
+		migrater.Log = log
+		migrater.PrefetchMigrations = *prefetchPtr
+		migrater.LockTimeout = time.Duration(int64(*lockTimeoutPtr)) * time.Second
+
+		// handle Ctrl+c
+		signals := make(chan os.Signal, 1)
+		signal.Notify(signals, syscall.SIGINT)
+		go func() {
+			for range signals {
+				log.Println("Stopping after this running migration ...")
+				migrater.GracefulStop <- true
+				return
+			}
+		}()
+	}
+
+	startTime := time.Now()
+
+	switch flag.Arg(0) {
+	case "create":
+		args := flag.Args()[1:]
+		seq := false
+		seqDigits := 6
+
+		createFlagSet := flag.NewFlagSet("create", flag.ExitOnError)
+		extPtr := createFlagSet.String("ext", "", "File extension")
+		dirPtr := createFlagSet.String("dir", "", "Directory to place file in (default: current working directory)")
+		formatPtr := createFlagSet.String("format", defaultTimeFormat, `The Go time format string to use. If the string "unix" or "unixNano" is specified, then the seconds or nanoseconds since January 1, 1970 UTC respectively will be used. Caution, due to the behavior of time.Time.Format(), invalid format strings will not error`)
+		createFlagSet.BoolVar(&seq, "seq", seq, "Use sequential numbers instead of timestamps (default: false)")
+		createFlagSet.IntVar(&seqDigits, "digits", seqDigits, "The number of digits to use in sequences (default: 6)")
+		createFlagSet.Parse(args)
+
+		if createFlagSet.NArg() == 0 {
+			log.fatal("error: please specify name")
+		}
+		name := createFlagSet.Arg(0)
+
+		if *extPtr == "" {
+			log.fatal("error: -ext flag must be specified")
+		}
+		*extPtr = "." + strings.TrimPrefix(*extPtr, ".")
+
+		if *dirPtr != "" {
+			*dirPtr = strings.Trim(*dirPtr, "/") + "/"
+		}
+
+		createCmd(*dirPtr, startTime, *formatPtr, name, *extPtr, seq, seqDigits)
+
+	case "goto":
+		if migraterErr != nil {
+			log.fatalErr(migraterErr)
+		}
+
+		if flag.Arg(1) == "" {
+			log.fatal("error: please specify version argument V")
+		}
+
+		v, err := strconv.ParseUint(flag.Arg(1), 10, 64)
+		if err != nil {
+			log.fatal("error: can't read version argument V")
+		}
+
+		gotoCmd(migrater, uint(v))
+
+		if log.verbose {
+			log.Println("Finished after", time.Now().Sub(startTime))
+		}
+
+	case "up":
+		if migraterErr != nil {
+			log.fatalErr(migraterErr)
+		}
+
+		limit := -1
+		if flag.Arg(1) != "" {
+			n, err := strconv.ParseUint(flag.Arg(1), 10, 64)
+			if err != nil {
+				log.fatal("error: can't read limit argument N")
+			}
+			limit = int(n)
+		}
+
+		upCmd(migrater, limit)
+
+		if log.verbose {
+			log.Println("Finished after", time.Now().Sub(startTime))
+		}
+
+	case "down":
+		if migraterErr != nil {
+			log.fatalErr(migraterErr)
+		}
+
+		limit := -1
+		if flag.Arg(1) != "" {
+			n, err := strconv.ParseUint(flag.Arg(1), 10, 64)
+			if err != nil {
+				log.fatal("error: can't read limit argument N")
+			}
+			limit = int(n)
+		}
+
+		downCmd(migrater, limit)
+
+		if log.verbose {
+			log.Println("Finished after", time.Now().Sub(startTime))
+		}
+
+	case "drop":
+		if migraterErr != nil {
+			log.fatalErr(migraterErr)
+		}
+
+		dropCmd(migrater)
+
+		if log.verbose {
+			log.Println("Finished after", time.Now().Sub(startTime))
+		}
+
+	case "force":
+		if migraterErr != nil {
+			log.fatalErr(migraterErr)
+		}
+
+		if flag.Arg(1) == "" {
+			log.fatal("error: please specify version argument V")
+		}
+
+		v, err := strconv.ParseInt(flag.Arg(1), 10, 64)
+		if err != nil {
+			log.fatal("error: can't read version argument V")
+		}
+
+		if v < -1 {
+			log.fatal("error: argument V must be >= -1")
+		}
+
+		forceCmd(migrater, int(v))
+
+		if log.verbose {
+			log.Println("Finished after", time.Now().Sub(startTime))
+		}
+
+	case "version":
+		if migraterErr != nil {
+			log.fatalErr(migraterErr)
+		}
+
+		versionCmd(migrater)
+
+	default:
+		flag.Usage()
+		os.Exit(0)
+	}
+}
--- a/src/vendor/github.com/golang-migrate/migrate/cli/version.go
+++ b/src/vendor/github.com/golang-migrate/migrate/cli/version.go
@ -0,0 +1,4 @@
+package main
+
+// Version is set in Makefile with build flags
+var Version = "dev"
--- a/src/vendor/github.com/golang-migrate/migrate/database/cassandra/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cassandra/README.md
@ -0,0 +1,31 @@
+# Cassandra
+
+* Drop command will not work on Cassandra 2.X because it rely on
+system_schema table which comes with 3.X
+* Other commands should work properly but are **not tested**
+
+
+## Usage
+`cassandra://host:port/keyspace?param1=value&param2=value2`
+
+
+| URL Query  | Default value | Description |
+|------------|-------------|-----------|
+| `x-migrations-table` | schema_migrations | Name of the migrations table |
+| `port` | 9042 | The port to bind to  |
+| `consistency` | ALL | Migration consistency
+| `protocol` |  | Cassandra protocol version (3 or 4)
+| `timeout` | 1 minute | Migration timeout
+| `username` | nil | Username to use when authenticating. |
+| `password` | nil | Password to use when authenticating. |
+
+
+`timeout` is parsed using [time.ParseDuration(s string)](https://golang.org/pkg/time/#ParseDuration)
+
+
+## Upgrading from v1
+
+1. Write down the current migration version from schema_migrations
+2. `DROP TABLE schema_migrations`
+4. Download and install the latest migrate version.
+5. Force the current migration version with `migrate force <current_version>`.
--- a/src/vendor/github.com/golang-migrate/migrate/database/cassandra/cassandra.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cassandra/cassandra.go
@ -0,0 +1,242 @@
+package cassandra
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gocql/gocql"
+	"github.com/golang-migrate/migrate/database"
+)
+
+func init() {
+	db := new(Cassandra)
+	database.Register("cassandra", db)
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+
+var (
+	ErrNilConfig     = errors.New("no config")
+	ErrNoKeyspace    = errors.New("no keyspace provided")
+	ErrDatabaseDirty = errors.New("database is dirty")
+	ErrClosedSession = errors.New("session is closed")
+)
+
+type Config struct {
+	MigrationsTable string
+	KeyspaceName    string
+}
+
+type Cassandra struct {
+	session  *gocql.Session
+	isLocked bool
+
+	// Open and WithInstance need to guarantee that config is never nil
+	config *Config
+}
+
+func WithInstance(session *gocql.Session, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	} else if len(config.KeyspaceName) == 0 {
+		return nil, ErrNoKeyspace
+	}
+
+	if session.Closed() {
+		return nil, ErrClosedSession
+	}
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	c := &Cassandra{
+		session: session,
+		config:  config,
+	}
+
+	if err := c.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func (c *Cassandra) Open(url string) (database.Driver, error) {
+	u, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// Check for missing mandatory attributes
+	if len(u.Path) == 0 {
+		return nil, ErrNoKeyspace
+	}
+
+	cluster := gocql.NewCluster(u.Host)
+	cluster.Keyspace = strings.TrimPrefix(u.Path, "/")
+	cluster.Consistency = gocql.All
+	cluster.Timeout = 1 * time.Minute
+
+	if len(u.Query().Get("username")) > 0 && len(u.Query().Get("password")) > 0 {
+		authenticator := gocql.PasswordAuthenticator{
+			Username: u.Query().Get("username"),
+			Password: u.Query().Get("password"),
+		}
+		cluster.Authenticator = authenticator
+	}
+
+	// Retrieve query string configuration
+	if len(u.Query().Get("consistency")) > 0 {
+		var consistency gocql.Consistency
+		consistency, err = parseConsistency(u.Query().Get("consistency"))
+		if err != nil {
+			return nil, err
+		}
+
+		cluster.Consistency = consistency
+	}
+	if len(u.Query().Get("protocol")) > 0 {
+		var protoversion int
+		protoversion, err = strconv.Atoi(u.Query().Get("protocol"))
+		if err != nil {
+			return nil, err
+		}
+		cluster.ProtoVersion = protoversion
+	}
+	if len(u.Query().Get("timeout")) > 0 {
+		var timeout time.Duration
+		timeout, err = time.ParseDuration(u.Query().Get("timeout"))
+		if err != nil {
+			return nil, err
+		}
+		cluster.Timeout = timeout
+	}
+
+	session, err := cluster.CreateSession()
+	if err != nil {
+		return nil, err
+	}
+
+	return WithInstance(session, &Config{
+		KeyspaceName:    strings.TrimPrefix(u.Path, "/"),
+		MigrationsTable: u.Query().Get("x-migrations-table"),
+	})
+}
+
+func (c *Cassandra) Close() error {
+	c.session.Close()
+	return nil
+}
+
+func (c *Cassandra) Lock() error {
+	if c.isLocked {
+		return database.ErrLocked
+	}
+	c.isLocked = true
+	return nil
+}
+
+func (c *Cassandra) Unlock() error {
+	c.isLocked = false
+	return nil
+}
+
+func (c *Cassandra) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+	// run migration
+	query := string(migr[:])
+	if err := c.session.Query(query).Exec(); err != nil {
+		// TODO: cast to Cassandra error and get line number
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	return nil
+}
+
+func (c *Cassandra) SetVersion(version int, dirty bool) error {
+	query := `TRUNCATE "` + c.config.MigrationsTable + `"`
+	if err := c.session.Query(query).Exec(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if version >= 0 {
+		query = `INSERT INTO "` + c.config.MigrationsTable + `" (version, dirty) VALUES (?, ?)`
+		if err := c.session.Query(query, version, dirty).Exec(); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+
+	return nil
+}
+
+// Return current keyspace version
+func (c *Cassandra) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM "` + c.config.MigrationsTable + `" LIMIT 1`
+	err = c.session.Query(query).Scan(&version, &dirty)
+	switch {
+	case err == gocql.ErrNotFound:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if _, ok := err.(*gocql.Error); ok {
+			return database.NilVersion, false, nil
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (c *Cassandra) Drop() error {
+	// select all tables in current schema
+	query := fmt.Sprintf(`SELECT table_name from system_schema.tables WHERE keyspace_name='%s'`, c.config.KeyspaceName)
+	iter := c.session.Query(query).Iter()
+	var tableName string
+	for iter.Scan(&tableName) {
+		err := c.session.Query(fmt.Sprintf(`DROP TABLE %s`, tableName)).Exec()
+		if err != nil {
+			return err
+		}
+	}
+	// Re-create the version table
+	return c.ensureVersionTable()
+}
+
+// Ensure version table exists
+func (c *Cassandra) ensureVersionTable() error {
+	err := c.session.Query(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version bigint, dirty boolean, PRIMARY KEY(version))", c.config.MigrationsTable)).Exec()
+	if err != nil {
+		return err
+	}
+	if _, _, err = c.Version(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ParseConsistency wraps gocql.ParseConsistency
+// to return an error instead of a panicking.
+func parseConsistency(consistencyStr string) (consistency gocql.Consistency, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("Failed to parse consistency \"%s\": %v", consistencyStr, r)
+			}
+		}
+	}()
+	consistency = gocql.ParseConsistency(consistencyStr)
+
+	return consistency, nil
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/cassandra/cassandra_test.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cassandra/cassandra_test.go
@ -0,0 +1,56 @@
+package cassandra
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/gocql/gocql"
+
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
+)
+
+var versions = []mt.Version{
+	{Image: "cassandra:3.0.10"},
+	{Image: "cassandra:3.0"},
+}
+
+func isReady(i mt.Instance) bool {
+	// Cassandra exposes 5 ports (7000, 7001, 7199, 9042 & 9160)
+	// We only need the port bound to 9042, but we can only access to the first one
+	// through 'i.Port()' (which calls DockerContainer.firstPortMapping())
+	// So we need to get port mapping to retrieve correct port number bound to 9042
+	portMap := i.NetworkSettings().Ports
+	port, _ := strconv.Atoi(portMap["9042/tcp"][0].HostPort)
+
+	cluster := gocql.NewCluster(i.Host())
+	cluster.Port = port
+	cluster.Consistency = gocql.All
+	p, err := cluster.CreateSession()
+	if err != nil {
+		return false
+	}
+	defer p.Close()
+	// Create keyspace for tests
+	if err = p.Query("CREATE KEYSPACE testks WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor':1}").Exec(); err != nil {
+		return false
+	}
+	return true
+}
+
+func Test(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Cassandra{}
+			portMap := i.NetworkSettings().Ports
+			port, _ := strconv.Atoi(portMap["9042/tcp"][0].HostPort)
+			addr := fmt.Sprintf("cassandra://%v:%v/testks", i.Host(), port)
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			defer d.Close()
+			dt.Test(t, d, []byte("SELECT table_name from system_schema.tables"))
+		})
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/README.md
@ -0,0 +1,12 @@
+# ClickHouse
+
+`clickhouse://host:port?username=user&password=qwerty&database=clicks`
+
+| URL Query  | Description |
+|------------|-------------|
+| `x-migrations-table`| Name of the migrations table |
+| `database` | The name of the database to connect to |
+| `username` | The user to sign in as |
+| `password` | The user's password | 
+| `host` | The host to connect to. |
+| `port` | The port to bind to. |
--- a/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/clickhouse.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/clickhouse.go
@ -0,0 +1,196 @@
+package clickhouse
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/url"
+	"time"
+
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+)
+
+var DefaultMigrationsTable = "schema_migrations"
+
+var ErrNilConfig = fmt.Errorf("no config")
+
+type Config struct {
+	DatabaseName    string
+	MigrationsTable string
+}
+
+func init() {
+	database.Register("clickhouse", &ClickHouse{})
+}
+
+func WithInstance(conn *sql.DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if err := conn.Ping(); err != nil {
+		return nil, err
+	}
+
+	ch := &ClickHouse{
+		conn:   conn,
+		config: config,
+	}
+
+	if err := ch.init(); err != nil {
+		return nil, err
+	}
+
+	return ch, nil
+}
+
+type ClickHouse struct {
+	conn   *sql.DB
+	config *Config
+}
+
+func (ch *ClickHouse) Open(dsn string) (database.Driver, error) {
+	purl, err := url.Parse(dsn)
+	if err != nil {
+		return nil, err
+	}
+	q := migrate.FilterCustomQuery(purl)
+	q.Scheme = "tcp"
+	conn, err := sql.Open("clickhouse", q.String())
+	if err != nil {
+		return nil, err
+	}
+
+	ch = &ClickHouse{
+		conn: conn,
+		config: &Config{
+			MigrationsTable: purl.Query().Get("x-migrations-table"),
+			DatabaseName:    purl.Query().Get("database"),
+		},
+	}
+
+	if err := ch.init(); err != nil {
+		return nil, err
+	}
+
+	return ch, nil
+}
+
+func (ch *ClickHouse) init() error {
+	if len(ch.config.DatabaseName) == 0 {
+		if err := ch.conn.QueryRow("SELECT currentDatabase()").Scan(&ch.config.DatabaseName); err != nil {
+			return err
+		}
+	}
+
+	if len(ch.config.MigrationsTable) == 0 {
+		ch.config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	return ch.ensureVersionTable()
+}
+
+func (ch *ClickHouse) Run(r io.Reader) error {
+	migration, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+	if _, err := ch.conn.Exec(string(migration)); err != nil {
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migration}
+	}
+
+	return nil
+}
+func (ch *ClickHouse) Version() (int, bool, error) {
+	var (
+		version int
+		dirty   uint8
+		query   = "SELECT version, dirty FROM `" + ch.config.MigrationsTable + "` ORDER BY sequence DESC LIMIT 1"
+	)
+	if err := ch.conn.QueryRow(query).Scan(&version, &dirty); err != nil {
+		if err == sql.ErrNoRows {
+			return database.NilVersion, false, nil
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return version, dirty == 1, nil
+}
+
+func (ch *ClickHouse) SetVersion(version int, dirty bool) error {
+	var (
+		bool = func(v bool) uint8 {
+			if v {
+				return 1
+			}
+			return 0
+		}
+		tx, err = ch.conn.Begin()
+	)
+	if err != nil {
+		return err
+	}
+
+	query := "INSERT INTO " + ch.config.MigrationsTable + " (version, dirty, sequence) VALUES (?, ?, ?)"
+	if _, err := tx.Exec(query, version, bool(dirty), time.Now().UnixNano()); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return tx.Commit()
+}
+
+func (ch *ClickHouse) ensureVersionTable() error {
+	var (
+		table string
+		query = "SHOW TABLES FROM " + ch.config.DatabaseName + " LIKE '" + ch.config.MigrationsTable + "'"
+	)
+	// check if migration table exists
+	if err := ch.conn.QueryRow(query).Scan(&table); err != nil {
+		if err != sql.ErrNoRows {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	} else {
+		return nil
+	}
+	// if not, create the empty migration table
+	query = `
+		CREATE TABLE ` + ch.config.MigrationsTable + ` (
+			version    UInt32, 
+			dirty      UInt8,
+			sequence   UInt64
+		) Engine=TinyLog
+	`
+	if _, err := ch.conn.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
+func (ch *ClickHouse) Drop() error {
+	var (
+		query       = "SHOW TABLES FROM " + ch.config.DatabaseName
+		tables, err = ch.conn.Query(query)
+	)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+	for tables.Next() {
+		var table string
+		if err := tables.Scan(&table); err != nil {
+			return err
+		}
+
+		query = "DROP TABLE IF EXISTS " + ch.config.DatabaseName + "." + table
+
+		if _, err := ch.conn.Exec(query); err != nil {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+	return ch.ensureVersionTable()
+}
+
+func (ch *ClickHouse) Lock() error   { return nil }
+func (ch *ClickHouse) Unlock() error { return nil }
+func (ch *ClickHouse) Close() error  { return ch.conn.Close() }
--- a/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/001_init.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/001_init.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS test_1;
--- a/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/001_init.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/001_init.up.sql
@ -0,0 +1,3 @@
+CREATE TABLE test_1 (
+    Date Date 
+) Engine=Memory;
--- a/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/002_create_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/002_create_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS test_2;
--- a/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/002_create_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/clickhouse/examples/migrations/002_create_table.up.sql
@ -0,0 +1,3 @@
+CREATE TABLE test_2 (
+    Date Date 
+) Engine=Memory;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/README.md
@ -0,0 +1,19 @@
+# cockroachdb
+
+`cockroachdb://user:password@host:port/dbname?query` (`cockroach://`, and `crdb-postgres://` work, too)
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `x-lock-table` | `LockTable` | Name of the table which maintains the migration lock |
+| `x-force-lock` | `ForceLock` | Force lock acquisition to fix faulty migrations which may not have released the schema lock (Boolean, default is `false`) |
+| `dbname` | `DatabaseName` | 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) |
+| `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. |
+| `sslmode` | | Whether or not to use SSL (disable\|require\|verify-ca\|verify-full) |
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/cockroachdb.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/cockroachdb.go
@ -0,0 +1,342 @@
+package cockroachdb
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+	"regexp"
+	"strconv"
+)
+
+import (
+	"github.com/cockroachdb/cockroach-go/crdb"
+	"github.com/lib/pq"
+)
+
+import (
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+)
+
+func init() {
+	db := CockroachDb{}
+	database.Register("cockroach", &db)
+	database.Register("cockroachdb", &db)
+	database.Register("crdb-postgres", &db)
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+var DefaultLockTable = "schema_lock"
+
+var (
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+)
+
+type Config struct {
+	MigrationsTable string
+	LockTable       string
+	ForceLock       bool
+	DatabaseName    string
+}
+
+type CockroachDb struct {
+	db       *sql.DB
+	isLocked bool
+
+	// Open and WithInstance need to guarantee that config is never nil
+	config *Config
+}
+
+func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if err := instance.Ping(); err != nil {
+		return nil, err
+	}
+
+	query := `SELECT current_database()`
+	var databaseName string
+	if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
+		return nil, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if len(databaseName) == 0 {
+		return nil, ErrNoDatabaseName
+	}
+
+	config.DatabaseName = databaseName
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	if len(config.LockTable) == 0 {
+		config.LockTable = DefaultLockTable
+	}
+
+	px := &CockroachDb{
+		db:     instance,
+		config: config,
+	}
+
+	if err := px.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	if err := px.ensureLockTable(); err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (c *CockroachDb) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// As Cockroach uses the postgres protocol, and 'postgres' is already a registered database, we need to replace the
+	// connect prefix, with the actual protocol, so that the library can differentiate between the implementations
+	re := regexp.MustCompile("^(cockroach(db)?|crdb-postgres)")
+	connectString := re.ReplaceAllString(migrate.FilterCustomQuery(purl).String(), "postgres")
+
+	db, err := sql.Open("postgres", connectString)
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+
+	lockTable := purl.Query().Get("x-lock-table")
+	if len(lockTable) == 0 {
+		lockTable = DefaultLockTable
+	}
+
+	forceLockQuery := purl.Query().Get("x-force-lock")
+	forceLock, err := strconv.ParseBool(forceLockQuery)
+	if err != nil {
+		forceLock = false
+	}
+
+	px, err := WithInstance(db, &Config{
+		DatabaseName:    purl.Path,
+		MigrationsTable: migrationsTable,
+		LockTable:       lockTable,
+		ForceLock:       forceLock,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (c *CockroachDb) Close() error {
+	return c.db.Close()
+}
+
+// Locking is done manually with a separate lock table.  Implementing advisory locks in CRDB is being discussed
+// See: https://github.com/cockroachdb/cockroach/issues/13546
+func (c *CockroachDb) Lock() error {
+	err := crdb.ExecuteTx(context.Background(), c.db, nil, func(tx *sql.Tx) error {
+		aid, err := database.GenerateAdvisoryLockId(c.config.DatabaseName)
+		if err != nil {
+			return err
+		}
+
+		query := "SELECT * FROM " + c.config.LockTable + " WHERE lock_id = $1"
+		rows, err := tx.Query(query, aid)
+		if err != nil {
+			return database.Error{OrigErr: err, Err: "failed to fetch migration lock", Query: []byte(query)}
+		}
+		defer rows.Close()
+
+		// If row exists at all, lock is present
+		locked := rows.Next()
+		if locked && !c.config.ForceLock {
+			return database.ErrLocked
+		}
+
+		query = "INSERT INTO " + c.config.LockTable + " (lock_id) VALUES ($1)"
+		if _, err := tx.Exec(query, aid); err != nil {
+			return database.Error{OrigErr: err, Err: "failed to set migration lock", Query: []byte(query)}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	} else {
+		c.isLocked = true
+		return nil
+	}
+}
+
+// Locking is done manually with a separate lock table.  Implementing advisory locks in CRDB is being discussed
+// See: https://github.com/cockroachdb/cockroach/issues/13546
+func (c *CockroachDb) Unlock() error {
+	aid, err := database.GenerateAdvisoryLockId(c.config.DatabaseName)
+	if err != nil {
+		return err
+	}
+
+	// In the event of an implementation (non-migration) error, it is possible for the lock to not be released.  Until
+	// a better locking mechanism is added, a manual purging of the lock table may be required in such circumstances
+	query := "DELETE FROM " + c.config.LockTable + " WHERE lock_id = $1"
+	if _, err := c.db.Exec(query, aid); err != nil {
+		if e, ok := err.(*pq.Error); ok {
+			// 42P01 is "UndefinedTableError" in CockroachDB
+			// https://github.com/cockroachdb/cockroach/blob/master/pkg/sql/pgwire/pgerror/codes.go
+			if e.Code == "42P01" {
+				// On drops, the lock table is fully removed;  This is fine, and is a valid "unlocked" state for the schema
+				c.isLocked = false
+				return nil
+			}
+		}
+		return database.Error{OrigErr: err, Err: "failed to release migration lock", Query: []byte(query)}
+	}
+
+	c.isLocked = false
+	return nil
+}
+
+func (c *CockroachDb) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+
+	// run migration
+	query := string(migr[:])
+	if _, err := c.db.Exec(query); err != nil {
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	return nil
+}
+
+func (c *CockroachDb) SetVersion(version int, dirty bool) error {
+	return crdb.ExecuteTx(context.Background(), c.db, nil, func(tx *sql.Tx) error {
+		if _, err := tx.Exec(`DELETE FROM "` + c.config.MigrationsTable + `"`); err != nil {
+			return err
+		}
+
+		if version >= 0 {
+			if _, err := tx.Exec(`INSERT INTO "`+c.config.MigrationsTable+`" (version, dirty) VALUES ($1, $2)`, version, dirty); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func (c *CockroachDb) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM "` + c.config.MigrationsTable + `" LIMIT 1`
+	err = c.db.QueryRow(query).Scan(&version, &dirty)
+
+	switch {
+	case err == sql.ErrNoRows:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if e, ok := err.(*pq.Error); ok {
+			// 42P01 is "UndefinedTableError" in CockroachDB
+			// https://github.com/cockroachdb/cockroach/blob/master/pkg/sql/pgwire/pgerror/codes.go
+			if e.Code == "42P01" {
+				return database.NilVersion, false, nil
+			}
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (c *CockroachDb) Drop() error {
+	// select all tables in current schema
+	query := `SELECT table_name FROM information_schema.tables WHERE table_schema=(SELECT current_schema())`
+	tables, err := c.db.Query(query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+
+	// delete one table after another
+	tableNames := make([]string, 0)
+	for tables.Next() {
+		var tableName string
+		if err := tables.Scan(&tableName); err != nil {
+			return err
+		}
+		if len(tableName) > 0 {
+			tableNames = append(tableNames, tableName)
+		}
+	}
+
+	if len(tableNames) > 0 {
+		// delete one by one ...
+		for _, t := range tableNames {
+			query = `DROP TABLE IF EXISTS ` + t + ` CASCADE`
+			if _, err := c.db.Exec(query); err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+		if err := c.ensureVersionTable(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *CockroachDb) ensureVersionTable() error {
+	// check if migration table exists
+	var count int
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1`
+	if err := c.db.QueryRow(query, c.config.MigrationsTable).Scan(&count); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if count == 1 {
+		return nil
+	}
+
+	// if not, create the empty migration table
+	query = `CREATE TABLE "` + c.config.MigrationsTable + `" (version INT NOT NULL PRIMARY KEY, dirty BOOL NOT NULL)`
+	if _, err := c.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
+func (c *CockroachDb) ensureLockTable() error {
+	// check if lock table exists
+	var count int
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1`
+	if err := c.db.QueryRow(query, c.config.LockTable).Scan(&count); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if count == 1 {
+		return nil
+	}
+
+	// if not, create the empty lock table
+	query = `CREATE TABLE "` + c.config.LockTable + `" (lock_id INT NOT NULL PRIMARY KEY)`
+	if _, err := c.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	return nil
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/cockroachdb_test.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/cockroachdb_test.go
@ -0,0 +1,91 @@
+package cockroachdb
+
+// error codes https://github.com/lib/pq/blob/master/error.go
+
+import (
+	//"bytes"
+	"database/sql"
+	"fmt"
+	"io"
+	"testing"
+
+	"github.com/lib/pq"
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
+	"bytes"
+)
+
+var versions = []mt.Version{
+	{Image: "cockroachdb/cockroach:v1.0.2", Cmd: []string{"start", "--insecure"}},
+}
+
+func isReady(i mt.Instance) bool {
+	db, err := sql.Open("postgres", fmt.Sprintf("postgres://root@%v:%v?sslmode=disable", i.Host(), i.PortFor(26257)))
+	if err != nil {
+		return false
+	}
+	defer db.Close()
+	err = db.Ping()
+	if err == io.EOF {
+		_, err = db.Exec("CREATE DATABASE migrate")
+		return err == nil;
+	} else if e, ok := err.(*pq.Error); ok {
+		if e.Code.Name() == "cannot_connect_now" {
+			return false
+		}
+	}
+
+	_, err = db.Exec("CREATE DATABASE migrate")
+	return err == nil;
+
+	return true
+}
+
+func Test(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			c := &CockroachDb{}
+			addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable", i.Host(), i.PortFor(26257))
+			d, err := c.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			dt.Test(t, d, []byte("SELECT 1"))
+		})
+}
+
+func TestMultiStatement(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			c := &CockroachDb{}
+			addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable", i.Host(), i.Port())
+			d, err := c.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			if err := d.Run(bytes.NewReader([]byte("CREATE TABLE foo (foo text); CREATE TABLE bar (bar text);"))); err != nil {
+				t.Fatalf("expected err to be nil, got %v", err)
+			}
+
+			// make sure second table exists
+			var exists bool
+			if err := d.(*CockroachDb).db.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'bar' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
+				t.Fatal(err)
+			}
+			if !exists {
+				t.Fatalf("expected table bar to exist")
+			}
+		})
+}
+
+func TestFilterCustomQuery(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			c := &CockroachDb{}
+			addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable&x-custom=foobar", i.Host(), i.PortFor(26257))
+			_, err := c.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+		})
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1085649617_create_users_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1085649617_create_users_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS users;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1085649617_create_users_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1085649617_create_users_table.up.sql
@ -0,0 +1,5 @@
+CREATE TABLE users (
+  user_id INT UNIQUE,
+  name    STRING(40),
+  email   STRING(40)
+);
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1185749658_add_city_to_users.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1185749658_add_city_to_users.down.sql
@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS city;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1185749658_add_city_to_users.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1185749658_add_city_to_users.up.sql
@ -0,0 +1 @@
+ALTER TABLE users ADD COLUMN city TEXT;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1285849751_add_index_on_user_emails.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1285849751_add_index_on_user_emails.down.sql
@ -0,0 +1 @@
+DROP INDEX IF EXISTS users_email_index;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1285849751_add_index_on_user_emails.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1285849751_add_index_on_user_emails.up.sql
@ -0,0 +1,3 @@
+CREATE UNIQUE INDEX IF NOT EXISTS users_email_index ON users (email);
+
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1385949617_create_books_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1385949617_create_books_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS books;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1385949617_create_books_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1385949617_create_books_table.up.sql
@ -0,0 +1,5 @@
+CREATE TABLE books (
+  user_id INT,
+  name    STRING(40),
+  author  STRING(40)
+);
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1485949617_create_movies_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1485949617_create_movies_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS movies;
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1485949617_create_movies_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1485949617_create_movies_table.up.sql
@ -0,0 +1,5 @@
+CREATE TABLE movies (
+  user_id   INT,
+  name      STRING(40),
+  director  STRING(40)
+);
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1585849751_just_a_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1585849751_just_a_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1685849751_another_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1685849751_another_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1785849751_another_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1785849751_another_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1885849751_another_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/cockroachdb/examples/migrations/1885849751_another_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/crate/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/crate/README.md
--- a/src/vendor/github.com/golang-migrate/migrate/database/driver.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/driver.go
@ -0,0 +1,123 @@
+// Package database provides the Database interface.
+// All database drivers must implement this interface, register themselves,
+// optionally provide a `WithInstance` function and pass the tests
+// in package database/testing.
+package database
+
+import (
+	"fmt"
+	"io"
+	nurl "net/url"
+	"sync"
+)
+
+var (
+	ErrLocked = fmt.Errorf("can't acquire lock")
+)
+
+const NilVersion int = -1
+
+var driversMu sync.RWMutex
+var drivers = make(map[string]Driver)
+
+// Driver is the interface every database driver must implement.
+//
+// How to implement a database driver?
+//   1. Implement this interface.
+//   2. Optionally, add a function named `WithInstance`.
+//      This function should accept an existing DB instance and a Config{} struct
+//      and return a driver instance.
+//   3. Add a test that calls database/testing.go:Test()
+//   4. Add own tests for Open(), WithInstance() (when provided) and Close().
+//      All other functions are tested by tests in database/testing.
+//      Saves you some time and makes sure all database drivers behave the same way.
+//   5. Call Register in init().
+//   6. Create a migrate/cli/build_<driver-name>.go file
+//   7. Add driver name in 'DATABASE' variable in Makefile
+//
+// Guidelines:
+//   * Don't try to correct user input. Don't assume things.
+//     When in doubt, return an error and explain the situation to the user.
+//   * All configuration input must come from the URL string in func Open()
+//     or the Config{} struct in WithInstance. Don't os.Getenv().
+type Driver interface {
+	// Open returns a new driver instance configured with parameters
+	// coming from the URL string. Migrate will call this function
+	// only once per instance.
+	Open(url string) (Driver, error)
+
+	// Close closes the underlying database instance managed by the driver.
+	// Migrate will call this function only once per instance.
+	Close() error
+
+	// Lock should acquire a database lock so that only one migration process
+	// can run at a time. Migrate will call this function before Run is called.
+	// If the implementation can't provide this functionality, return nil.
+	// Return database.ErrLocked if database is already locked.
+	Lock() error
+
+	// Unlock should release the lock. Migrate will call this function after
+	// all migrations have been run.
+	Unlock() error
+
+	// Run applies a migration to the database. migration is garantueed to be not nil.
+	Run(migration io.Reader) error
+
+	// SetVersion saves version and dirty state.
+	// Migrate will call this function before and after each call to Run.
+	// version must be >= -1. -1 means NilVersion.
+	SetVersion(version int, dirty bool) error
+
+	// Version returns the currently active version and if the database is dirty.
+	// When no migration has been applied, it must return version -1.
+	// Dirty means, a previous migration failed and user interaction is required.
+	Version() (version int, dirty bool, err error)
+
+	// Drop deletes everything in the database.
+	Drop() error
+}
+
+// Open returns a new driver instance.
+func Open(url string) (Driver, error) {
+	u, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	if u.Scheme == "" {
+		return nil, fmt.Errorf("database driver: invalid URL scheme")
+	}
+
+	driversMu.RLock()
+	d, ok := drivers[u.Scheme]
+	driversMu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("database driver: unknown driver %v (forgotten import?)", u.Scheme)
+	}
+
+	return d.Open(url)
+}
+
+// Register globally registers a driver.
+func Register(name string, driver Driver) {
+	driversMu.Lock()
+	defer driversMu.Unlock()
+	if driver == nil {
+		panic("Register driver is nil")
+	}
+	if _, dup := drivers[name]; dup {
+		panic("Register called twice for driver " + name)
+	}
+	drivers[name] = driver
+}
+
+// List lists the registered drivers
+func List() []string {
+	driversMu.RLock()
+	defer driversMu.RUnlock()
+	names := make([]string, 0, len(drivers))
+	for n := range drivers {
+		names = append(names, n)
+	}
+	return names
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/driver_test.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/driver_test.go
@ -0,0 +1,8 @@
+package database
+
+func ExampleDriver() {
+	// see database/stub for an example
+
+	// database/stub/stub.go has the driver implementation
+	// database/stub/stub_test.go runs database/testing/test.go:Test
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/error.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/error.go
@ -0,0 +1,27 @@
+package database
+
+import (
+	"fmt"
+)
+
+// Error should be used for errors involving queries ran against the database
+type Error struct {
+	// Optional: the line number
+	Line uint
+
+	// Query is a query excerpt
+	Query []byte
+
+	// Err is a useful/helping error message for humans
+	Err string
+
+	// OrigErr is the underlying error
+	OrigErr error
+}
+
+func (e Error) Error() string {
+	if len(e.Err) == 0 {
+		return fmt.Sprintf("%v in line %v: %s", e.OrigErr, e.Line, e.Query)
+	}
+	return fmt.Sprintf("%v in line %v: %s (details: %v)", e.Err, e.Line, e.Query, e.OrigErr)
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/mongodb/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/mongodb/README.md
--- a/src/vendor/github.com/golang-migrate/migrate/database/mysql/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/mysql/README.md
@ -0,0 +1,53 @@
+# MySQL
+
+`mysql://user:password@tcp(host:port)/dbname?query`
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `dbname` | `DatabaseName` | 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. |
+| `port` | | The port to bind to. |
+| `x-tls-ca` | | The location of the root certificate file. |
+| `x-tls-cert` | | Cert file location. |
+| `x-tls-key` | | Key file location. | 
+| `x-tls-insecure-skip-verify` | | Whether or not to use SSL (true\|false) | 
+
+## Use with existing client
+
+If you use the MySQL driver with existing database client, you must create the client with parameter `multiStatements=true`:
+
+```go
+package main
+
+import (
+    "database/sql"
+    
+    _ "github.com/go-sql-driver/mysql"
+    "github.com/golang-migrate/migrate"
+    "github.com/golang-migrate/migrate/database/mysql"
+    _ "github.com/golang-migrate/migrate/source/file"
+)
+
+func main() {
+    db, _ := sql.Open("mysql", "user:password@tcp(host:port)/dbname?multiStatements=true")
+    driver, _ := mysql.WithInstance(db, &mysql.Config{})
+    m, _ := migrate.NewWithDatabaseInstance(
+        "file:///migrations",
+        "mysql", 
+        driver,
+    )
+    
+    m.Steps(2)
+}
+```
+
+## Upgrading from v1
+
+1. Write down the current migration version from schema_migrations
+1. `DROP TABLE schema_migrations`
+2. Wrap your existing migrations in transactions ([BEGIN/COMMIT](https://dev.mysql.com/doc/refman/5.7/en/commit.html)) if you use multiple statements within one migration.
+3. Download and install the latest migrate version.
+4. Force the current migration version with `migrate force <current_version>`.
--- a/src/vendor/github.com/golang-migrate/migrate/database/mysql/mysql.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/mysql/mysql.go
@ -0,0 +1,344 @@
+// +build go1.9
+
+package mysql
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"database/sql"
+	"fmt"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+	"strconv"
+	"strings"
+
+	"github.com/go-sql-driver/mysql"
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+)
+
+func init() {
+	database.Register("mysql", &Mysql{})
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+
+var (
+	ErrDatabaseDirty  = fmt.Errorf("database is dirty")
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+	ErrAppendPEM      = fmt.Errorf("failed to append PEM")
+)
+
+type Config struct {
+	MigrationsTable string
+	DatabaseName    string
+}
+
+type Mysql struct {
+	// mysql RELEASE_LOCK must be called from the same conn, so
+	// just do everything over a single conn anyway.
+	conn     *sql.Conn
+	isLocked bool
+
+	config *Config
+}
+
+// instance must have `multiStatements` set to true
+func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if err := instance.Ping(); err != nil {
+		return nil, err
+	}
+
+	query := `SELECT DATABASE()`
+	var databaseName sql.NullString
+	if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
+		return nil, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if len(databaseName.String) == 0 {
+		return nil, ErrNoDatabaseName
+	}
+
+	config.DatabaseName = databaseName.String
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	conn, err := instance.Conn(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	mx := &Mysql{
+		conn:   conn,
+		config: config,
+	}
+
+	if err := mx.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return mx, nil
+}
+
+func (m *Mysql) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	q := purl.Query()
+	q.Set("multiStatements", "true")
+	purl.RawQuery = q.Encode()
+
+	db, err := sql.Open("mysql", strings.Replace(
+		migrate.FilterCustomQuery(purl).String(), "mysql://", "", 1))
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+
+	// use custom TLS?
+	ctls := purl.Query().Get("tls")
+	if len(ctls) > 0 {
+		if _, isBool := readBool(ctls); !isBool && strings.ToLower(ctls) != "skip-verify" {
+			rootCertPool := x509.NewCertPool()
+			pem, err := ioutil.ReadFile(purl.Query().Get("x-tls-ca"))
+			if err != nil {
+				return nil, err
+			}
+
+			if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
+				return nil, ErrAppendPEM
+			}
+
+			certs, err := tls.LoadX509KeyPair(purl.Query().Get("x-tls-cert"), purl.Query().Get("x-tls-key"))
+			if err != nil {
+				return nil, err
+			}
+
+			insecureSkipVerify := false
+			if len(purl.Query().Get("x-tls-insecure-skip-verify")) > 0 {
+				x, err := strconv.ParseBool(purl.Query().Get("x-tls-insecure-skip-verify"))
+				if err != nil {
+					return nil, err
+				}
+				insecureSkipVerify = x
+			}
+
+			mysql.RegisterTLSConfig(ctls, &tls.Config{
+				RootCAs:            rootCertPool,
+				Certificates:       []tls.Certificate{certs},
+				InsecureSkipVerify: insecureSkipVerify,
+			})
+		}
+	}
+
+	mx, err := WithInstance(db, &Config{
+		DatabaseName:    purl.Path,
+		MigrationsTable: migrationsTable,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return mx, nil
+}
+
+func (m *Mysql) Close() error {
+	return m.conn.Close()
+}
+
+func (m *Mysql) Lock() error {
+	if m.isLocked {
+		return database.ErrLocked
+	}
+
+	aid, err := database.GenerateAdvisoryLockId(
+		fmt.Sprintf("%s:%s", m.config.DatabaseName, m.config.MigrationsTable))
+	if err != nil {
+		return err
+	}
+
+	query := "SELECT GET_LOCK(?, 10)"
+	var success bool
+	if err := m.conn.QueryRowContext(context.Background(), query, aid).Scan(&success); err != nil {
+		return &database.Error{OrigErr: err, Err: "try lock failed", Query: []byte(query)}
+	}
+
+	if success {
+		m.isLocked = true
+		return nil
+	}
+
+	return database.ErrLocked
+}
+
+func (m *Mysql) Unlock() error {
+	if !m.isLocked {
+		return nil
+	}
+
+	aid, err := database.GenerateAdvisoryLockId(
+		fmt.Sprintf("%s:%s", m.config.DatabaseName, m.config.MigrationsTable))
+	if err != nil {
+		return err
+	}
+
+	query := `SELECT RELEASE_LOCK(?)`
+	if _, err := m.conn.ExecContext(context.Background(), query, aid); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	// NOTE: RELEASE_LOCK could return NULL or (or 0 if the code is changed),
+	// in which case isLocked should be true until the timeout expires -- synchronizing
+	// these states is likely not worth trying to do; reconsider the necessity of isLocked.
+
+	m.isLocked = false
+	return nil
+}
+
+func (m *Mysql) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+
+	query := string(migr[:])
+	if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	return nil
+}
+
+func (m *Mysql) SetVersion(version int, dirty bool) error {
+	tx, err := m.conn.BeginTx(context.Background(), &sql.TxOptions{})
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+
+	query := "TRUNCATE `" + m.config.MigrationsTable + "`"
+	if _, err := tx.ExecContext(context.Background(), query); err != nil {
+		tx.Rollback()
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if version >= 0 {
+		query := "INSERT INTO `" + m.config.MigrationsTable + "` (version, dirty) VALUES (?, ?)"
+		if _, err := tx.ExecContext(context.Background(), query, version, dirty); err != nil {
+			tx.Rollback()
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction commit failed"}
+	}
+
+	return nil
+}
+
+func (m *Mysql) Version() (version int, dirty bool, err error) {
+	query := "SELECT version, dirty FROM `" + m.config.MigrationsTable + "` LIMIT 1"
+	err = m.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
+	switch {
+	case err == sql.ErrNoRows:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if e, ok := err.(*mysql.MySQLError); ok {
+			if e.Number == 0 {
+				return database.NilVersion, false, nil
+			}
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (m *Mysql) Drop() error {
+	// select all tables
+	query := `SHOW TABLES LIKE '%'`
+	tables, err := m.conn.QueryContext(context.Background(), query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+
+	// delete one table after another
+	tableNames := make([]string, 0)
+	for tables.Next() {
+		var tableName string
+		if err := tables.Scan(&tableName); err != nil {
+			return err
+		}
+		if len(tableName) > 0 {
+			tableNames = append(tableNames, tableName)
+		}
+	}
+
+	if len(tableNames) > 0 {
+		// delete one by one ...
+		for _, t := range tableNames {
+			query = "DROP TABLE IF EXISTS `" + t + "` CASCADE"
+			if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+		if err := m.ensureVersionTable(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Mysql) ensureVersionTable() error {
+	// check if migration table exists
+	var result string
+	query := `SHOW TABLES LIKE "` + m.config.MigrationsTable + `"`
+	if err := m.conn.QueryRowContext(context.Background(), query).Scan(&result); err != nil {
+		if err != sql.ErrNoRows {
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	} else {
+		return nil
+	}
+
+	// if not, create the empty migration table
+	query = "CREATE TABLE `" + m.config.MigrationsTable + "` (version bigint not null primary key, dirty boolean not null)"
+	if _, err := m.conn.ExecContext(context.Background(), query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
+// Returns the bool value of the input.
+// The 2nd return value indicates if the input was a valid bool value
+// See https://github.com/go-sql-driver/mysql/blob/a059889267dc7170331388008528b3b44479bffb/utils.go#L71
+func readBool(input string) (value bool, valid bool) {
+	switch input {
+	case "1", "true", "TRUE", "True":
+		return true, true
+	case "0", "false", "FALSE", "False":
+		return false, true
+	}
+
+	// Not a valid bool value
+	return
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/mysql/mysql_test.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/mysql/mysql_test.go
@ -0,0 +1,99 @@
+package mysql
+
+import (
+	"database/sql"
+	sqldriver "database/sql/driver"
+	"fmt"
+	// "io/ioutil"
+	// "log"
+	"testing"
+
+	"github.com/go-sql-driver/mysql"
+	dt "github.com/golang-migrate/migrate/database/testing"
+	mt "github.com/golang-migrate/migrate/testing"
+)
+
+var versions = []mt.Version{
+	{Image: "mysql:8", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:5.7", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:5.6", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+	{Image: "mysql:5.5", ENV: []string{"MYSQL_ROOT_PASSWORD=root", "MYSQL_DATABASE=public"}},
+}
+
+func isReady(i mt.Instance) bool {
+	db, err := sql.Open("mysql", fmt.Sprintf("root:root@tcp(%v:%v)/public", i.Host(), i.Port()))
+	if err != nil {
+		return false
+	}
+	defer db.Close()
+	if err = db.Ping(); err != nil {
+		switch err {
+		case sqldriver.ErrBadConn, mysql.ErrInvalidConn:
+			return false
+		default:
+			fmt.Println(err)
+		}
+		return false
+	}
+
+	return true
+}
+
+func Test(t *testing.T) {
+	// mysql.SetLogger(mysql.Logger(log.New(ioutil.Discard, "", log.Ltime)))
+
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Mysql{}
+			addr := fmt.Sprintf("mysql://root:root@tcp(%v:%v)/public", i.Host(), i.Port())
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			defer d.Close()
+			dt.Test(t, d, []byte("SELECT 1"))
+
+			// check ensureVersionTable
+			if err := d.(*Mysql).ensureVersionTable(); err != nil {
+				t.Fatal(err)
+			}
+			// check again
+			if err := d.(*Mysql).ensureVersionTable(); err != nil {
+				t.Fatal(err)
+			}
+		})
+}
+
+func TestLockWorks(t *testing.T) {
+	mt.ParallelTest(t, versions, isReady,
+		func(t *testing.T, i mt.Instance) {
+			p := &Mysql{}
+			addr := fmt.Sprintf("mysql://root:root@tcp(%v:%v)/public", i.Host(), i.Port())
+			d, err := p.Open(addr)
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+			dt.Test(t, d, []byte("SELECT 1"))
+
+			ms := d.(*Mysql)
+
+			err = ms.Lock()
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = ms.Unlock()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// make sure the 2nd lock works (RELEASE_LOCK is very finicky)
+			err = ms.Lock()
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = ms.Unlock()
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+}
--- a/src/vendor/github.com/golang-migrate/migrate/database/neo4j/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/neo4j/README.md
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/README.md
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/README.md
@ -0,0 +1,28 @@
+# postgres
+
+`postgres://user:password@host:port/dbname?query` (`postgresql://` works, too)
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table |
+| `dbname` | `DatabaseName` | The name of the database to connect to |
+| `search_path` | | This variable specifies the order in which schemas are searched when an object is referenced by a simple name with no schema specified. |
+| `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) |
+| `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. | 
+| `sslmode` | | Whether or not to use SSL (disable\|require\|verify-ca\|verify-full) |
+
+
+## Upgrading from v1
+
+1. Write down the current migration version from schema_migrations
+1. `DROP TABLE schema_migrations`
+2. Wrap your existing migrations in transactions ([BEGIN/COMMIT](https://www.postgresql.org/docs/current/static/transaction-iso.html)) if you use multiple statements within one migration.
+3. Download and install the latest migrate version.
+4. Force the current migration version with `migrate force <current_version>`.
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1085649617_create_users_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1085649617_create_users_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS users;
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1085649617_create_users_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1085649617_create_users_table.up.sql
@ -0,0 +1,5 @@
+CREATE TABLE users (
+  user_id integer unique,
+  name    varchar(40),
+  email   varchar(40)
+);
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1185749658_add_city_to_users.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1185749658_add_city_to_users.down.sql
@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS city;
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1185749658_add_city_to_users.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1185749658_add_city_to_users.up.sql
@ -0,0 +1,3 @@
+ALTER TABLE users ADD COLUMN city varchar(100);
+
+
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1285849751_add_index_on_user_emails.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1285849751_add_index_on_user_emails.down.sql
@ -0,0 +1 @@
+DROP INDEX IF EXISTS users_email_index;
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1285849751_add_index_on_user_emails.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1285849751_add_index_on_user_emails.up.sql
@ -0,0 +1,3 @@
+CREATE UNIQUE INDEX CONCURRENTLY users_email_index ON users (email);
+
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1385949617_create_books_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1385949617_create_books_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS books;
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1385949617_create_books_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1385949617_create_books_table.up.sql
@ -0,0 +1,5 @@
+CREATE TABLE books (
+  user_id integer,
+  name    varchar(40),
+  author  varchar(40)
+);
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1485949617_create_movies_table.down.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1485949617_create_movies_table.down.sql
@ -0,0 +1 @@
+DROP TABLE IF EXISTS movies;
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1485949617_create_movies_table.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1485949617_create_movies_table.up.sql
@ -0,0 +1,5 @@
+CREATE TABLE movies (
+  user_id   integer,
+  name      varchar(40),
+  director  varchar(40)
+);
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1585849751_just_a_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1585849751_just_a_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1685849751_another_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1685849751_another_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1785849751_another_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1785849751_another_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1885849751_another_comment.up.sql
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/examples/migrations/1885849751_another_comment.up.sql
@ -0,0 +1 @@
+-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.
--- a/src/vendor/github.com/golang-migrate/migrate/database/postgres/postgres.go
+++ b/src/vendor/github.com/golang-migrate/migrate/database/postgres/postgres.go
@ -0,0 +1,278 @@
+// +build go1.9
+
+package postgres
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"io/ioutil"
+	nurl "net/url"
+
+	"context"
+	"github.com/golang-migrate/migrate"
+	"github.com/golang-migrate/migrate/database"
+	"github.com/lib/pq"
+)
+
+func init() {
+	db := Postgres{}
+	database.Register("postgres", &db)
+	database.Register("postgresql", &db)
+}
+
+var DefaultMigrationsTable = "schema_migrations"
+
+var (
+	ErrNilConfig      = fmt.Errorf("no config")
+	ErrNoDatabaseName = fmt.Errorf("no database name")
+	ErrNoSchema       = fmt.Errorf("no schema")
+	ErrDatabaseDirty  = fmt.Errorf("database is dirty")
+)
+
+type Config struct {
+	MigrationsTable string
+	DatabaseName    string
+}
+
+type Postgres struct {
+	// Locking and unlocking need to use the same connection
+	conn     *sql.Conn
+	isLocked bool
+
+	// Open and WithInstance need to garantuee that config is never nil
+	config *Config
+}
+
+func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
+	if config == nil {
+		return nil, ErrNilConfig
+	}
+
+	if err := instance.Ping(); err != nil {
+		return nil, err
+	}
+
+	query := `SELECT CURRENT_DATABASE()`
+	var databaseName string
+	if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
+		return nil, &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if len(databaseName) == 0 {
+		return nil, ErrNoDatabaseName
+	}
+
+	config.DatabaseName = databaseName
+
+	if len(config.MigrationsTable) == 0 {
+		config.MigrationsTable = DefaultMigrationsTable
+	}
+
+	conn, err := instance.Conn(context.Background())
+
+	if err != nil {
+		return nil, err
+	}
+
+	px := &Postgres{
+		conn:   conn,
+		config: config,
+	}
+
+	if err := px.ensureVersionTable(); err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (p *Postgres) Open(url string) (database.Driver, error) {
+	purl, err := nurl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
+	db, err := sql.Open("postgres", migrate.FilterCustomQuery(purl).String())
+	if err != nil {
+		return nil, err
+	}
+
+	migrationsTable := purl.Query().Get("x-migrations-table")
+	if len(migrationsTable) == 0 {
+		migrationsTable = DefaultMigrationsTable
+	}
+
+	px, err := WithInstance(db, &Config{
+		DatabaseName:    purl.Path,
+		MigrationsTable: migrationsTable,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return px, nil
+}
+
+func (p *Postgres) Close() error {
+	return p.conn.Close()
+}
+
+// https://www.postgresql.org/docs/9.6/static/explicit-locking.html#ADVISORY-LOCKS
+func (p *Postgres) Lock() error {
+	if p.isLocked {
+		return database.ErrLocked
+	}
+
+	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName)
+	if err != nil {
+		return err
+	}
+
+	// This will either obtain the lock immediately and return true,
+	// or return false if the lock cannot be acquired immediately.
+	query := `SELECT pg_advisory_lock($1)`
+	if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
+		return &database.Error{OrigErr: err, Err: "try lock failed", Query: []byte(query)}
+	}
+
+	p.isLocked = true
+	return nil
+}
+
+func (p *Postgres) Unlock() error {
+	if !p.isLocked {
+		return nil
+	}
+
+	aid, err := database.GenerateAdvisoryLockId(p.config.DatabaseName)
+	if err != nil {
+		return err
+	}
+
+	query := `SELECT pg_advisory_unlock($1)`
+	if _, err := p.conn.ExecContext(context.Background(), query, aid); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	p.isLocked = false
+	return nil
+}
+
+func (p *Postgres) Run(migration io.Reader) error {
+	migr, err := ioutil.ReadAll(migration)
+	if err != nil {
+		return err
+	}
+
+	// run migration
+	query := string(migr[:])
+	if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
+		// TODO: cast to postgress error and get line number
+		return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
+	}
+
+	return nil
+}
+
+func (p *Postgres) SetVersion(version int, dirty bool) error {
+	tx, err := p.conn.BeginTx(context.Background(), &sql.TxOptions{})
+	if err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction start failed"}
+	}
+
+	query := `TRUNCATE "` + p.config.MigrationsTable + `"`
+	if _, err := tx.Exec(query); err != nil {
+		tx.Rollback()
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
+	if version >= 0 {
+		query = `INSERT INTO "` + p.config.MigrationsTable + `" (version, dirty) VALUES ($1, $2)`
+		if _, err := tx.Exec(query, version, dirty); err != nil {
+			tx.Rollback()
+			return &database.Error{OrigErr: err, Query: []byte(query)}
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return &database.Error{OrigErr: err, Err: "transaction commit failed"}
+	}
+
+	return nil
+}
+
+func (p *Postgres) Version() (version int, dirty bool, err error) {
+	query := `SELECT version, dirty FROM "` + p.config.MigrationsTable + `" LIMIT 1`
+	err = p.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
+	switch {
+	case err == sql.ErrNoRows:
+		return database.NilVersion, false, nil
+
+	case err != nil:
+		if e, ok := err.(*pq.Error); ok {
+			if e.Code.Name() == "undefined_table" {
+				return database.NilVersion, false, nil
+			}
+		}
+		return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
+
+	default:
+		return version, dirty, nil
+	}
+}
+
+func (p *Postgres) Drop() error {
+	// select all tables in current schema
+	query := `SELECT table_name FROM information_schema.tables WHERE table_schema=(SELECT current_schema())`
+	tables, err := p.conn.QueryContext(context.Background(), query)
+	if err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	defer tables.Close()
+
+	// delete one table after another
+	tableNames := make([]string, 0)
+	for tables.Next() {
+		var tableName string
+		if err := tables.Scan(&tableName); err != nil {
+			return err
+		}
+		if len(tableName) > 0 {
+			tableNames = append(tableNames, tableName)
+		}
+	}
+
+	if len(tableNames) > 0 {
+		// delete one by one ...
+		for _, t := range tableNames {
+			query = `DROP TABLE IF EXISTS ` + t + ` CASCADE`
+			if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
+				return &database.Error{OrigErr: err, Query: []byte(query)}
+			}
+		}
+		if err := p.ensureVersionTable(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p *Postgres) ensureVersionTable() error {
+	// check if migration table exists
+	var count int
+	query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1`
+	if err := p.conn.QueryRowContext(context.Background(), query, p.config.MigrationsTable).Scan(&count); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	if count == 1 {
+		return nil
+	}
+
+	// if not, create the empty migration table
+	query = `CREATE TABLE "` + p.config.MigrationsTable + `" (version bigint not null primary key, dirty boolean not null)`
+	if _, err := p.conn.ExecContext(context.Background(), query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`ALTER TABLE users DROP COLUMN IF EXISTS city;`
				`@ -0,0 +1 @@`
				`-- Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean sed interdum velit, tristique iaculis justo. Pellentesque ut porttitor dolor. Donec sit amet pharetra elit. Cras vel ligula ex. Phasellus posuere.`
				`@ -0,0 +1,3 @@`
				`ALTER TABLE users ADD COLUMN city varchar(100);`