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/source/driver.go

@@ -87,7 +87,7 @@ func Open(url string) (Driver, error) {
 	d, ok := drivers[u.Scheme]
 	driversMu.RUnlock()
 	if !ok {
-		return nil, fmt.Errorf("source driver: unknown driver %v (forgotten import?)", u.Scheme)
+		return nil, fmt.Errorf("source driver: unknown driver '%s' (forgotten import?)", u.Scheme)
 	}
 
 	return d.Open(url)

vendor/github.com/golang-migrate/migrate/v4/source/errors.go

@@ -0,0 +1,15 @@
+package source
+
+import "os"
+
+// ErrDuplicateMigration is an error type for reporting duplicate migration
+// files.
+type ErrDuplicateMigration struct {
+	Migration
+	os.FileInfo
+}
+
+// Error implements error interface.
+func (e ErrDuplicateMigration) Error() string {
+	return "duplicate migration file: " + e.Name()
+}

vendor/github.com/golang-migrate/migrate/v4/source/file/file.go

@@ -1,12 +1,8 @@
 package file
 
 import (
-	"fmt"
-	"io"
-	"io/ioutil"
 	nurl "net/url"
 	"os"
-	"path"
 	"path/filepath"
 
 	"github.com/golang-migrate/migrate/v4/source"
@@ -16,18 +12,11 @@ func init() {
 	source.Register("file", &File{})
 }
 
-type File struct {
-	url        string
-	path       string
-	migrations *source.Migrations
-}
-
-func (f *File) Open(url string) (source.Driver, error) {
+func parseURL(url string) (string, error) {
 	u, err := nurl.Parse(url)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
-
 	// concat host and path to restore full path
 	// host might be `.`
 	p := u.Opaque
@@ -39,7 +28,7 @@ func (f *File) Open(url string) (source.Driver, error) {
 		// default to current directory if no path
 		wd, err := os.Getwd()
 		if err != nil {
-			return nil, err
+			return "", err
 		}
 		p = wd
 
@@ -47,81 +36,9 @@ func (f *File) Open(url string) (source.Driver, error) {
 		// make path absolute if relative
 		abs, err := filepath.Abs(p)
 		if err != nil {
-			return nil, err
+			return "", err
 		}
 		p = abs
 	}
-
-	// scan directory
-	files, err := ioutil.ReadDir(p)
-	if err != nil {
-		return nil, err
-	}
-
-	nf := &File{
-		url:        url,
-		path:       p,
-		migrations: source.NewMigrations(),
-	}
-
-	for _, fi := range files {
-		if !fi.IsDir() {
-			m, err := source.DefaultParse(fi.Name())
-			if err != nil {
-				continue // ignore files that we can't parse
-			}
-			if !nf.migrations.Append(m) {
-				return nil, fmt.Errorf("unable to parse file %v", fi.Name())
-			}
-		}
-	}
-	return nf, nil
-}
-
-func (f *File) Close() error {
-	// nothing do to here
-	return nil
-}
-
-func (f *File) First() (version uint, err error) {
-	if v, ok := f.migrations.First(); ok {
-		return v, nil
-	}
-	return 0, &os.PathError{Op: "first", Path: f.path, Err: os.ErrNotExist}
-}
-
-func (f *File) Prev(version uint) (prevVersion uint, err error) {
-	if v, ok := f.migrations.Prev(version); ok {
-		return v, nil
-	}
-	return 0, &os.PathError{Op: fmt.Sprintf("prev for version %v", version), Path: f.path, Err: os.ErrNotExist}
-}
-
-func (f *File) Next(version uint) (nextVersion uint, err error) {
-	if v, ok := f.migrations.Next(version); ok {
-		return v, nil
-	}
-	return 0, &os.PathError{Op: fmt.Sprintf("next for version %v", version), Path: f.path, Err: os.ErrNotExist}
-}
-
-func (f *File) ReadUp(version uint) (r io.ReadCloser, identifier string, err error) {
-	if m, ok := f.migrations.Up(version); ok {
-		r, err := os.Open(path.Join(f.path, m.Raw))
-		if err != nil {
-			return nil, "", err
-		}
-		return r, m.Identifier, nil
-	}
-	return nil, "", &os.PathError{Op: fmt.Sprintf("read version %v", version), Path: f.path, Err: os.ErrNotExist}
-}
-
-func (f *File) ReadDown(version uint) (r io.ReadCloser, identifier string, err error) {
-	if m, ok := f.migrations.Down(version); ok {
-		r, err := os.Open(path.Join(f.path, m.Raw))
-		if err != nil {
-			return nil, "", err
-		}
-		return r, m.Identifier, nil
-	}
-	return nil, "", &os.PathError{Op: fmt.Sprintf("read version %v", version), Path: f.path, Err: os.ErrNotExist}
+	return p, nil
 }

vendor/github.com/golang-migrate/migrate/v4/source/file/file_go115.go

@@ -0,0 +1,32 @@
+// +build !go1.16
+
+package file
+
+import (
+	"net/http"
+
+	"github.com/golang-migrate/migrate/v4/source"
+	"github.com/golang-migrate/migrate/v4/source/httpfs"
+)
+
+type File struct {
+	httpfs.PartialDriver
+	url  string
+	path string
+}
+
+func (f *File) Open(url string) (source.Driver, error) {
+	p, err := parseURL(url)
+	if err != nil {
+		return nil, err
+	}
+
+	nf := &File{
+		url:  url,
+		path: p,
+	}
+	if err := nf.Init(http.Dir(p), ""); err != nil {
+		return nil, err
+	}
+	return nf, nil
+}

vendor/github.com/golang-migrate/migrate/v4/source/file/file_go116.go

@@ -0,0 +1,31 @@
+// +build go1.16
+
+package file
+
+import (
+	"os"
+
+	"github.com/golang-migrate/migrate/v4/source"
+	"github.com/golang-migrate/migrate/v4/source/iofs"
+)
+
+type File struct {
+	iofs.PartialDriver
+	url  string
+	path string
+}
+
+func (f *File) Open(url string) (source.Driver, error) {
+	p, err := parseURL(url)
+	if err != nil {
+		return nil, err
+	}
+	nf := &File{
+		url:  url,
+		path: p,
+	}
+	if err := nf.Init(os.DirFS(p), "."); err != nil {
+		return nil, err
+	}
+	return nf, nil
+}

vendor/github.com/golang-migrate/migrate/v4/source/httpfs/README.md

@@ -0,0 +1,49 @@
+# httpfs
+
+## Usage
+
+This package could be used to create new migration source drivers that uses
+`http.FileSystem` to read migration files.
+
+Struct `httpfs.PartialDriver` partly implements the `source.Driver` interface. It has all
+the methods except for `Open()`. Embedding this struct and adding `Open()` method
+allows users of this package to create new migration sources. Example:
+
+```go
+struct mydriver {
+        httpfs.PartialDriver
+}
+
+func (d *mydriver) Open(url string) (source.Driver, error) {
+	var fs http.FileSystem
+	var path string
+	var ds mydriver
+
+	// acquire fs and path from url
+	// set-up ds if necessary
+
+	if err := ds.Init(fs, path); err != nil {
+		return nil, err
+	}
+	return &ds, nil
+}
+```
+
+This package also provides a simple `source.Driver` implementation that works
+with `http.FileSystem` provided by the user of this package. It is created with
+`httpfs.New()` call.
+
+Example of using `http.Dir()` to read migrations from `sql` directory:
+
+```go
+	src, err := httpfs.New(http.Dir("sql"))
+	if err != nil {
+		// do something
+	}
+	m, err := migrate.NewWithSourceInstance("httpfs", src, "database://url")
+	if err != nil {
+		// do something
+	}
+        err = m.Up()
+	...
+```

vendor/github.com/golang-migrate/migrate/v4/source/httpfs/driver.go

@@ -0,0 +1,31 @@
+package httpfs
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/golang-migrate/migrate/v4/source"
+)
+
+// driver is a migration source driver for reading migrations from
+// http.FileSystem instances. It implements source.Driver interface and can be
+// used as a migration source for the main migrate library.
+type driver struct {
+	PartialDriver
+}
+
+// New creates a new migrate source driver from a http.FileSystem instance and a
+// relative path to migration files within the virtual FS.
+func New(fs http.FileSystem, path string) (source.Driver, error) {
+	var d driver
+	if err := d.Init(fs, path); err != nil {
+		return nil, err
+	}
+	return &d, nil
+}
+
+// Open completes the implementetion of source.Driver interface. Other methods
+// are implemented by the embedded PartialDriver struct.
+func (d *driver) Open(url string) (source.Driver, error) {
+	return nil, errors.New("Open() cannot be called on the httpfs passthrough driver")
+}

vendor/github.com/golang-migrate/migrate/v4/source/httpfs/partial_driver.go

@@ -0,0 +1,156 @@
+package httpfs
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"strconv"
+
+	"github.com/golang-migrate/migrate/v4/source"
+)
+
+// PartialDriver is a helper service for creating new source drivers working with
+// http.FileSystem instances. It implements all source.Driver interface methods
+// except for Open(). New driver could embed this struct and add missing Open()
+// method.
+//
+// To prepare PartialDriver for use Init() function.
+type PartialDriver struct {
+	migrations *source.Migrations
+	fs         http.FileSystem
+	path       string
+}
+
+// Init prepares not initialized PartialDriver instance to read migrations from a
+// http.FileSystem instance and a relative path.
+func (p *PartialDriver) Init(fs http.FileSystem, path string) error {
+	root, err := fs.Open(path)
+	if err != nil {
+		return err
+	}
+
+	files, err := root.Readdir(0)
+	if err != nil {
+		_ = root.Close()
+		return err
+	}
+	if err = root.Close(); err != nil {
+		return err
+	}
+
+	ms := source.NewMigrations()
+	for _, file := range files {
+		if file.IsDir() {
+			continue
+		}
+
+		m, err := source.DefaultParse(file.Name())
+		if err != nil {
+			continue // ignore files that we can't parse
+		}
+
+		if !ms.Append(m) {
+			return source.ErrDuplicateMigration{
+				Migration: *m,
+				FileInfo:  file,
+			}
+		}
+	}
+
+	p.fs = fs
+	p.path = path
+	p.migrations = ms
+	return nil
+}
+
+// Close is part of source.Driver interface implementation. This is a no-op.
+func (p *PartialDriver) Close() error {
+	return nil
+}
+
+// First is part of source.Driver interface implementation.
+func (p *PartialDriver) First() (version uint, err error) {
+	if version, ok := p.migrations.First(); ok {
+		return version, nil
+	}
+	return 0, &os.PathError{
+		Op:   "first",
+		Path: p.path,
+		Err:  os.ErrNotExist,
+	}
+}
+
+// Prev is part of source.Driver interface implementation.
+func (p *PartialDriver) Prev(version uint) (prevVersion uint, err error) {
+	if version, ok := p.migrations.Prev(version); ok {
+		return version, nil
+	}
+	return 0, &os.PathError{
+		Op:   "prev for version " + strconv.FormatUint(uint64(version), 10),
+		Path: p.path,
+		Err:  os.ErrNotExist,
+	}
+}
+
+// Next is part of source.Driver interface implementation.
+func (p *PartialDriver) Next(version uint) (nextVersion uint, err error) {
+	if version, ok := p.migrations.Next(version); ok {
+		return version, nil
+	}
+	return 0, &os.PathError{
+		Op:   "next for version " + strconv.FormatUint(uint64(version), 10),
+		Path: p.path,
+		Err:  os.ErrNotExist,
+	}
+}
+
+// ReadUp is part of source.Driver interface implementation.
+func (p *PartialDriver) ReadUp(version uint) (r io.ReadCloser, identifier string, err error) {
+	if m, ok := p.migrations.Up(version); ok {
+		body, err := p.open(path.Join(p.path, m.Raw))
+		if err != nil {
+			return nil, "", err
+		}
+		return body, m.Identifier, nil
+	}
+	return nil, "", &os.PathError{
+		Op:   "read up for version " + strconv.FormatUint(uint64(version), 10),
+		Path: p.path,
+		Err:  os.ErrNotExist,
+	}
+}
+
+// ReadDown is part of source.Driver interface implementation.
+func (p *PartialDriver) ReadDown(version uint) (r io.ReadCloser, identifier string, err error) {
+	if m, ok := p.migrations.Down(version); ok {
+		body, err := p.open(path.Join(p.path, m.Raw))
+		if err != nil {
+			return nil, "", err
+		}
+		return body, m.Identifier, nil
+	}
+	return nil, "", &os.PathError{
+		Op:   "read down for version " + strconv.FormatUint(uint64(version), 10),
+		Path: p.path,
+		Err:  os.ErrNotExist,
+	}
+}
+
+func (p *PartialDriver) open(path string) (http.File, error) {
+	f, err := p.fs.Open(path)
+	if err == nil {
+		return f, nil
+	}
+	// Some non-standard file systems may return errors that don't include the path, that
+	// makes debugging harder.
+	if !errors.As(err, new(*os.PathError)) {
+		err = &os.PathError{
+			Op:   "open",
+			Path: path,
+			Err:  err,
+		}
+	}
+	return nil, err
+}

vendor/github.com/golang-migrate/migrate/v4/source/iofs/README.md

@@ -0,0 +1,3 @@
+# iofs
+
+https://pkg.go.dev/github.com/golang-migrate/migrate/v4/source/iofs

vendor/github.com/golang-migrate/migrate/v4/source/iofs/doc.go

@@ -0,0 +1,10 @@
+/*
+Package iofs provides the Go 1.16+ io/fs#FS driver.
+
+It can accept various file systems (like embed.FS, archive/zip#Reader) implementing io/fs#FS.
+
+This driver cannot be used with Go versions 1.15 and below.
+
+Also, Opening with a URL scheme is not supported.
+*/
+package iofs

vendor/github.com/golang-migrate/migrate/v4/source/iofs/iofs.go

@@ -0,0 +1,175 @@
+// +build go1.16
+
+package iofs
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"path"
+	"strconv"
+
+	"github.com/golang-migrate/migrate/v4/source"
+)
+
+type driver struct {
+	PartialDriver
+}
+
+// New returns a new Driver from io/fs#FS and a relative path.
+func New(fsys fs.FS, path string) (source.Driver, error) {
+	var i driver
+	if err := i.Init(fsys, path); err != nil {
+		return nil, fmt.Errorf("failed to init driver with path %s: %w", path, err)
+	}
+	return &i, nil
+}
+
+// Open is part of source.Driver interface implementation.
+// Open cannot be called on the iofs passthrough driver.
+func (d *driver) Open(url string) (source.Driver, error) {
+	return nil, errors.New("Open() cannot be called on the iofs passthrough driver")
+}
+
+// PartialDriver is a helper service for creating new source drivers working with
+// io/fs.FS instances. It implements all source.Driver interface methods
+// except for Open(). New driver could embed this struct and add missing Open()
+// method.
+//
+// To prepare PartialDriver for use Init() function.
+type PartialDriver struct {
+	migrations *source.Migrations
+	fsys       fs.FS
+	path       string
+}
+
+// Init prepares not initialized IoFS instance to read migrations from a
+// io/fs#FS instance and a relative path.
+func (d *PartialDriver) Init(fsys fs.FS, path string) error {
+	entries, err := fs.ReadDir(fsys, path)
+	if err != nil {
+		return err
+	}
+
+	ms := source.NewMigrations()
+	for _, e := range entries {
+		if e.IsDir() {
+			continue
+		}
+		m, err := source.DefaultParse(e.Name())
+		if err != nil {
+			continue
+		}
+		file, err := e.Info()
+		if err != nil {
+			return err
+		}
+		if !ms.Append(m) {
+			return source.ErrDuplicateMigration{
+				Migration: *m,
+				FileInfo:  file,
+			}
+		}
+	}
+
+	d.fsys = fsys
+	d.path = path
+	d.migrations = ms
+	return nil
+}
+
+// Close is part of source.Driver interface implementation.
+// Closes the file system if possible.
+func (d *PartialDriver) Close() error {
+	c, ok := d.fsys.(io.Closer)
+	if !ok {
+		return nil
+	}
+	return c.Close()
+}
+
+// First is part of source.Driver interface implementation.
+func (d *PartialDriver) First() (version uint, err error) {
+	if version, ok := d.migrations.First(); ok {
+		return version, nil
+	}
+	return 0, &fs.PathError{
+		Op:   "first",
+		Path: d.path,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+// Prev is part of source.Driver interface implementation.
+func (d *PartialDriver) Prev(version uint) (prevVersion uint, err error) {
+	if version, ok := d.migrations.Prev(version); ok {
+		return version, nil
+	}
+	return 0, &fs.PathError{
+		Op:   "prev for version " + strconv.FormatUint(uint64(version), 10),
+		Path: d.path,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+// Next is part of source.Driver interface implementation.
+func (d *PartialDriver) Next(version uint) (nextVersion uint, err error) {
+	if version, ok := d.migrations.Next(version); ok {
+		return version, nil
+	}
+	return 0, &fs.PathError{
+		Op:   "next for version " + strconv.FormatUint(uint64(version), 10),
+		Path: d.path,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+// ReadUp is part of source.Driver interface implementation.
+func (d *PartialDriver) ReadUp(version uint) (r io.ReadCloser, identifier string, err error) {
+	if m, ok := d.migrations.Up(version); ok {
+		body, err := d.open(path.Join(d.path, m.Raw))
+		if err != nil {
+			return nil, "", err
+		}
+		return body, m.Identifier, nil
+	}
+	return nil, "", &fs.PathError{
+		Op:   "read up for version " + strconv.FormatUint(uint64(version), 10),
+		Path: d.path,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+// ReadDown is part of source.Driver interface implementation.
+func (d *PartialDriver) ReadDown(version uint) (r io.ReadCloser, identifier string, err error) {
+	if m, ok := d.migrations.Down(version); ok {
+		body, err := d.open(path.Join(d.path, m.Raw))
+		if err != nil {
+			return nil, "", err
+		}
+		return body, m.Identifier, nil
+	}
+	return nil, "", &fs.PathError{
+		Op:   "read down for version " + strconv.FormatUint(uint64(version), 10),
+		Path: d.path,
+		Err:  fs.ErrNotExist,
+	}
+}
+
+func (d *PartialDriver) open(path string) (fs.File, error) {
+	f, err := d.fsys.Open(path)
+	if err == nil {
+		return f, nil
+	}
+	// Some non-standard file systems may return errors that don't include the path, that
+	// makes debugging harder.
+	if !errors.As(err, new(*fs.PathError)) {
+		err = &fs.PathError{
+			Op:   "open",
+			Path: path,
+			Err:  err,
+		}
+	}
+	return nil, err
+}

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/1_foobar.down.sql

@@ -0,0 +1 @@
+1 down

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/1_foobar.up.sql

@@ -0,0 +1 @@
+1 up

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/3_foobar.up.sql

@@ -0,0 +1 @@
+3 up

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/4_foobar.down.sql

@@ -0,0 +1 @@
+4 down

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/4_foobar.up.sql

@@ -0,0 +1 @@
+4 up

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/5_foobar.down.sql

@@ -0,0 +1 @@
+5 down

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/7_foobar.down.sql

@@ -0,0 +1 @@
+7 down

vendor/github.com/golang-migrate/migrate/v4/source/iofs/testdata/migrations/7_foobar.up.sql

@@ -0,0 +1 @@
+7 up