focalboard/server/services/store/sqlstore/migrate.go

178 lines
4.2 KiB
Go
Raw Normal View History

2020-10-16 22:27:16 +02:00
package sqlstore
import (
2021-04-17 09:06:57 +02:00
"bytes"
"database/sql"
"errors"
2021-04-17 09:06:57 +02:00
"fmt"
"io"
"io/ioutil"
"os"
2021-04-17 09:06:57 +02:00
"text/template"
mysqldriver "github.com/go-sql-driver/mysql"
2020-10-16 22:27:16 +02:00
"github.com/golang-migrate/migrate/v4"
"github.com/golang-migrate/migrate/v4/database"
"github.com/golang-migrate/migrate/v4/database/mysql"
2020-10-16 22:27:16 +02:00
"github.com/golang-migrate/migrate/v4/database/postgres"
"github.com/golang-migrate/migrate/v4/database/sqlite3"
2021-04-17 09:06:57 +02:00
"github.com/golang-migrate/migrate/v4/source"
_ "github.com/golang-migrate/migrate/v4/source/file" // fileystem driver
bindata "github.com/golang-migrate/migrate/v4/source/go_bindata"
_ "github.com/lib/pq" // postgres driver
"github.com/mattermost/focalboard/server/services/store/sqlstore/migrations"
2020-10-16 22:27:16 +02:00
)
2021-04-17 09:06:57 +02:00
type PrefixedMigration struct {
*bindata.Bindata
prefix string
postgres bool
sqlite bool
mysql bool
plugin bool
2021-04-17 09:06:57 +02:00
}
func init() {
source.Register("prefixed-migrations", &PrefixedMigration{})
}
func (pm *PrefixedMigration) executeTemplate(r io.ReadCloser, identifier string) (io.ReadCloser, string, error) {
2021-04-17 09:06:57 +02:00
data, err := ioutil.ReadAll(r)
if err != nil {
return nil, "", err
}
tmpl, err := template.New("sql").Parse(string(data))
if err != nil {
return nil, "", err
}
buffer := bytes.NewBufferString("")
params := map[string]interface{}{
"prefix": pm.prefix,
"postgres": pm.postgres,
"sqlite": pm.sqlite,
"mysql": pm.mysql,
"plugin": pm.plugin,
}
err = tmpl.Execute(buffer, params)
2021-04-17 09:06:57 +02:00
if err != nil {
return nil, "", err
}
2021-04-17 10:05:07 +02:00
return ioutil.NopCloser(bytes.NewReader(buffer.Bytes())), identifier, nil
2021-04-17 09:06:57 +02:00
}
func (pm *PrefixedMigration) ReadUp(version uint) (io.ReadCloser, string, error) {
r, identifier, err := pm.Bindata.ReadUp(version)
2021-04-17 09:06:57 +02:00
if err != nil {
return nil, "", err
}
return pm.executeTemplate(r, identifier)
}
func (pm *PrefixedMigration) ReadDown(version uint) (io.ReadCloser, string, error) {
r, identifier, err := pm.Bindata.ReadDown(version)
2021-04-17 09:06:57 +02:00
if err != nil {
return nil, "", err
}
return pm.executeTemplate(r, identifier)
2021-04-17 09:06:57 +02:00
}
func appendMultipleStatementsFlag(connectionString string) (string, error) {
config, err := mysqldriver.ParseDSN(connectionString)
if err != nil {
return "", err
}
if config.Params == nil {
config.Params = map[string]string{}
}
config.Params["multiStatements"] = "true"
return config.FormatDSN(), nil
}
// migrations in MySQL need to run with the multiStatements flag
// enabled, so this method creates a new connection ensuring that it's
// enabled.
func (s *SQLStore) getMigrationConnection() (*sql.DB, error) {
connectionString := s.connectionString
if s.dbType == mysqlDBType {
var err error
connectionString, err = appendMultipleStatementsFlag(s.connectionString)
if err != nil {
return nil, err
}
}
db, err := sql.Open(s.dbType, connectionString)
if err != nil {
return nil, err
}
if err = db.Ping(); err != nil {
return nil, err
}
return db, nil
}
2020-10-16 22:27:16 +02:00
func (s *SQLStore) Migrate() error {
var driver database.Driver
var err error
2021-04-17 09:06:57 +02:00
migrationsTable := fmt.Sprintf("%sschema_migrations", s.tablePrefix)
if s.dbType == sqliteDBType {
2021-04-17 09:06:57 +02:00
driver, err = sqlite3.WithInstance(s.db, &sqlite3.Config{MigrationsTable: migrationsTable})
2020-10-18 02:07:35 +02:00
if err != nil {
return err
}
2020-10-16 22:27:16 +02:00
}
db, err := s.getMigrationConnection()
if err != nil {
return err
}
defer db.Close()
if s.dbType == postgresDBType {
driver, err = postgres.WithInstance(db, &postgres.Config{MigrationsTable: migrationsTable})
2020-10-18 02:07:35 +02:00
if err != nil {
return err
}
}
if s.dbType == mysqlDBType {
driver, err = mysql.WithInstance(db, &mysql.Config{MigrationsTable: migrationsTable})
if err != nil {
return err
}
}
bresource := bindata.Resource(migrations.AssetNames(), migrations.Asset)
d, err := bindata.WithInstance(bresource)
if err != nil {
return err
2020-10-16 22:27:16 +02:00
}
2021-04-17 09:06:57 +02:00
prefixedData := &PrefixedMigration{
Bindata: d.(*bindata.Bindata),
prefix: s.tablePrefix,
plugin: s.isPlugin,
postgres: s.dbType == postgresDBType,
sqlite: s.dbType == sqliteDBType,
mysql: s.dbType == mysqlDBType,
2021-04-17 09:06:57 +02:00
}
2021-04-17 09:06:57 +02:00
m, err := migrate.NewWithInstance("prefixed-migration", prefixedData, s.dbType, driver)
2020-10-16 22:27:16 +02:00
if err != nil {
return err
}
err = m.Up()
if err != nil && !errors.Is(err, migrate.ErrNoChange) && !errors.Is(err, os.ErrNotExist) {
2020-10-16 22:27:16 +02:00
return err
}
2020-10-16 22:27:16 +02:00
return nil
}