From 152448d11681212325f3ba24b273f651f09e93e6 Mon Sep 17 00:00:00 2001 From: Nicola Murino Date: Sat, 15 Feb 2025 22:43:19 +0100 Subject: [PATCH] dataprovider: add options to shares for future extensibility Signed-off-by: Nicola Murino --- internal/dataprovider/bolt.go | 14 +++++++++++--- internal/dataprovider/mysql.go | 30 +++++++++++++++++++++++++++++ internal/dataprovider/pgsql.go | 30 +++++++++++++++++++++++++++++ internal/dataprovider/sqlcommon.go | 2 +- internal/dataprovider/sqlite.go | 31 ++++++++++++++++++++++++++++++ 5 files changed, 103 insertions(+), 4 deletions(-) diff --git a/internal/dataprovider/bolt.go b/internal/dataprovider/bolt.go index 4db4c945..d3000031 100644 --- a/internal/dataprovider/bolt.go +++ b/internal/dataprovider/bolt.go @@ -40,7 +40,7 @@ import ( ) const ( - boltDatabaseVersion = 29 + boltDatabaseVersion = 30 ) var ( @@ -3186,6 +3186,10 @@ func (p *BoltProvider) migrateDatabase() error { providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err + case version == 29: + logger.InfoToConsole("updating database schema version: %d -> 30", version) + providerLog(logger.LevelInfo, "updating database schema version: %d -> 30", version) + return updateBoltDatabaseVersion(p.dbHandle, 30) default: if version > boltDatabaseVersion { providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, @@ -3207,6 +3211,10 @@ func (p *BoltProvider) revertDatabase(targetVersion int) error { //nolint:gocycl return errors.New("current version match target version, nothing to do") } switch dbVersion.Version { + case 30: + logger.InfoToConsole("downgrading database schema version: %d -> 29", dbVersion.Version) + providerLog(logger.LevelInfo, "downgrading database schema version: %d -> 29", dbVersion.Version) + return updateBoltDatabaseVersion(p.dbHandle, 29) default: return fmt.Errorf("database schema version not handled: %v", dbVersion.Version) } @@ -3947,7 +3955,7 @@ func getBoltDatabaseVersion(dbHandle *bolt.DB) (schemaVersion, error) { return dbVersion, err } -/*func updateBoltDatabaseVersion(dbHandle *bolt.DB, version int) error { +func updateBoltDatabaseVersion(dbHandle *bolt.DB, version int) error { err := dbHandle.Update(func(tx *bolt.Tx) error { bucket := tx.Bucket(dbVersionBucket) if bucket == nil { @@ -3963,4 +3971,4 @@ func getBoltDatabaseVersion(dbHandle *bolt.DB) (schemaVersion, error) { return bucket.Put(dbVersionKey, buf) }) return err -}*/ +} diff --git a/internal/dataprovider/mysql.go b/internal/dataprovider/mysql.go index a1d6a613..78a1f933 100644 --- a/internal/dataprovider/mysql.go +++ b/internal/dataprovider/mysql.go @@ -194,6 +194,8 @@ const ( "CREATE INDEX `{{prefix}}ip_lists_deleted_at_idx` ON `{{ip_lists}}` (`deleted_at`);" + "CREATE INDEX `{{prefix}}ip_lists_first_last_idx` ON `{{ip_lists}}` (`first`, `last`);" + "INSERT INTO {{schema_version}} (version) VALUES (29);" + mysqlV30SQL = "ALTER TABLE `{{shares}}` ADD COLUMN `options` longtext NULL;" + mysqlV30DownSQL = "ALTER TABLE `{{shares}}` DROP COLUMN `options`;" ) // MySQLProvider defines the auth provider for MySQL/MariaDB database @@ -802,6 +804,8 @@ func (p *MySQLProvider) migrateDatabase() error { providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err + case version == 29: + return updateMySQLDatabaseFromV29(p.dbHandle) default: if version > sqlDatabaseVersion { providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, @@ -824,6 +828,8 @@ func (p *MySQLProvider) revertDatabase(targetVersion int) error { } switch dbVersion.Version { + case 30: + return downgradeMySQLDatabaseFromV30(p.dbHandle) default: return fmt.Errorf("database schema version not handled: %d", dbVersion.Version) } @@ -861,3 +867,27 @@ func (p *MySQLProvider) normalizeError(err error, fieldType int) error { } return err } + +func updateMySQLDatabaseFromV29(dbHandle *sql.DB) error { + return updateMySQLDatabaseFrom29To30(dbHandle) +} + +func downgradeMySQLDatabaseFromV30(dbHandle *sql.DB) error { + return downgradeMySQLDatabaseFrom30To29(dbHandle) +} + +func updateMySQLDatabaseFrom29To30(dbHandle *sql.DB) error { + logger.InfoToConsole("updating database schema version: 29 -> 30") + providerLog(logger.LevelInfo, "updating database schema version: 29 -> 30") + + sql := strings.ReplaceAll(mysqlV30SQL, "{{shares}}", sqlTableShares) + return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 30, true) +} + +func downgradeMySQLDatabaseFrom30To29(dbHandle *sql.DB) error { + logger.InfoToConsole("downgrading database schema version: 30 -> 29") + providerLog(logger.LevelInfo, "downgrading database schema version: 30 -> 29") + + sql := strings.ReplaceAll(mysqlV30DownSQL, "{{shares}}", sqlTableShares) + return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 29, false) +} diff --git a/internal/dataprovider/pgsql.go b/internal/dataprovider/pgsql.go index 9ff88695..5bc0e5fe 100644 --- a/internal/dataprovider/pgsql.go +++ b/internal/dataprovider/pgsql.go @@ -210,6 +210,8 @@ INSERT INTO {{schema_version}} (version) VALUES (29); ` // not supported in CockroachDB ipListsLikeIndex = `CREATE INDEX "{{prefix}}ip_lists_ipornet_like_idx" ON "{{ip_lists}}" ("ipornet" varchar_pattern_ops);` + pgsqlV30SQL = `ALTER TABLE "{{shares}}" ADD COLUMN "options" text NULL;` + pgsqlV30DownSQL = `ALTER TABLE "{{shares}}" DROP COLUMN "options" CASCADE;` ) var ( @@ -826,6 +828,8 @@ func (p *PGSQLProvider) migrateDatabase() error { //nolint:dupl providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err + case version == 29: + return updatePGSQLDatabaseFromV29(p.dbHandle) default: if version > sqlDatabaseVersion { providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, @@ -848,6 +852,8 @@ func (p *PGSQLProvider) revertDatabase(targetVersion int) error { } switch dbVersion.Version { + case 30: + return downgradePGSQLDatabaseFromV30(p.dbHandle) default: return fmt.Errorf("database schema version not handled: %d", dbVersion.Version) } @@ -885,3 +891,27 @@ func (p *PGSQLProvider) normalizeError(err error, fieldType int) error { } return err } + +func updatePGSQLDatabaseFromV29(dbHandle *sql.DB) error { + return updatePGSQLDatabaseFrom29To30(dbHandle) +} + +func downgradePGSQLDatabaseFromV30(dbHandle *sql.DB) error { + return downgradePGSQLDatabaseFrom30To29(dbHandle) +} + +func updatePGSQLDatabaseFrom29To30(dbHandle *sql.DB) error { + logger.InfoToConsole("updating database schema version: 29 -> 30") + providerLog(logger.LevelInfo, "updating database schema version: 29 -> 30") + + sql := strings.ReplaceAll(pgsqlV30SQL, "{{shares}}", sqlTableShares) + return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 30, true) +} + +func downgradePGSQLDatabaseFrom30To29(dbHandle *sql.DB) error { + logger.InfoToConsole("downgrading database schema version: 30 -> 29") + providerLog(logger.LevelInfo, "downgrading database schema version: 30 -> 29") + + sql := strings.ReplaceAll(pgsqlV30DownSQL, "{{shares}}", sqlTableShares) + return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 29, false) +} diff --git a/internal/dataprovider/sqlcommon.go b/internal/dataprovider/sqlcommon.go index d15c63b3..7fb626d1 100644 --- a/internal/dataprovider/sqlcommon.go +++ b/internal/dataprovider/sqlcommon.go @@ -36,7 +36,7 @@ import ( ) const ( - sqlDatabaseVersion = 29 + sqlDatabaseVersion = 30 defaultSQLQueryTimeout = 10 * time.Second longSQLQueryTimeout = 60 * time.Second ) diff --git a/internal/dataprovider/sqlite.go b/internal/dataprovider/sqlite.go index c7f59eb9..b2b77af3 100644 --- a/internal/dataprovider/sqlite.go +++ b/internal/dataprovider/sqlite.go @@ -24,6 +24,7 @@ import ( "errors" "fmt" "path/filepath" + "strings" "time" "github.com/mattn/go-sqlite3" @@ -180,6 +181,8 @@ CREATE INDEX "{{prefix}}ip_lists_ip_deleted_at_idx" ON "{{ip_lists}}" ("deleted_ CREATE INDEX "{{prefix}}ip_lists_first_last_idx" ON "{{ip_lists}}" ("first", "last"); INSERT INTO {{schema_version}} (version) VALUES (29); ` + sqliteV30SQL = `ALTER TABLE "{{shares}}" ADD COLUMN "options" text NULL;` + sqliteV30DownSQL = `ALTER TABLE "{{shares}}" DROP COLUMN "options";` ) // SQLiteProvider defines the auth provider for SQLite database @@ -722,6 +725,8 @@ func (p *SQLiteProvider) migrateDatabase() error { //nolint:dupl providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err + case version == 29: + return updateSQLiteDatabaseFromV29(p.dbHandle) default: if version > sqlDatabaseVersion { providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, @@ -744,6 +749,8 @@ func (p *SQLiteProvider) revertDatabase(targetVersion int) error { } switch dbVersion.Version { + case 30: + return downgradeSQLiteDatabaseFromV30(p.dbHandle) default: return fmt.Errorf("database schema version not handled: %d", dbVersion.Version) } @@ -789,6 +796,30 @@ func executePragmaOptimize(dbHandle *sql.DB) error { return err } +func updateSQLiteDatabaseFromV29(dbHandle *sql.DB) error { + return updateSQLiteDatabaseFrom29To30(dbHandle) +} + +func downgradeSQLiteDatabaseFromV30(dbHandle *sql.DB) error { + return downgradeSQLiteDatabaseFrom30To29(dbHandle) +} + +func updateSQLiteDatabaseFrom29To30(dbHandle *sql.DB) error { + logger.InfoToConsole("updating database schema version: 29 -> 30") + providerLog(logger.LevelInfo, "updating database schema version: 29 -> 30") + + sql := strings.ReplaceAll(sqliteV30SQL, "{{shares}}", sqlTableShares) + return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 30, true) +} + +func downgradeSQLiteDatabaseFrom30To29(dbHandle *sql.DB) error { + logger.InfoToConsole("downgrading database schema version: 30 -> 29") + providerLog(logger.LevelInfo, "downgrading database schema version: 30 -> 29") + + sql := strings.ReplaceAll(sqliteV30DownSQL, "{{shares}}", sqlTableShares) + return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 29, false) +} + /*func setPragmaFK(dbHandle *sql.DB, value string) error { ctx, cancel := context.WithTimeout(context.Background(), longSQLQueryTimeout) defer cancel()