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

api/datastore/sql/sql.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/fnproject/fn/api/datastore/sql/migrations"
 	"github.com/fnproject/fn/api/models"
 	"github.com/go-sql-driver/mysql"
 	_ "github.com/go-sql-driver/mysql"
@@ -21,6 +22,12 @@ import (
 	_ "github.com/lib/pq"
 	"github.com/mattn/go-sqlite3"
 	_ "github.com/mattn/go-sqlite3"
+	"github.com/rdallman/migrate"
+	_ "github.com/rdallman/migrate/database/mysql"
+	_ "github.com/rdallman/migrate/database/postgres"
+	_ "github.com/rdallman/migrate/database/sqlite3"
+	"github.com/rdallman/migrate/source"
+	"github.com/rdallman/migrate/source/go-bindata"
 	"github.com/sirupsen/logrus"
 )
 
@@ -41,6 +48,7 @@ var tables = [...]string{`CREATE TABLE IF NOT EXISTS routes (
 	type varchar(16) NOT NULL,
 	headers text NOT NULL,
 	config text NOT NULL,
+	created_at text,
 	PRIMARY KEY (app_name, path)
 );`,
 
@@ -68,7 +76,7 @@ var tables = [...]string{`CREATE TABLE IF NOT EXISTS routes (
 }
 
 const (
-	routeSelector = `SELECT app_name, path, image, format, memory, type, timeout, idle_timeout, headers, config FROM routes`
+	routeSelector = `SELECT app_name, path, image, format, memory, type, timeout, idle_timeout, headers, config, created_at FROM routes`
 	callSelector  = `SELECT id, created_at, started_at, completed_at, status, app_name, path FROM calls`
 )
 
@@ -79,11 +87,16 @@ type sqlStore struct {
 // New will open the db specified by url, create any tables necessary
 // and return a models.Datastore safe for concurrent usage.
 func New(url *url.URL) (models.Datastore, error) {
+	return newDS(url)
+}
+
+// for test methods, return concrete type, but don't expose
+func newDS(url *url.URL) (*sqlStore, error) {
 	driver := url.Scheme
 
 	// driver must be one of these for sqlx to work, double check:
 	switch driver {
-	case "postgres", "pgx", "mysql", "sqlite3", "oci8", "ora", "goracle":
+	case "postgres", "pgx", "mysql", "sqlite3":
 	default:
 		return nil, errors.New("invalid db driver, refer to the code")
 	}
@@ -121,6 +134,12 @@ func New(url *url.URL) (models.Datastore, error) {
 	db.SetMaxIdleConns(maxIdleConns)
 	logrus.WithFields(logrus.Fields{"max_idle_connections": maxIdleConns, "datastore": driver}).Info("datastore dialed")
 
+	err = runMigrations(url.String(), checkExistence(db)) // original url string
+	if err != nil {
+		logrus.WithError(err).Error("error running migrations")
+		return nil, err
+	}
+
 	switch driver {
 	case "sqlite3":
 		db.SetMaxOpenConns(1)
@@ -135,6 +154,104 @@ func New(url *url.URL) (models.Datastore, error) {
 	return &sqlStore{db: db}, nil
 }
 
+// checkExistence checks if tables have been created yet, it is not concerned
+// about the existence of the schema migration version (since migrations were
+// added to existing dbs, we need to know whether the db exists without migrations
+// or if it's brand new).
+func checkExistence(db *sqlx.DB) bool {
+	query := db.Rebind(`SELECT name FROM apps LIMIT 1`)
+	row := db.QueryRow(query)
+
+	var dummy string
+	err := row.Scan(&dummy)
+	if err != nil && err != sql.ErrNoRows {
+		// TODO we should probably ensure this is a certain 'no such table' error
+		// and if it's not that or err no rows, we should probably block start up.
+		// if we return false here spuriously, then migrations could be skipped,
+		// which would be bad.
+		return false
+	}
+	return true
+}
+
+// check if the db already existed, if the db is brand new then we can skip
+// over all the migrations BUT we must be sure to set the right migration
+// number so that only current migrations are skipped, not any future ones.
+func runMigrations(url string, exists bool) error {
+	m, err := migrator(url)
+	if err != nil {
+		return err
+	}
+	defer m.Close()
+
+	if !exists {
+		// set to highest and bail
+		return m.Force(latestVersion(migrations.AssetNames()))
+	}
+
+	// run any migrations needed to get to latest, if any
+	err = m.Up()
+	if err == migrate.ErrNoChange { // we don't care, but want other errors
+		err = nil
+	}
+	return err
+}
+
+func migrator(url string) (*migrate.Migrate, error) {
+	s := bindata.Resource(migrations.AssetNames(),
+		func(name string) ([]byte, error) {
+			return migrations.Asset(name)
+		})
+
+	d, err := bindata.WithInstance(s)
+	if err != nil {
+		return nil, err
+	}
+
+	return migrate.NewWithSourceInstance("go-bindata", d, url)
+}
+
+// latest version will find the latest version from a list of migration
+// names (not from the db)
+func latestVersion(migs []string) int {
+	var highest uint
+	for _, m := range migs {
+		mig, _ := source.Parse(m)
+		if mig.Version > highest {
+			highest = mig.Version
+		}
+	}
+
+	return int(highest)
+}
+
+// clear is for tests only, be careful, it deletes all records.
+func (ds *sqlStore) clear() error {
+	return ds.Tx(func(tx *sqlx.Tx) error {
+		query := tx.Rebind(`DELETE FROM routes`)
+		_, err := tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM calls`)
+		_, err = tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM apps`)
+		_, err = tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM logs`)
+		_, err = tx.Exec(query)
+		return err
+	})
+}
+
 func (ds *sqlStore) InsertApp(ctx context.Context, app *models.App) (*models.App, error) {
 	query := ds.db.Rebind("INSERT INTO apps (name, config) VALUES (:name, :config);")
 	_, err := ds.db.NamedExecContext(ctx, query, app)
@@ -298,7 +415,8 @@ func (ds *sqlStore) InsertRoute(ctx context.Context, route *models.Route) (*mode
 			timeout,
 			idle_timeout,
 			headers,
-			config
+			config,
+			created_at
 		)
 		VALUES (
 			:app_name,
@@ -310,7 +428,8 @@ func (ds *sqlStore) InsertRoute(ctx context.Context, route *models.Route) (*mode
 			:timeout,
 			:idle_timeout,
 			:headers,
-			:config
+			:config,
+			:created_at
 		);`)
 
 		_, err = tx.NamedExecContext(ctx, query, route)
@@ -348,7 +467,8 @@ func (ds *sqlStore) UpdateRoute(ctx context.Context, newroute *models.Route) (*m
 			timeout = :timeout,
 			idle_timeout = :idle_timeout,
 			headers = :headers,
-			config = :config
+			config = :config,
+			created_at = :created_at
 		WHERE app_name=:app_name AND path=:path;`)
 
 		res, err := tx.NamedExecContext(ctx, query, &route)