automagic sql db migrations (#461)

* adds migrations

closes #57

migrations only run if the database is not brand new. brand new
databases will contain all the right fields when CREATE TABLE is called,
this is for readability mostly more than efficiency (do not want to have
to go through all of the database migrations to ascertain what columns a table
has). upon startup of a new database, the migrations will be analyzed and the
highest version set, so that future migrations will be run. this should also
avoid running through all the migrations, which could bork db's easily enough
(if the user just exits from impatience, say).

otherwise, all migrations that a db has not yet seen will be run against it
upon startup, this should be seamless to the user whether they had a db that
had 0 migrations run on it before or N. this means users will not have to
explicitly run any migrations on their dbs nor see any errors when we upgrade
the db (so long as things go well). if migrations do not go so well, users
will have to manually repair dbs (this is the intention of the `migrate`
library and it seems sane), this should be rare, and I'm unsure myself how
best to resolve not having gone through this myself, I would assume it will
require running down migrations and then manually updating the migration
field; in any case, docs once one of us has to go through this.

migrations are written to files and checked into version control, and then use
go-bindata to generate those files into go code and compiled in to be consumed
by the migrate library (so that we don't have to put migration files on any
servers) -- this is also in vcs. this seems to work ok. I don't like having to
use the separate go-bindata tool but it wasn't really hard to install and then
go generate takes care of the args. adding migrations should be relatively
rare anyway, but tried to make it pretty painless.

1 migration to add created_at to the route is done here as an example of how
to do migrations, as well as testing these things ;) -- `created_at` will be
`0001-01-01T00:00:00.000Z` for any existing routes after a user runs this
version. could spend the extra time adding 'today's date to any outstanding
records, but that's not really accurate, the main thing is nobody will have to
nuke their db with the migrations in place & we don't have any prod clusters
really to worry about. all future routes will correctly have `created_at` set,
and plan to add other timestamps but wanted to keep this patch as small as
possible so only did routes.created_at.

there are tests that a spankin new db will work as expected as well as a db
after running all down & up migrations works. the latter tests only run on mysql
and postgres, since sqlite3 does not like ALTER TABLE DROP COLUMN; up
migrations will need to be tested manually for sqlite3 only, but in theory if
they are simple and work on postgres and mysql, there is a good likelihood of
success; the new migration from this patch works on sqlite3 fine.

for now, we need to use `github.com/rdallman/migrate` to move forward, as
getting integrated into upstream is proving difficult due to
`github.com/go-sql-driver/mysql` being broken on master (yay dependencies).
Fortunately for us, we vendor a version of the `mysql` bindings that actually
works, thus, we are capable of using the `mattes/migrate` library with success
due to that. this also will require go1.9 to use the new `database/sql.Conn`
type, CI has been updated accordingly.

some doc fixes too from testing.. and of course updated all deps.

anyway, whew. this should let us add fields to the db without busting
everybody's dbs. open to feedback on better ways, but this was overall pretty
simple despite futzing with mysql.

* add migrate pkg to deps, update deps

use rdallman/migrate until we resolve in mattes land

* add README in migrations package

* add ref to mattes lib

vendor/github.com/rdallman/migrate/cli/README.md

@@ -0,0 +1,113 @@
+# migrate CLI
+
+## Installation
+
+#### With Go toolchain
+
+```
+$ go get -u -d github.com/mattes/migrate/cli github.com/lib/pq
+$ go build -tags 'postgres' -o /usr/local/bin/migrate github.com/mattes/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
+
+([todo #156](https://github.com/mattes/migrate/issues/156))
+
+```
+$ brew install migrate --with-postgres
+```
+
+#### Linux (*.deb package)
+
+```
+$ curl -L https://packagecloud.io/mattes/migrate/gpgkey | apt-key add -
+$ echo "deb https://packagecloud.io/mattes/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/mattes/migrate/releases)
+
+```
+$ curl -L https://github.com/mattes/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"]')"
+```

vendor/github.com/rdallman/migrate/cli/build_aws-s3.go

@@ -0,0 +1,7 @@
+// +build aws-s3
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/source/aws-s3"
+)

vendor/github.com/rdallman/migrate/cli/build_cassandra.go

@@ -0,0 +1,7 @@
+// +build cassandra
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/cassandra"
+)

vendor/github.com/rdallman/migrate/cli/build_clickhouse.go

@@ -0,0 +1,8 @@
+// +build clickhouse
+
+package main
+
+import (
+	_ "github.com/kshvakov/clickhouse"
+	_ "github.com/mattes/migrate/database/clickhouse"
+)

vendor/github.com/rdallman/migrate/cli/build_cockroachdb.go

@@ -0,0 +1,7 @@
+// +build cockroachdb
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/cockroachdb"
+)

vendor/github.com/rdallman/migrate/cli/build_github.go

@@ -0,0 +1,7 @@
+// +build github
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/source/github"
+)

vendor/github.com/rdallman/migrate/cli/build_go-bindata.go

@@ -0,0 +1,7 @@
+// +build go-bindata
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/source/go-bindata"
+)

vendor/github.com/rdallman/migrate/cli/build_google-cloud-storage.go

@@ -0,0 +1,7 @@
+// +build google-cloud-storage
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/source/google-cloud-storage"
+)

vendor/github.com/rdallman/migrate/cli/build_mysql.go

@@ -0,0 +1,7 @@
+// +build mysql
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/mysql"
+)

vendor/github.com/rdallman/migrate/cli/build_postgres.go

@@ -0,0 +1,7 @@
+// +build postgres
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/postgres"
+)

vendor/github.com/rdallman/migrate/cli/build_ql.go

@@ -0,0 +1,7 @@
+// +build ql
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/ql"
+)

vendor/github.com/rdallman/migrate/cli/build_redshift.go

@@ -0,0 +1,7 @@
+// +build redshift
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/redshift"
+)

vendor/github.com/rdallman/migrate/cli/build_spanner.go

@@ -0,0 +1,7 @@
+// +build spanner
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/spanner"
+)

vendor/github.com/rdallman/migrate/cli/build_sqlite3.go

@@ -0,0 +1,7 @@
+// +build sqlite3
+
+package main
+
+import (
+	_ "github.com/mattes/migrate/database/sqlite3"
+)

vendor/github.com/rdallman/migrate/cli/commands.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"github.com/mattes/migrate"
+	_ "github.com/mattes/migrate/database/stub" // TODO remove again
+	_ "github.com/mattes/migrate/source/file"
+	"os"
+	"fmt"
+)
+
+func createCmd(dir string, timestamp int64, name string, ext string) {
+	base := fmt.Sprintf("%v%v_%v.", dir, timestamp, 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)
+	}
+}

vendor/github.com/rdallman/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/mattes/migrate/gpgkey | apt-key add - && \
+    echo "deb https://packagecloud.io/mattes/migrate/ubuntu/ xenial main" > /etc/apt/sources.list.d/migrate.list && \
+    apt-get update && \
+    apt-get install -y migrate
+
+RUN migrate -version
+

vendor/github.com/rdallman/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)
+}

vendor/github.com/rdallman/migrate/cli/main.go

@@ -0,0 +1,237 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/mattes/migrate"
+)
+
+// 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] 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
+`)
+	}
+
+	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:]
+
+		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)")
+		createFlagSet.Parse(args)
+
+		if createFlagSet.NArg() == 0 {
+			log.fatal("error: please specify name")
+		}
+		name := createFlagSet.Arg(0)
+
+		if *extPtr != "" {
+			*extPtr = "." + strings.TrimPrefix(*extPtr, ".")
+		}
+		if *dirPtr != "" {
+			*dirPtr = strings.Trim(*dirPtr, "/") + "/"
+		}
+
+		timestamp := startTime.Unix()
+
+		createCmd(*dirPtr, timestamp, name, *extPtr)
+
+	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)
+	}
+}

vendor/github.com/rdallman/migrate/cli/version.go

@@ -0,0 +1,4 @@
+package main
+
+// Version is set in Makefile with build flags
+var Version = "dev"