Replace packr with go embed (#1751)

* Embed performer images
* Embed schema migrations
* Update dependencies
* Embed UI
* Remove remaining packr references

vendor/github.com/golang-migrate/migrate/v4/database/driver.go

@@ -7,12 +7,14 @@ package database
 import (
 	"fmt"
 	"io"
-	nurl "net/url"
 	"sync"
+
+	iurl "github.com/golang-migrate/migrate/v4/internal/url"
 )
 
 var (
-	ErrLocked = fmt.Errorf("can't acquire lock")
+	ErrLocked    = fmt.Errorf("can't acquire lock")
+	ErrNotLocked = fmt.Errorf("can't unlock, as not currently locked")
 )
 
 const NilVersion int = -1
@@ -32,7 +34,7 @@ var drivers = make(map[string]Driver)
 //      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
+//   6. Create a internal/cli/build_<driver-name>.go file
 //   7. Add driver name in 'DATABASE' variable in Makefile
 //
 // Guidelines:
@@ -60,7 +62,7 @@ type Driver interface {
 	// all migrations have been run.
 	Unlock() error
 
-	// Run applies a migration to the database. migration is garantueed to be not nil.
+	// Run applies a migration to the database. migration is guaranteed to be not nil.
 	Run(migration io.Reader) error
 
 	// SetVersion saves version and dirty state.
@@ -81,21 +83,16 @@ type Driver interface {
 
 // Open returns a new driver instance.
 func Open(url string) (Driver, error) {
-	u, err := nurl.Parse(url)
+	scheme, err := iurl.SchemeFromURL(url)
 	if err != nil {
-		return nil, fmt.Errorf("Unable to parse URL. Did you escape all reserved URL characters? "+
-			"See: https://github.com/golang-migrate/migrate#database-urls Error: %v", err)
-	}
-
-	if u.Scheme == "" {
-		return nil, fmt.Errorf("database driver: invalid URL scheme")
+		return nil, err
 	}
 
 	driversMu.RLock()
-	d, ok := drivers[u.Scheme]
+	d, ok := drivers[scheme]
 	driversMu.RUnlock()
 	if !ok {
-		return nil, fmt.Errorf("database driver: unknown driver %v (forgotten import?)", u.Scheme)
+		return nil, fmt.Errorf("database driver: unknown driver %v (forgotten import?)", scheme)
 	}
 
 	return d.Open(url)

vendor/github.com/golang-migrate/migrate/v4/database/sqlite3/README.md

@@ -0,0 +1,16 @@
+# sqlite3
+
+`sqlite3://path/to/database?query`
+
+Unlike other migrate database drivers, the sqlite3 driver will automatically wrap each migration in an implicit transaction by default.  Migrations must not contain explicit `BEGIN` or `COMMIT` statements.  This behavior may change in a future major release.  (See below for a workaround.)
+
+Refer to [upstream documentation](https://github.com/mattn/go-sqlite3/blob/master/README.md#connection-string) for a complete list of query parameters supported by the sqlite3 database driver.  The auxiliary query parameters listed below may be supplied to tailor migrate behavior.  All auxiliary query parameters are optional.
+
+| URL Query  | WithInstance Config | Description |
+|------------|---------------------|-------------|
+| `x-migrations-table` | `MigrationsTable` | Name of the migrations table.  Defaults to `schema_migrations`. |
+| `x-no-tx-wrap` | `NoTxWrap` | Disable implicit transactions when `true`.  Migrations may, and should, contain explicit `BEGIN` and `COMMIT` statements. |
+
+## Notes
+
+* Uses the `github.com/mattn/go-sqlite3` sqlite db driver (cgo)

vendor/github.com/golang-migrate/migrate/v4/database/sqlite3/sqlite3.go

@@ -3,9 +3,11 @@ package sqlite3
 import (
 	"database/sql"
 	"fmt"
+	"go.uber.org/atomic"
 	"io"
 	"io/ioutil"
 	nurl "net/url"
+	"strconv"
 	"strings"
 
 	"github.com/golang-migrate/migrate/v4"
@@ -28,11 +30,12 @@ var (
 type Config struct {
 	MigrationsTable string
 	DatabaseName    string
+	NoTxWrap        bool
 }
 
 type Sqlite struct {
 	db       *sql.DB
-	isLocked bool
+	isLocked atomic.Bool
 
 	config *Config
 }
@@ -100,13 +103,25 @@ func (m *Sqlite) Open(url string) (database.Driver, error) {
 		return nil, err
 	}
 
-	migrationsTable := purl.Query().Get("x-migrations-table")
+	qv := purl.Query()
+
+	migrationsTable := qv.Get("x-migrations-table")
 	if len(migrationsTable) == 0 {
 		migrationsTable = DefaultMigrationsTable
 	}
+
+	noTxWrap := false
+	if v := qv.Get("x-no-tx-wrap"); v != "" {
+		noTxWrap, err = strconv.ParseBool(v)
+		if err != nil {
+			return nil, fmt.Errorf("x-no-tx-wrap: %s", err)
+		}
+	}
+
 	mx, err := WithInstance(db, &Config{
 		DatabaseName:    purl.Path,
 		MigrationsTable: migrationsTable,
+		NoTxWrap:        noTxWrap,
 	})
 	if err != nil {
 		return nil, err
@@ -129,6 +144,7 @@ func (m *Sqlite) Drop() (err error) {
 			err = multierror.Append(err, errClose)
 		}
 	}()
+
 	tableNames := make([]string, 0)
 	for tables.Next() {
 		var tableName string
@@ -139,6 +155,10 @@ func (m *Sqlite) Drop() (err error) {
 			tableNames = append(tableNames, tableName)
 		}
 	}
+	if err := tables.Err(); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+
 	if len(tableNames) > 0 {
 		for _, t := range tableNames {
 			query := "DROP TABLE " + t
@@ -158,18 +178,16 @@ func (m *Sqlite) Drop() (err error) {
 }
 
 func (m *Sqlite) Lock() error {
-	if m.isLocked {
+	if !m.isLocked.CAS(false, true) {
 		return database.ErrLocked
 	}
-	m.isLocked = true
 	return nil
 }
 
 func (m *Sqlite) Unlock() error {
-	if !m.isLocked {
-		return nil
+	if !m.isLocked.CAS(true, false) {
+		return database.ErrNotLocked
 	}
-	m.isLocked = false
 	return nil
 }
 
@@ -180,6 +198,9 @@ func (m *Sqlite) Run(migration io.Reader) error {
 	}
 	query := string(migr[:])
 
+	if m.config.NoTxWrap {
+		return m.executeQueryNoTx(query)
+	}
 	return m.executeQuery(query)
 }
 
@@ -200,6 +221,13 @@ func (m *Sqlite) executeQuery(query string) error {
 	return nil
 }
 
+func (m *Sqlite) executeQueryNoTx(query string) error {
+	if _, err := m.db.Exec(query); err != nil {
+		return &database.Error{OrigErr: err, Query: []byte(query)}
+	}
+	return nil
+}
+
 func (m *Sqlite) SetVersion(version int, dirty bool) error {
 	tx, err := m.db.Begin()
 	if err != nil {
@@ -211,9 +239,12 @@ func (m *Sqlite) SetVersion(version int, dirty bool) error {
 		return &database.Error{OrigErr: err, Query: []byte(query)}
 	}
 
-	if version >= 0 {
-		query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (%d, '%t')`, m.config.MigrationsTable, version, dirty)
-		if _, err := tx.Exec(query); err != nil {
+	// Also re-write the schema version for nil dirty versions to prevent
+	// empty schema version for failed down migration on the first migration
+	// See: https://github.com/golang-migrate/migrate/issues/330
+	if version >= 0 || (version == database.NilVersion && dirty) {
+		query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, m.config.MigrationsTable)
+		if _, err := tx.Exec(query, version, dirty); err != nil {
 			if errRollback := tx.Rollback(); errRollback != nil {
 				err = multierror.Append(err, errRollback)
 			}

vendor/github.com/golang-migrate/migrate/v4/database/util.go

@@ -2,6 +2,7 @@ package database
 
 import (
 	"fmt"
+	"go.uber.org/atomic"
 	"hash/crc32"
 	"strings"
 )
@@ -17,3 +18,16 @@ func GenerateAdvisoryLockId(databaseName string, additionalNames ...string) (str
 	sum = sum * uint32(advisoryLockIDSalt)
 	return fmt.Sprint(sum), nil
 }
+
+// CasRestoreOnErr CAS wrapper to automatically restore the lock state on error
+func CasRestoreOnErr(lock *atomic.Bool, o, n bool, casErr error, f func() error) error {
+	if !lock.CAS(o, n) {
+		return casErr
+	}
+	if err := f(); err != nil {
+		// Automatically unlock/lock on error
+		lock.Store(o)
+		return err
+	}
+	return nil
+}