From 9a9e7d1a7f43d42614431d239dab08471f7512cf Mon Sep 17 00:00:00 2001 From: Nicola Murino Date: Fri, 28 Oct 2022 14:28:37 +0200 Subject: [PATCH] squash database migrations Signed-off-by: Nicola Murino --- go.mod | 5 +- go.sum | 13 +- internal/dataprovider/bolt.go | 38 ++--- internal/dataprovider/mysql.go | 215 ++++----------------------- internal/dataprovider/pgsql.go | 250 +++++--------------------------- internal/dataprovider/sqlite.go | 227 +++++------------------------ 6 files changed, 126 insertions(+), 622 deletions(-) diff --git a/go.mod b/go.mod index 7d895870..aff89fab 100644 --- a/go.mod +++ b/go.mod @@ -77,8 +77,7 @@ require ( require ( cloud.google.com/go v0.105.0 // indirect - cloud.google.com/go/compute v1.12.1 // indirect - cloud.google.com/go/compute/metadata v0.1.1 // indirect + cloud.google.com/go/compute/metadata v0.2.0 // indirect cloud.google.com/go/iam v0.6.0 // indirect github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.1 // indirect github.com/ajg/form v1.5.1 // indirect @@ -160,7 +159,7 @@ require ( golang.org/x/tools v0.2.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/appengine v1.6.7 // indirect - google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71 // indirect + google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c // indirect google.golang.org/grpc v1.50.1 // indirect google.golang.org/protobuf v1.28.1 // indirect gopkg.in/ini.v1 v1.67.0 // indirect diff --git a/go.sum b/go.sum index c734580c..bd911d62 100644 --- a/go.sum +++ b/go.sum @@ -50,10 +50,8 @@ cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6m cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= -cloud.google.com/go/compute v1.12.1 h1:gKVJMEyqV5c/UnpzjjQbo3Rjvvqpr9B1DFSbJC4OXr0= -cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= -cloud.google.com/go/compute/metadata v0.1.1 h1:/sxEbyrm6cw+XOUw1YxBHlatV71z4vpnmO7z2IZ0h3I= -cloud.google.com/go/compute/metadata v0.1.1/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0 h1:nBbNSZyDpkNlo3DepaaLKVuO7ClyifSAmNloSCZrHnQ= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= @@ -62,8 +60,9 @@ cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJ cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= cloud.google.com/go/iam v0.6.0 h1:nsqQC88kT5Iwlm4MeNGTpfMWddp6NB/UOLFTH6m1QfQ= cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= -cloud.google.com/go/kms v1.4.0 h1:iElbfoE61VeLhnZcGOltqL8HIly8Nhbe5t6JlH9GXjo= cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0 h1:uc58n3b/n/F2yDMJzHMbXORkJSh3fzO4/+jju6eR7Zg= +cloud.google.com/go/longrunning v0.1.1 h1:y50CXG4j0+qvEukslYFBCrzaXX0qpFbBzc3PchSu/LE= cloud.google.com/go/monitoring v1.1.0/go.mod h1:L81pzz7HKn14QCMaCs6NTQkdBnE87TElyanS95vIcl4= cloud.google.com/go/monitoring v1.5.0/go.mod h1:/o9y8NYX5j91JjD/JvGLYbi86kL11OjyJXq2XziLJu4= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= @@ -2220,8 +2219,8 @@ google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljW google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= google.golang.org/genproto v0.0.0-20220802133213-ce4fa296bf78/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= -google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71 h1:GEgb2jF5zxsFJpJfg9RoDDWm7tiwc/DDSTE2BtLUkXU= -google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c h1:QgY/XxIAIeccR+Ca/rDdKubLIU9rcJ3xfy1DC/Wd2Oo= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= google.golang.org/grpc v0.0.0-20160317175043-d3ddb4469d5a/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= diff --git a/internal/dataprovider/bolt.go b/internal/dataprovider/bolt.go index 9be756d0..79b587b7 100644 --- a/internal/dataprovider/bolt.go +++ b/internal/dataprovider/bolt.go @@ -2596,26 +2596,22 @@ func (p *BoltProvider) migrateDatabase() error { } switch version := dbVersion.Version; { case version == boltDatabaseVersion: - providerLog(logger.LevelDebug, "bolt database is up to date, current version: %v", version) + providerLog(logger.LevelDebug, "bolt database is up to date, current version: %d", version) return ErrNoInitRequired - case version < 19: - err = fmt.Errorf("database schema version %v is too old, please see the upgrading docs", version) + case version < 23: + err = fmt.Errorf("database schema version %d is too old, please see the upgrading docs", version) providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err - case version == 19, version == 20, version == 21, version == 22: - logger.InfoToConsole(fmt.Sprintf("updating database schema version: %d -> 23", version)) - providerLog(logger.LevelInfo, "updating database schema version: %d -> 23", version) - return updateBoltDatabaseVersion(p.dbHandle, 23) default: if version > boltDatabaseVersion { - providerLog(logger.LevelError, "database schema version %v is newer than the supported one: %v", version, + providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, boltDatabaseVersion) - logger.WarnToConsole("database schema version %v is newer than the supported one: %v", version, + logger.WarnToConsole("database schema version %d is newer than the supported one: %d", version, boltDatabaseVersion) return nil } - return fmt.Errorf("database schema version not handled: %v", version) + return fmt.Errorf("database schema version not handled: %d", version) } } @@ -2628,22 +2624,6 @@ func (p *BoltProvider) revertDatabase(targetVersion int) error { return errors.New("current version match target version, nothing to do") } switch dbVersion.Version { - case 20, 21, 22, 23: - logger.InfoToConsole("downgrading database schema version: %d -> 19", dbVersion.Version) - providerLog(logger.LevelInfo, "downgrading database schema version: %d -> 19", dbVersion.Version) - err := p.dbHandle.Update(func(tx *bolt.Tx) error { - for _, bucketName := range [][]byte{actionsBucket, rulesBucket} { - err := tx.DeleteBucket(bucketName) - if err != nil && !errors.Is(err, bolt.ErrBucketNotFound) { - return err - } - } - return nil - }) - if err != nil { - return err - } - return updateBoltDatabaseVersion(p.dbHandle, 19) default: return fmt.Errorf("database schema version not handled: %v", dbVersion.Version) } @@ -3220,7 +3200,7 @@ func getBoltDatabaseVersion(dbHandle *bolt.DB) (schemaVersion, error) { v := bucket.Get(dbVersionKey) if v == nil { dbVersion = schemaVersion{ - Version: 19, + Version: 23, } return nil } @@ -3229,7 +3209,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 { @@ -3245,4 +3225,4 @@ func updateBoltDatabaseVersion(dbHandle *bolt.DB, version int) error { return bucket.Put(dbVersionKey, buf) }) return err -} +}*/ diff --git a/internal/dataprovider/mysql.go b/internal/dataprovider/mysql.go index 948052bd..0833cebb 100644 --- a/internal/dataprovider/mysql.go +++ b/internal/dataprovider/mysql.go @@ -92,7 +92,8 @@ const ( "`created_at` bigint NOT NULL, `updated_at` bigint NOT NULL, `email` varchar(255) NULL, " + "`upload_data_transfer` integer NOT NULL, `download_data_transfer` integer NOT NULL, " + "`total_data_transfer` integer NOT NULL, `used_upload_data_transfer` integer NOT NULL, " + - "`used_download_data_transfer` integer NOT NULL);" + + "`used_download_data_transfer` integer NOT NULL, `deleted_at` bigint NOT NULL, `first_download` bigint NOT NULL, " + + "`first_upload` bigint NOT NULL);" + "CREATE TABLE `{{groups_folders_mapping}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + "`group_id` integer NOT NULL, `folder_id` integer NOT NULL, " + "`virtual_path` longtext NOT NULL, `quota_size` bigint NOT NULL, `quota_files` integer NOT NULL);" + @@ -129,18 +130,7 @@ const ( "`expires_at` bigint NOT NULL, `description` longtext NULL, `admin_id` integer NULL, `user_id` integer NULL);" + "ALTER TABLE `{{api_keys}}` ADD CONSTRAINT `{{prefix}}api_keys_admin_id_fk_admins_id` FOREIGN KEY (`admin_id`) REFERENCES `{{admins}}` (`id`) ON DELETE CASCADE;" + "ALTER TABLE `{{api_keys}}` ADD CONSTRAINT `{{prefix}}api_keys_user_id_fk_users_id` FOREIGN KEY (`user_id`) REFERENCES `{{users}}` (`id`) ON DELETE CASCADE;" + - "CREATE INDEX `{{prefix}}users_updated_at_idx` ON `{{users}}` (`updated_at`);" + - "CREATE INDEX `{{prefix}}defender_hosts_updated_at_idx` ON `{{defender_hosts}}` (`updated_at`);" + - "CREATE INDEX `{{prefix}}defender_hosts_ban_time_idx` ON `{{defender_hosts}}` (`ban_time`);" + - "CREATE INDEX `{{prefix}}defender_events_date_time_idx` ON `{{defender_events}}` (`date_time`);" + - "CREATE INDEX `{{prefix}}active_transfers_connection_id_idx` ON `{{active_transfers}}` (`connection_id`);" + - "CREATE INDEX `{{prefix}}active_transfers_transfer_id_idx` ON `{{active_transfers}}` (`transfer_id`);" + - "CREATE INDEX `{{prefix}}active_transfers_updated_at_idx` ON `{{active_transfers}}` (`updated_at`);" + - "CREATE INDEX `{{prefix}}groups_updated_at_idx` ON `{{groups}}` (`updated_at`);" + - "CREATE INDEX `{{prefix}}shared_sessions_type_idx` ON `{{shared_sessions}}` (`type`);" + - "CREATE INDEX `{{prefix}}shared_sessions_timestamp_idx` ON `{{shared_sessions}}` (`timestamp`);" + - "INSERT INTO {{schema_version}} (version) VALUES (19);" - mysqlV20SQL = "CREATE TABLE `{{events_rules}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + + "CREATE TABLE `{{events_rules}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + "`name` varchar(255) NOT NULL UNIQUE, `description` varchar(512) NULL, `created_at` bigint NOT NULL, " + "`updated_at` bigint NOT NULL, `trigger` integer NOT NULL, `conditions` longtext NOT NULL, `deleted_at` bigint NOT NULL);" + "CREATE TABLE `{{events_actions}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + @@ -155,38 +145,32 @@ const ( "FOREIGN KEY (`rule_id`) REFERENCES `{{events_rules}}` (`id`) ON DELETE CASCADE;" + "ALTER TABLE `{{rules_actions_mapping}}` ADD CONSTRAINT `{{prefix}}rules_actions_mapping_action_id_fk_events_targets_id` " + "FOREIGN KEY (`action_id`) REFERENCES `{{events_actions}}` (`id`) ON DELETE NO ACTION;" + - "ALTER TABLE `{{users}}` ADD COLUMN `deleted_at` bigint DEFAULT 0 NOT NULL;" + - "ALTER TABLE `{{users}}` ALTER COLUMN `deleted_at` DROP DEFAULT;" + - "CREATE INDEX `{{prefix}}events_rules_updated_at_idx` ON `{{events_rules}}` (`updated_at`);" + - "CREATE INDEX `{{prefix}}events_rules_deleted_at_idx` ON `{{events_rules}}` (`deleted_at`);" + - "CREATE INDEX `{{prefix}}events_rules_trigger_idx` ON `{{events_rules}}` (`trigger`);" + - "CREATE INDEX `{{prefix}}rules_actions_mapping_order_idx` ON `{{rules_actions_mapping}}` (`order`);" + - "CREATE INDEX `{{prefix}}users_deleted_at_idx` ON `{{users}}` (`deleted_at`);" - mysqlV20DownSQL = "DROP TABLE `{{rules_actions_mapping}}` CASCADE;" + - "DROP TABLE `{{events_rules}}` CASCADE;" + - "DROP TABLE `{{events_actions}}` CASCADE;" + - "DROP TABLE `{{tasks}}` CASCADE;" + - "ALTER TABLE `{{users}}` DROP COLUMN `deleted_at`;" - mysqlV21SQL = "ALTER TABLE `{{users}}` ADD COLUMN `first_download` bigint DEFAULT 0 NOT NULL; " + - "ALTER TABLE `{{users}}` ALTER COLUMN `first_download` DROP DEFAULT; " + - "ALTER TABLE `{{users}}` ADD COLUMN `first_upload` bigint DEFAULT 0 NOT NULL; " + - "ALTER TABLE `{{users}}` ALTER COLUMN `first_upload` DROP DEFAULT;" - mysqlV21DownSQL = "ALTER TABLE `{{users}}` DROP COLUMN `first_upload`; " + - "ALTER TABLE `{{users}}` DROP COLUMN `first_download`;" - mysqlV22SQL = "CREATE TABLE `{{admins_groups_mapping}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + + "CREATE TABLE `{{admins_groups_mapping}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + " `admin_id` integer NOT NULL, `group_id` integer NOT NULL, `options` longtext NOT NULL);" + "ALTER TABLE `{{admins_groups_mapping}}` ADD CONSTRAINT `{{prefix}}unique_admin_group_mapping` " + "UNIQUE (`admin_id`, `group_id`);" + "ALTER TABLE `{{admins_groups_mapping}}` ADD CONSTRAINT `{{prefix}}admins_groups_mapping_admin_id_fk_admins_id` " + "FOREIGN KEY (`admin_id`) REFERENCES `{{admins}}` (`id`) ON DELETE CASCADE;" + "ALTER TABLE `{{admins_groups_mapping}}` ADD CONSTRAINT `{{prefix}}admins_groups_mapping_group_id_fk_groups_id` " + - "FOREIGN KEY (`group_id`) REFERENCES `{{groups}}` (`id`) ON DELETE CASCADE;" - mysqlV22DownSQL = "ALTER TABLE `{{admins_groups_mapping}}` DROP INDEX `{{prefix}}unique_admin_group_mapping`;" + - "DROP TABLE `{{admins_groups_mapping}}` CASCADE;" - mysqlV23SQL = "CREATE TABLE `{{nodes}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + + "FOREIGN KEY (`group_id`) REFERENCES `{{groups}}` (`id`) ON DELETE CASCADE;" + + "CREATE TABLE `{{nodes}}` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, " + "`name` varchar(255) NOT NULL UNIQUE, `data` longtext NOT NULL, `created_at` bigint NOT NULL, " + - "`updated_at` bigint NOT NULL);" - mysqlV23DownSQL = "DROP TABLE `{{nodes}}` CASCADE;" + "`updated_at` bigint NOT NULL);" + + "CREATE INDEX `{{prefix}}users_updated_at_idx` ON `{{users}}` (`updated_at`);" + + "CREATE INDEX `{{prefix}}users_deleted_at_idx` ON `{{users}}` (`deleted_at`);" + + "CREATE INDEX `{{prefix}}defender_hosts_updated_at_idx` ON `{{defender_hosts}}` (`updated_at`);" + + "CREATE INDEX `{{prefix}}defender_hosts_ban_time_idx` ON `{{defender_hosts}}` (`ban_time`);" + + "CREATE INDEX `{{prefix}}defender_events_date_time_idx` ON `{{defender_events}}` (`date_time`);" + + "CREATE INDEX `{{prefix}}active_transfers_connection_id_idx` ON `{{active_transfers}}` (`connection_id`);" + + "CREATE INDEX `{{prefix}}active_transfers_transfer_id_idx` ON `{{active_transfers}}` (`transfer_id`);" + + "CREATE INDEX `{{prefix}}active_transfers_updated_at_idx` ON `{{active_transfers}}` (`updated_at`);" + + "CREATE INDEX `{{prefix}}shared_sessions_type_idx` ON `{{shared_sessions}}` (`type`);" + + "CREATE INDEX `{{prefix}}shared_sessions_timestamp_idx` ON `{{shared_sessions}}` (`timestamp`);" + + "CREATE INDEX `{{prefix}}events_rules_updated_at_idx` ON `{{events_rules}}` (`updated_at`);" + + "CREATE INDEX `{{prefix}}events_rules_deleted_at_idx` ON `{{events_rules}}` (`deleted_at`);" + + "CREATE INDEX `{{prefix}}events_rules_trigger_idx` ON `{{events_rules}}` (`trigger`);" + + "CREATE INDEX `{{prefix}}rules_actions_mapping_order_idx` ON `{{rules_actions_mapping}}` (`order`);" + + "INSERT INTO {{schema_version}} (version) VALUES (23);" ) // MySQLProvider defines the auth provider for MySQL/MariaDB database @@ -695,11 +679,11 @@ func (p *MySQLProvider) initializeDatabase() error { if errors.Is(err, sql.ErrNoRows) { return errSchemaVersionEmpty } - logger.InfoToConsole("creating initial database schema, version 19") - providerLog(logger.LevelInfo, "creating initial database schema, version 19") + logger.InfoToConsole("creating initial database schema, version 23") + providerLog(logger.LevelInfo, "creating initial database schema, version 23") initialSQL := sqlReplaceAll(mysqlInitialSQL) - return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, strings.Split(initialSQL, ";"), 19, true) + return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, strings.Split(initialSQL, ";"), 23, true) } func (p *MySQLProvider) migrateDatabase() error { //nolint:dupl @@ -710,30 +694,22 @@ func (p *MySQLProvider) migrateDatabase() error { //nolint:dupl switch version := dbVersion.Version; { case version == sqlDatabaseVersion: - providerLog(logger.LevelDebug, "sql database is up to date, current version: %v", version) + providerLog(logger.LevelDebug, "sql database is up to date, current version: %d", version) return ErrNoInitRequired - case version < 19: - err = fmt.Errorf("database schema version %v is too old, please see the upgrading docs", version) + case version < 23: + err = fmt.Errorf("database schema version %d is too old, please see the upgrading docs", version) providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err - case version == 19: - return updateMySQLDatabaseFromV19(p.dbHandle) - case version == 20: - return updateMySQLDatabaseFromV20(p.dbHandle) - case version == 21: - return updateMySQLDatabaseFromV21(p.dbHandle) - case version == 22: - return updateMySQLDatabaseFromV22(p.dbHandle) default: if version > sqlDatabaseVersion { - providerLog(logger.LevelError, "database schema version %v is newer than the supported one: %v", version, + providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, sqlDatabaseVersion) - logger.WarnToConsole("database schema version %v is newer than the supported one: %v", version, + logger.WarnToConsole("database schema version %d is newer than the supported one: %d", version, sqlDatabaseVersion) return nil } - return fmt.Errorf("database schema version not handled: %v", version) + return fmt.Errorf("database schema version not handled: %d", version) } } @@ -747,16 +723,8 @@ func (p *MySQLProvider) revertDatabase(targetVersion int) error { } switch dbVersion.Version { - case 20: - return downgradeMySQLDatabaseFromV20(p.dbHandle) - case 21: - return downgradeMySQLDatabaseFromV21(p.dbHandle) - case 22: - return downgradeMySQLDatabaseFromV22(p.dbHandle) - case 23: - return downgradeMySQLDatabaseFromV23(p.dbHandle) default: - return fmt.Errorf("database schema version not handled: %v", dbVersion.Version) + return fmt.Errorf("database schema version not handled: %d", dbVersion.Version) } } @@ -764,122 +732,3 @@ func (p *MySQLProvider) resetDatabase() error { sql := sqlReplaceAll(mysqlResetSQL) return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, strings.Split(sql, ";"), 0, false) } - -func updateMySQLDatabaseFromV19(dbHandle *sql.DB) error { - if err := updateMySQLDatabaseFrom19To20(dbHandle); err != nil { - return err - } - return updateMySQLDatabaseFromV20(dbHandle) -} - -func updateMySQLDatabaseFromV20(dbHandle *sql.DB) error { - if err := updateMySQLDatabaseFrom20To21(dbHandle); err != nil { - return err - } - return updateMySQLDatabaseFromV21(dbHandle) -} - -func updateMySQLDatabaseFromV21(dbHandle *sql.DB) error { - if err := updateMySQLDatabaseFrom21To22(dbHandle); err != nil { - return err - } - return updateMySQLDatabaseFromV22(dbHandle) -} - -func updateMySQLDatabaseFromV22(dbHandle *sql.DB) error { - return updateMySQLDatabaseFrom22To23(dbHandle) -} - -func downgradeMySQLDatabaseFromV20(dbHandle *sql.DB) error { - return downgradeMySQLDatabaseFrom20To19(dbHandle) -} - -func downgradeMySQLDatabaseFromV21(dbHandle *sql.DB) error { - if err := downgradeMySQLDatabaseFrom21To20(dbHandle); err != nil { - return err - } - return downgradeMySQLDatabaseFromV20(dbHandle) -} - -func downgradeMySQLDatabaseFromV22(dbHandle *sql.DB) error { - if err := downgradeMySQLDatabaseFrom22To21(dbHandle); err != nil { - return err - } - return downgradeMySQLDatabaseFromV21(dbHandle) -} - -func downgradeMySQLDatabaseFromV23(dbHandle *sql.DB) error { - if err := downgradeMySQLDatabaseFrom23To22(dbHandle); err != nil { - return err - } - return downgradeMySQLDatabaseFromV22(dbHandle) -} - -func updateMySQLDatabaseFrom19To20(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 19 -> 20") - providerLog(logger.LevelInfo, "updating database schema version: 19 -> 20") - sql := strings.ReplaceAll(mysqlV20SQL, "{{events_actions}}", sqlTableEventsActions) - sql = strings.ReplaceAll(sql, "{{events_rules}}", sqlTableEventsRules) - sql = strings.ReplaceAll(sql, "{{rules_actions_mapping}}", sqlTableRulesActionsMapping) - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - sql = strings.ReplaceAll(sql, "{{tasks}}", sqlTableTasks) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 20, true) -} - -func updateMySQLDatabaseFrom20To21(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 20 -> 21") - providerLog(logger.LevelInfo, "updating database schema version: 20 -> 21") - sql := strings.ReplaceAll(mysqlV21SQL, "{{users}}", sqlTableUsers) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 21, true) -} - -func updateMySQLDatabaseFrom21To22(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 21 -> 22") - providerLog(logger.LevelInfo, "updating database schema version: 21 -> 22") - sql := strings.ReplaceAll(mysqlV22SQL, "{{admins_groups_mapping}}", sqlTableAdminsGroupsMapping) - sql = strings.ReplaceAll(sql, "{{admins}}", sqlTableAdmins) - sql = strings.ReplaceAll(sql, "{{groups}}", sqlTableGroups) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 22, true) -} - -func updateMySQLDatabaseFrom22To23(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 22 -> 23") - providerLog(logger.LevelInfo, "updating database schema version: 22 -> 23") - sql := strings.ReplaceAll(mysqlV23SQL, "{{nodes}}", sqlTableNodes) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 23, true) -} - -func downgradeMySQLDatabaseFrom20To19(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 20 -> 19") - providerLog(logger.LevelInfo, "downgrading database schema version: 20 -> 19") - sql := strings.ReplaceAll(mysqlV20DownSQL, "{{events_actions}}", sqlTableEventsActions) - sql = strings.ReplaceAll(sql, "{{events_rules}}", sqlTableEventsRules) - sql = strings.ReplaceAll(sql, "{{rules_actions_mapping}}", sqlTableRulesActionsMapping) - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - sql = strings.ReplaceAll(sql, "{{tasks}}", sqlTableTasks) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 19, false) -} - -func downgradeMySQLDatabaseFrom21To20(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 21 -> 20") - providerLog(logger.LevelInfo, "downgrading database schema version: 21 -> 20") - sql := strings.ReplaceAll(mysqlV21DownSQL, "{{users}}", sqlTableUsers) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 20, false) -} - -func downgradeMySQLDatabaseFrom22To21(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 22 -> 21") - providerLog(logger.LevelInfo, "downgrading database schema version: 22 -> 21") - sql := strings.ReplaceAll(mysqlV22DownSQL, "{{admins_groups_mapping}}", sqlTableAdminsGroupsMapping) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 21, false) -} - -func downgradeMySQLDatabaseFrom23To22(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 23 -> 22") - providerLog(logger.LevelInfo, "downgrading database schema version: 23 -> 22") - sql := strings.ReplaceAll(mysqlV23DownSQL, "{{nodes}}", sqlTableNodes) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, strings.Split(sql, ";"), 22, false) -} diff --git a/internal/dataprovider/pgsql.go b/internal/dataprovider/pgsql.go index 0e2d5c43..d62cfd1e 100644 --- a/internal/dataprovider/pgsql.go +++ b/internal/dataprovider/pgsql.go @@ -23,7 +23,6 @@ import ( "database/sql" "errors" "fmt" - "strings" "time" // we import pgx here to be able to disable PostgreSQL support using a build tag @@ -88,7 +87,8 @@ CREATE TABLE "{{users}}" ("id" serial NOT NULL PRIMARY KEY, "username" varchar(2 "download_bandwidth" integer NOT NULL, "last_login" bigint NOT NULL, "filters" text NULL, "filesystem" text NULL, "additional_info" text NULL, "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "email" varchar(255) NULL, "upload_data_transfer" integer NOT NULL, "download_data_transfer" integer NOT NULL, "total_data_transfer" integer NOT NULL, -"used_upload_data_transfer" integer NOT NULL, "used_download_data_transfer" integer NOT NULL); +"used_upload_data_transfer" integer NOT NULL, "used_download_data_transfer" integer NOT NULL, "deleted_at" bigint NOT NULL, +"first_download" bigint NOT NULL, "first_upload" bigint NOT NULL); CREATE TABLE "{{groups_folders_mapping}}" ("id" serial NOT NULL PRIMARY KEY, "group_id" integer NOT NULL, "folder_id" integer NOT NULL, "virtual_path" text NOT NULL, "quota_size" bigint NOT NULL, "quota_files" integer NOT NULL); CREATE TABLE "{{users_groups_mapping}}" ("id" serial NOT NULL PRIMARY KEY, "user_id" integer NOT NULL, @@ -130,25 +130,7 @@ FOREIGN KEY ("folder_id") REFERENCES "{{folders}}" ("id") MATCH SIMPLE ON UPDATE CREATE INDEX "{{prefix}}groups_folders_mapping_group_id_idx" ON "{{groups_folders_mapping}}" ("group_id"); ALTER TABLE "{{groups_folders_mapping}}" ADD CONSTRAINT "{{prefix}}groups_folders_mapping_group_id_fk_groups_id" FOREIGN KEY ("group_id") REFERENCES "{{groups}}" ("id") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE; -CREATE INDEX "{{prefix}}groups_updated_at_idx" ON "{{groups}}" ("updated_at"); -CREATE INDEX "{{prefix}}users_folders_mapping_folder_id_idx" ON "{{users_folders_mapping}}" ("folder_id"); -CREATE INDEX "{{prefix}}users_folders_mapping_user_id_idx" ON "{{users_folders_mapping}}" ("user_id"); -CREATE INDEX "{{prefix}}api_keys_admin_id_idx" ON "{{api_keys}}" ("admin_id"); -CREATE INDEX "{{prefix}}api_keys_user_id_idx" ON "{{api_keys}}" ("user_id"); -CREATE INDEX "{{prefix}}users_updated_at_idx" ON "{{users}}" ("updated_at"); -CREATE INDEX "{{prefix}}shares_user_id_idx" ON "{{shares}}" ("user_id"); -CREATE INDEX "{{prefix}}defender_hosts_updated_at_idx" ON "{{defender_hosts}}" ("updated_at"); -CREATE INDEX "{{prefix}}defender_hosts_ban_time_idx" ON "{{defender_hosts}}" ("ban_time"); -CREATE INDEX "{{prefix}}defender_events_date_time_idx" ON "{{defender_events}}" ("date_time"); -CREATE INDEX "{{prefix}}defender_events_host_id_idx" ON "{{defender_events}}" ("host_id"); -CREATE INDEX "{{prefix}}active_transfers_connection_id_idx" ON "{{active_transfers}}" ("connection_id"); -CREATE INDEX "{{prefix}}active_transfers_transfer_id_idx" ON "{{active_transfers}}" ("transfer_id"); -CREATE INDEX "{{prefix}}active_transfers_updated_at_idx" ON "{{active_transfers}}" ("updated_at"); -CREATE INDEX "{{prefix}}shared_sessions_type_idx" ON "{{shared_sessions}}" ("type"); -CREATE INDEX "{{prefix}}shared_sessions_timestamp_idx" ON "{{shared_sessions}}" ("timestamp"); -INSERT INTO {{schema_version}} (version) VALUES (19); -` - pgsqlV20SQL = `CREATE TABLE "{{events_rules}}" ("id" serial NOT NULL PRIMARY KEY, "name" varchar(255) NOT NULL UNIQUE, +CREATE TABLE "{{events_rules}}" ("id" serial NOT NULL PRIMARY KEY, "name" varchar(255) NOT NULL UNIQUE, "description" varchar(512) NULL, "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "trigger" integer NOT NULL, "conditions" text NOT NULL, "deleted_at" bigint NOT NULL); CREATE TABLE "{{events_actions}}" ("id" serial NOT NULL PRIMARY KEY, "name" varchar(255) NOT NULL UNIQUE, @@ -162,46 +144,41 @@ ALTER TABLE "{{rules_actions_mapping}}" ADD CONSTRAINT "{{prefix}}rules_actions_ FOREIGN KEY ("rule_id") REFERENCES "{{events_rules}}" ("id") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE; ALTER TABLE "{{rules_actions_mapping}}" ADD CONSTRAINT "{{prefix}}rules_actions_mapping_action_id_fk_events_targets_id" FOREIGN KEY ("action_id") REFERENCES "{{events_actions}}" ("id") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION; -ALTER TABLE "{{users}}" ADD COLUMN "deleted_at" bigint DEFAULT 0 NOT NULL; -ALTER TABLE "{{users}}" ALTER COLUMN "deleted_at" DROP DEFAULT; -CREATE INDEX "{{prefix}}events_rules_updated_at_idx" ON "{{events_rules}}" ("updated_at"); -CREATE INDEX "{{prefix}}events_rules_deleted_at_idx" ON "{{events_rules}}" ("deleted_at"); -CREATE INDEX "{{prefix}}events_rules_trigger_idx" ON "{{events_rules}}" ("trigger"); -CREATE INDEX "{{prefix}}rules_actions_mapping_rule_id_idx" ON "{{rules_actions_mapping}}" ("rule_id"); -CREATE INDEX "{{prefix}}rules_actions_mapping_action_id_idx" ON "{{rules_actions_mapping}}" ("action_id"); -CREATE INDEX "{{prefix}}rules_actions_mapping_order_idx" ON "{{rules_actions_mapping}}" ("order"); -CREATE INDEX "{{prefix}}users_deleted_at_idx" ON "{{users}}" ("deleted_at"); -` - pgsqlV20DownSQL = `DROP TABLE "{{rules_actions_mapping}}" CASCADE; -DROP TABLE "{{events_rules}}" CASCADE; -DROP TABLE "{{events_actions}}" CASCADE; -DROP TABLE "{{tasks}}" CASCADE; -ALTER TABLE "{{users}}" DROP COLUMN "deleted_at" CASCADE; -` - pgsqlV21SQL = `ALTER TABLE "{{users}}" ADD COLUMN "first_download" bigint DEFAULT 0 NOT NULL; -ALTER TABLE "{{users}}" ALTER COLUMN "first_download" DROP DEFAULT; -ALTER TABLE "{{users}}" ADD COLUMN "first_upload" bigint DEFAULT 0 NOT NULL; -ALTER TABLE "{{users}}" ALTER COLUMN "first_upload" DROP DEFAULT; -` - pgsqlV21DownSQL = `ALTER TABLE "{{users}}" DROP COLUMN "first_upload" CASCADE; -ALTER TABLE "{{users}}" DROP COLUMN "first_download" CASCADE; -` - pgsqlV22SQL = `CREATE TABLE "{{admins_groups_mapping}}" ("id" serial NOT NULL PRIMARY KEY, +CREATE TABLE "{{admins_groups_mapping}}" ("id" serial NOT NULL PRIMARY KEY, "admin_id" integer NOT NULL, "group_id" integer NOT NULL, "options" text NOT NULL); ALTER TABLE "{{admins_groups_mapping}}" ADD CONSTRAINT "{{prefix}}unique_admin_group_mapping" UNIQUE ("admin_id", "group_id"); ALTER TABLE "{{admins_groups_mapping}}" ADD CONSTRAINT "{{prefix}}admins_groups_mapping_admin_id_fk_admins_id" FOREIGN KEY ("admin_id") REFERENCES "{{admins}}" ("id") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE; ALTER TABLE "{{admins_groups_mapping}}" ADD CONSTRAINT "{{prefix}}admins_groups_mapping_group_id_fk_groups_id" FOREIGN KEY ("group_id") REFERENCES "{{groups}}" ("id") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE; +CREATE TABLE "{{nodes}}" ("id" serial NOT NULL PRIMARY KEY, "name" varchar(255) NOT NULL UNIQUE, +"data" text NOT NULL, "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL); +CREATE INDEX "{{prefix}}users_folders_mapping_folder_id_idx" ON "{{users_folders_mapping}}" ("folder_id"); +CREATE INDEX "{{prefix}}users_folders_mapping_user_id_idx" ON "{{users_folders_mapping}}" ("user_id"); +CREATE INDEX "{{prefix}}api_keys_admin_id_idx" ON "{{api_keys}}" ("admin_id"); +CREATE INDEX "{{prefix}}api_keys_user_id_idx" ON "{{api_keys}}" ("user_id"); +CREATE INDEX "{{prefix}}users_updated_at_idx" ON "{{users}}" ("updated_at"); +CREATE INDEX "{{prefix}}users_deleted_at_idx" ON "{{users}}" ("deleted_at"); +CREATE INDEX "{{prefix}}shares_user_id_idx" ON "{{shares}}" ("user_id"); +CREATE INDEX "{{prefix}}defender_hosts_updated_at_idx" ON "{{defender_hosts}}" ("updated_at"); +CREATE INDEX "{{prefix}}defender_hosts_ban_time_idx" ON "{{defender_hosts}}" ("ban_time"); +CREATE INDEX "{{prefix}}defender_events_date_time_idx" ON "{{defender_events}}" ("date_time"); +CREATE INDEX "{{prefix}}defender_events_host_id_idx" ON "{{defender_events}}" ("host_id"); +CREATE INDEX "{{prefix}}active_transfers_connection_id_idx" ON "{{active_transfers}}" ("connection_id"); +CREATE INDEX "{{prefix}}active_transfers_transfer_id_idx" ON "{{active_transfers}}" ("transfer_id"); +CREATE INDEX "{{prefix}}active_transfers_updated_at_idx" ON "{{active_transfers}}" ("updated_at"); +CREATE INDEX "{{prefix}}shared_sessions_type_idx" ON "{{shared_sessions}}" ("type"); +CREATE INDEX "{{prefix}}shared_sessions_timestamp_idx" ON "{{shared_sessions}}" ("timestamp"); +CREATE INDEX "{{prefix}}events_rules_updated_at_idx" ON "{{events_rules}}" ("updated_at"); +CREATE INDEX "{{prefix}}events_rules_deleted_at_idx" ON "{{events_rules}}" ("deleted_at"); +CREATE INDEX "{{prefix}}events_rules_trigger_idx" ON "{{events_rules}}" ("trigger"); +CREATE INDEX "{{prefix}}rules_actions_mapping_rule_id_idx" ON "{{rules_actions_mapping}}" ("rule_id"); +CREATE INDEX "{{prefix}}rules_actions_mapping_action_id_idx" ON "{{rules_actions_mapping}}" ("action_id"); +CREATE INDEX "{{prefix}}rules_actions_mapping_order_idx" ON "{{rules_actions_mapping}}" ("order"); CREATE INDEX "{{prefix}}admins_groups_mapping_admin_id_idx" ON "{{admins_groups_mapping}}" ("admin_id"); CREATE INDEX "{{prefix}}admins_groups_mapping_group_id_idx" ON "{{admins_groups_mapping}}" ("group_id"); +INSERT INTO {{schema_version}} (version) VALUES (23); ` - pgsqlV22DownSQL = `ALTER TABLE "{{admins_groups_mapping}}" DROP CONSTRAINT "{{prefix}}unique_admin_group_mapping"; -DROP TABLE "{{admins_groups_mapping}}" CASCADE; -` - pgsqlV23SQL = `CREATE TABLE "{{nodes}}" ("id" serial NOT NULL PRIMARY KEY, "name" varchar(255) NOT NULL UNIQUE, -"data" text NOT NULL, "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL);` - pgsqlV23DownSQL = `DROP TABLE "{{nodes}}" CASCADE;` ) // PGSQLProvider defines the auth provider for PostgreSQL database @@ -669,11 +646,11 @@ func (p *PGSQLProvider) initializeDatabase() error { if errors.Is(err, sql.ErrNoRows) { return errSchemaVersionEmpty } - logger.InfoToConsole("creating initial database schema, version 19") - providerLog(logger.LevelInfo, "creating initial database schema, version 19") + logger.InfoToConsole("creating initial database schema, version 23") + providerLog(logger.LevelInfo, "creating initial database schema, version 23") initialSQL := sqlReplaceAll(pgsqlInitial) - return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, []string{initialSQL}, 19, true) + return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, []string{initialSQL}, 23, true) } func (p *PGSQLProvider) migrateDatabase() error { //nolint:dupl @@ -684,30 +661,22 @@ func (p *PGSQLProvider) migrateDatabase() error { //nolint:dupl switch version := dbVersion.Version; { case version == sqlDatabaseVersion: - providerLog(logger.LevelDebug, "sql database is up to date, current version: %v", version) + providerLog(logger.LevelDebug, "sql database is up to date, current version: %d", version) return ErrNoInitRequired - case version < 19: - err = fmt.Errorf("database schema version %v is too old, please see the upgrading docs", version) + case version < 23: + err = fmt.Errorf("database schema version %d is too old, please see the upgrading docs", version) providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err - case version == 19: - return updatePgSQLDatabaseFromV19(p.dbHandle) - case version == 20: - return updatePgSQLDatabaseFromV20(p.dbHandle) - case version == 21: - return updatePgSQLDatabaseFromV21(p.dbHandle) - case version == 22: - return updatePgSQLDatabaseFromV21(p.dbHandle) default: if version > sqlDatabaseVersion { - providerLog(logger.LevelError, "database schema version %v is newer than the supported one: %v", version, + providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, sqlDatabaseVersion) - logger.WarnToConsole("database schema version %v is newer than the supported one: %v", version, + logger.WarnToConsole("database schema version %d is newer than the supported one: %d", version, sqlDatabaseVersion) return nil } - return fmt.Errorf("database schema version not handled: %v", version) + return fmt.Errorf("database schema version not handled: %d", version) } } @@ -721,16 +690,8 @@ func (p *PGSQLProvider) revertDatabase(targetVersion int) error { } switch dbVersion.Version { - case 20: - return downgradePgSQLDatabaseFromV20(p.dbHandle) - case 21: - return downgradePgSQLDatabaseFromV21(p.dbHandle) - case 22: - return downgradePgSQLDatabaseFromV22(p.dbHandle) - case 23: - return downgradePgSQLDatabaseFromV23(p.dbHandle) default: - return fmt.Errorf("database schema version not handled: %v", dbVersion.Version) + return fmt.Errorf("database schema version not handled: %d", dbVersion.Version) } } @@ -738,136 +699,3 @@ func (p *PGSQLProvider) resetDatabase() error { sql := sqlReplaceAll(pgsqlResetSQL) return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, []string{sql}, 0, false) } - -func updatePgSQLDatabaseFromV19(dbHandle *sql.DB) error { - if err := updatePgSQLDatabaseFrom19To20(dbHandle); err != nil { - return err - } - return updatePgSQLDatabaseFromV20(dbHandle) -} - -func updatePgSQLDatabaseFromV20(dbHandle *sql.DB) error { - if err := updatePgSQLDatabaseFrom20To21(dbHandle); err != nil { - return err - } - return updatePgSQLDatabaseFromV21(dbHandle) -} - -func updatePgSQLDatabaseFromV21(dbHandle *sql.DB) error { - if err := updatePgSQLDatabaseFrom21To22(dbHandle); err != nil { - return err - } - return updatePgSQLDatabaseFromV22(dbHandle) -} - -func updatePgSQLDatabaseFromV22(dbHandle *sql.DB) error { - return updatePgSQLDatabaseFrom22To23(dbHandle) -} - -func downgradePgSQLDatabaseFromV20(dbHandle *sql.DB) error { - return downgradePgSQLDatabaseFrom20To19(dbHandle) -} - -func downgradePgSQLDatabaseFromV21(dbHandle *sql.DB) error { - if err := downgradePgSQLDatabaseFrom21To20(dbHandle); err != nil { - return err - } - return downgradePgSQLDatabaseFromV20(dbHandle) -} - -func downgradePgSQLDatabaseFromV22(dbHandle *sql.DB) error { - if err := downgradePgSQLDatabaseFrom22To21(dbHandle); err != nil { - return err - } - return downgradePgSQLDatabaseFromV21(dbHandle) -} - -func downgradePgSQLDatabaseFromV23(dbHandle *sql.DB) error { - if err := downgradePgSQLDatabaseFrom23To22(dbHandle); err != nil { - return err - } - return downgradePgSQLDatabaseFromV22(dbHandle) -} - -func updatePgSQLDatabaseFrom19To20(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 19 -> 20") - providerLog(logger.LevelInfo, "updating database schema version: 19 -> 20") - sql := pgsqlV20SQL - if config.Driver == CockroachDataProviderName { - sql = strings.ReplaceAll(sql, `ALTER TABLE "{{users}}" ALTER COLUMN "deleted_at" DROP DEFAULT;`, "") - } - sql = strings.ReplaceAll(sql, "{{events_actions}}", sqlTableEventsActions) - sql = strings.ReplaceAll(sql, "{{events_rules}}", sqlTableEventsRules) - sql = strings.ReplaceAll(sql, "{{rules_actions_mapping}}", sqlTableRulesActionsMapping) - sql = strings.ReplaceAll(sql, "{{tasks}}", sqlTableTasks) - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 20, true) -} - -func updatePgSQLDatabaseFrom20To21(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 20 -> 21") - providerLog(logger.LevelInfo, "updating database schema version: 20 -> 21") - sql := pgsqlV21SQL - if config.Driver == CockroachDataProviderName { - sql = strings.ReplaceAll(sql, `ALTER TABLE "{{users}}" ALTER COLUMN "first_download" DROP DEFAULT;`, "") - sql = strings.ReplaceAll(sql, `ALTER TABLE "{{users}}" ALTER COLUMN "first_upload" DROP DEFAULT;`, "") - } - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 21, true) -} - -func updatePgSQLDatabaseFrom21To22(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 21 -> 22") - providerLog(logger.LevelInfo, "updating database schema version: 21 -> 22") - sql := strings.ReplaceAll(pgsqlV22SQL, "{{admins_groups_mapping}}", sqlTableAdminsGroupsMapping) - sql = strings.ReplaceAll(sql, "{{admins}}", sqlTableAdmins) - sql = strings.ReplaceAll(sql, "{{groups}}", sqlTableGroups) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 22, true) -} - -func updatePgSQLDatabaseFrom22To23(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 22 -> 23") - providerLog(logger.LevelInfo, "updating database schema version: 22 -> 23") - sql := strings.ReplaceAll(pgsqlV23SQL, "{{nodes}}", sqlTableNodes) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 23, true) -} - -func downgradePgSQLDatabaseFrom20To19(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 20 -> 19") - providerLog(logger.LevelInfo, "downgrading database schema version: 20 -> 19") - sql := strings.ReplaceAll(pgsqlV20DownSQL, "{{events_actions}}", sqlTableEventsActions) - sql = strings.ReplaceAll(sql, "{{events_rules}}", sqlTableEventsRules) - sql = strings.ReplaceAll(sql, "{{rules_actions_mapping}}", sqlTableRulesActionsMapping) - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - sql = strings.ReplaceAll(sql, "{{tasks}}", sqlTableTasks) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 19, false) -} - -func downgradePgSQLDatabaseFrom21To20(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 21 -> 20") - providerLog(logger.LevelInfo, "downgrading database schema version: 21 -> 20") - sql := strings.ReplaceAll(pgsqlV21DownSQL, "{{users}}", sqlTableUsers) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 20, false) -} - -func downgradePgSQLDatabaseFrom22To21(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 22 -> 21") - providerLog(logger.LevelInfo, "downgrading database schema version: 22 -> 21") - sql := pgsqlV22DownSQL - if config.Driver == CockroachDataProviderName { - sql = strings.ReplaceAll(sql, `ALTER TABLE "{{admins_groups_mapping}}" DROP CONSTRAINT "{{prefix}}unique_admin_group_mapping";`, - `DROP INDEX "{{prefix}}unique_admin_group_mapping" CASCADE;`) - } - sql = strings.ReplaceAll(sql, "{{admins_groups_mapping}}", sqlTableAdminsGroupsMapping) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 21, false) -} - -func downgradePgSQLDatabaseFrom23To22(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 23 -> 22") - providerLog(logger.LevelInfo, "downgrading database schema version: 23 -> 22") - sql := strings.ReplaceAll(pgsqlV23DownSQL, "{{nodes}}", sqlTableNodes) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 22, false) -} diff --git a/internal/dataprovider/sqlite.go b/internal/dataprovider/sqlite.go index 47628ca3..28ccc1e1 100644 --- a/internal/dataprovider/sqlite.go +++ b/internal/dataprovider/sqlite.go @@ -24,7 +24,6 @@ import ( "errors" "fmt" "path/filepath" - "strings" "time" // we import go-sqlite3 here to be able to disable SQLite support using a build tag @@ -89,7 +88,8 @@ CREATE TABLE "{{users}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "user "filters" text NULL, "filesystem" text NULL, "additional_info" text NULL, "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "email" varchar(255) NULL, "upload_data_transfer" integer NOT NULL, "download_data_transfer" integer NOT NULL, "total_data_transfer" integer NOT NULL, "used_upload_data_transfer" integer NOT NULL, -"used_download_data_transfer" integer NOT NULL); +"used_download_data_transfer" integer NOT NULL, "deleted_at" bigint NOT NULL, "first_download" bigint NOT NULL, +"first_upload" bigint NOT NULL); CREATE TABLE "{{groups_folders_mapping}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "folder_id" integer NOT NULL REFERENCES "{{folders}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, "group_id" integer NOT NULL REFERENCES "{{groups}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, @@ -114,29 +114,7 @@ CREATE TABLE "{{api_keys}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "n "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "last_use_at" bigint NOT NULL, "expires_at" bigint NOT NULL, "description" text NULL, "admin_id" integer NULL REFERENCES "{{admins}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, "user_id" integer NULL REFERENCES "{{users}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED); -CREATE INDEX "{{prefix}}groups_updated_at_idx" ON "{{groups}}" ("updated_at"); -CREATE INDEX "{{prefix}}users_folders_mapping_folder_id_idx" ON "{{users_folders_mapping}}" ("folder_id"); -CREATE INDEX "{{prefix}}users_folders_mapping_user_id_idx" ON "{{users_folders_mapping}}" ("user_id"); -CREATE INDEX "{{prefix}}users_groups_mapping_group_id_idx" ON "{{users_groups_mapping}}" ("group_id"); -CREATE INDEX "{{prefix}}users_groups_mapping_user_id_idx" ON "{{users_groups_mapping}}" ("user_id"); -CREATE INDEX "{{prefix}}groups_folders_mapping_folder_id_idx" ON "{{groups_folders_mapping}}" ("folder_id"); -CREATE INDEX "{{prefix}}groups_folders_mapping_group_id_idx" ON "{{groups_folders_mapping}}" ("group_id"); -CREATE INDEX "{{prefix}}api_keys_admin_id_idx" ON "{{api_keys}}" ("admin_id"); -CREATE INDEX "{{prefix}}api_keys_user_id_idx" ON "{{api_keys}}" ("user_id"); -CREATE INDEX "{{prefix}}users_updated_at_idx" ON "{{users}}" ("updated_at"); -CREATE INDEX "{{prefix}}shares_user_id_idx" ON "{{shares}}" ("user_id"); -CREATE INDEX "{{prefix}}defender_hosts_updated_at_idx" ON "{{defender_hosts}}" ("updated_at"); -CREATE INDEX "{{prefix}}defender_hosts_ban_time_idx" ON "{{defender_hosts}}" ("ban_time"); -CREATE INDEX "{{prefix}}defender_events_date_time_idx" ON "{{defender_events}}" ("date_time"); -CREATE INDEX "{{prefix}}defender_events_host_id_idx" ON "{{defender_events}}" ("host_id"); -CREATE INDEX "{{prefix}}active_transfers_connection_id_idx" ON "{{active_transfers}}" ("connection_id"); -CREATE INDEX "{{prefix}}active_transfers_transfer_id_idx" ON "{{active_transfers}}" ("transfer_id"); -CREATE INDEX "{{prefix}}active_transfers_updated_at_idx" ON "{{active_transfers}}" ("updated_at"); -CREATE INDEX "{{prefix}}shared_sessions_type_idx" ON "{{shared_sessions}}" ("type"); -CREATE INDEX "{{prefix}}shared_sessions_timestamp_idx" ON "{{shared_sessions}}" ("timestamp"); -INSERT INTO {{schema_version}} (version) VALUES (19); -` - sqliteV20SQL = `CREATE TABLE "{{events_rules}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, +CREATE TABLE "{{events_rules}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "name" varchar(255) NOT NULL UNIQUE, "description" varchar(512) NULL, "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "trigger" integer NOT NULL, "conditions" text NOT NULL, "deleted_at" bigint NOT NULL); CREATE TABLE "{{events_actions}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "name" varchar(255) NOT NULL UNIQUE, @@ -148,35 +126,40 @@ CREATE TABLE "{{rules_actions_mapping}}" ("id" integer NOT NULL PRIMARY KEY AUTO CONSTRAINT "{{prefix}}unique_rule_action_mapping" UNIQUE ("rule_id", "action_id")); CREATE TABLE "{{tasks}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "name" varchar(255) NOT NULL UNIQUE, "updated_at" bigint NOT NULL, "version" bigint NOT NULL); -ALTER TABLE "{{users}}" ADD COLUMN "deleted_at" bigint DEFAULT 0 NOT NULL; +CREATE TABLE "{{admins_groups_mapping}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, +"admin_id" integer NOT NULL REFERENCES "{{admins}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, +"group_id" integer NOT NULL REFERENCES "{{groups}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, +"options" text NOT NULL, CONSTRAINT "{{prefix}}unique_admin_group_mapping" UNIQUE ("admin_id", "group_id")); +CREATE INDEX "{{prefix}}users_folders_mapping_folder_id_idx" ON "{{users_folders_mapping}}" ("folder_id"); +CREATE INDEX "{{prefix}}users_folders_mapping_user_id_idx" ON "{{users_folders_mapping}}" ("user_id"); +CREATE INDEX "{{prefix}}users_groups_mapping_group_id_idx" ON "{{users_groups_mapping}}" ("group_id"); +CREATE INDEX "{{prefix}}users_groups_mapping_user_id_idx" ON "{{users_groups_mapping}}" ("user_id"); +CREATE INDEX "{{prefix}}groups_folders_mapping_folder_id_idx" ON "{{groups_folders_mapping}}" ("folder_id"); +CREATE INDEX "{{prefix}}groups_folders_mapping_group_id_idx" ON "{{groups_folders_mapping}}" ("group_id"); +CREATE INDEX "{{prefix}}api_keys_admin_id_idx" ON "{{api_keys}}" ("admin_id"); +CREATE INDEX "{{prefix}}api_keys_user_id_idx" ON "{{api_keys}}" ("user_id"); +CREATE INDEX "{{prefix}}users_updated_at_idx" ON "{{users}}" ("updated_at"); +CREATE INDEX "{{prefix}}users_deleted_at_idx" ON "{{users}}" ("deleted_at"); +CREATE INDEX "{{prefix}}shares_user_id_idx" ON "{{shares}}" ("user_id"); +CREATE INDEX "{{prefix}}defender_hosts_updated_at_idx" ON "{{defender_hosts}}" ("updated_at"); +CREATE INDEX "{{prefix}}defender_hosts_ban_time_idx" ON "{{defender_hosts}}" ("ban_time"); +CREATE INDEX "{{prefix}}defender_events_date_time_idx" ON "{{defender_events}}" ("date_time"); +CREATE INDEX "{{prefix}}defender_events_host_id_idx" ON "{{defender_events}}" ("host_id"); +CREATE INDEX "{{prefix}}active_transfers_connection_id_idx" ON "{{active_transfers}}" ("connection_id"); +CREATE INDEX "{{prefix}}active_transfers_transfer_id_idx" ON "{{active_transfers}}" ("transfer_id"); +CREATE INDEX "{{prefix}}active_transfers_updated_at_idx" ON "{{active_transfers}}" ("updated_at"); +CREATE INDEX "{{prefix}}shared_sessions_type_idx" ON "{{shared_sessions}}" ("type"); +CREATE INDEX "{{prefix}}shared_sessions_timestamp_idx" ON "{{shared_sessions}}" ("timestamp"); CREATE INDEX "{{prefix}}events_rules_updated_at_idx" ON "{{events_rules}}" ("updated_at"); CREATE INDEX "{{prefix}}events_rules_deleted_at_idx" ON "{{events_rules}}" ("deleted_at"); CREATE INDEX "{{prefix}}events_rules_trigger_idx" ON "{{events_rules}}" ("trigger"); CREATE INDEX "{{prefix}}rules_actions_mapping_rule_id_idx" ON "{{rules_actions_mapping}}" ("rule_id"); CREATE INDEX "{{prefix}}rules_actions_mapping_action_id_idx" ON "{{rules_actions_mapping}}" ("action_id"); CREATE INDEX "{{prefix}}rules_actions_mapping_order_idx" ON "{{rules_actions_mapping}}" ("order"); -CREATE INDEX "{{prefix}}users_deleted_at_idx" ON "{{users}}" ("deleted_at"); -` - sqliteV20DownSQL = `DROP TABLE "{{rules_actions_mapping}}"; -DROP TABLE "{{events_rules}}"; -DROP TABLE "{{events_actions}}"; -DROP TABLE "{{tasks}}"; -DROP INDEX IF EXISTS "{{prefix}}users_deleted_at_idx"; -ALTER TABLE "{{users}}" DROP COLUMN "deleted_at"; -` - sqliteV21SQL = `ALTER TABLE "{{users}}" ADD COLUMN "first_download" bigint DEFAULT 0 NOT NULL; -ALTER TABLE "{{users}}" ADD COLUMN "first_upload" bigint DEFAULT 0 NOT NULL;` - sqliteV21DownSQL = `ALTER TABLE "{{users}}" DROP COLUMN "first_upload"; -ALTER TABLE "{{users}}" DROP COLUMN "first_download"; -` - sqliteV22SQL = `CREATE TABLE "{{admins_groups_mapping}}" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, -"admin_id" integer NOT NULL REFERENCES "{{admins}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -"group_id" integer NOT NULL REFERENCES "{{groups}}" ("id") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, -"options" text NOT NULL, CONSTRAINT "{{prefix}}unique_admin_group_mapping" UNIQUE ("admin_id", "group_id")); CREATE INDEX "{{prefix}}admins_groups_mapping_admin_id_idx" ON "{{admins_groups_mapping}}" ("admin_id"); CREATE INDEX "{{prefix}}admins_groups_mapping_group_id_idx" ON "{{admins_groups_mapping}}" ("group_id"); +INSERT INTO {{schema_version}} (version) VALUES (23); ` - sqliteV22DownSQL = `DROP TABLE "{{admins_groups_mapping}}";` ) // SQLiteProvider defines the auth provider for SQLite database @@ -623,11 +606,11 @@ func (p *SQLiteProvider) initializeDatabase() error { if errors.Is(err, sql.ErrNoRows) { return errSchemaVersionEmpty } - logger.InfoToConsole("creating initial database schema, version 19") - providerLog(logger.LevelInfo, "creating initial database schema, version 19") + logger.InfoToConsole("creating initial database schema, version 23") + providerLog(logger.LevelInfo, "creating initial database schema, version 23") sql := sqlReplaceAll(sqliteInitialSQL) - return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, []string{sql}, 19, true) + return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, []string{sql}, 23, true) } func (p *SQLiteProvider) migrateDatabase() error { //nolint:dupl @@ -638,30 +621,22 @@ func (p *SQLiteProvider) migrateDatabase() error { //nolint:dupl switch version := dbVersion.Version; { case version == sqlDatabaseVersion: - providerLog(logger.LevelDebug, "sql database is up to date, current version: %v", version) + providerLog(logger.LevelDebug, "sql database is up to date, current version: %d", version) return ErrNoInitRequired - case version < 19: - err = fmt.Errorf("database schema version %v is too old, please see the upgrading docs", version) + case version < 23: + err = fmt.Errorf("database schema version %d is too old, please see the upgrading docs", version) providerLog(logger.LevelError, "%v", err) logger.ErrorToConsole("%v", err) return err - case version == 19: - return updateSQLiteDatabaseFromV19(p.dbHandle) - case version == 20: - return updateSQLiteDatabaseFromV20(p.dbHandle) - case version == 21: - return updateSQLiteDatabaseFromV21(p.dbHandle) - case version == 22: - return updateSQLiteDatabaseFromV22(p.dbHandle) default: if version > sqlDatabaseVersion { - providerLog(logger.LevelError, "database schema version %v is newer than the supported one: %v", version, + providerLog(logger.LevelError, "database schema version %d is newer than the supported one: %d", version, sqlDatabaseVersion) - logger.WarnToConsole("database schema version %v is newer than the supported one: %v", version, + logger.WarnToConsole("database schema version %d is newer than the supported one: %d", version, sqlDatabaseVersion) return nil } - return fmt.Errorf("database schema version not handled: %v", version) + return fmt.Errorf("database schema version not handled: %d", version) } } @@ -675,16 +650,8 @@ func (p *SQLiteProvider) revertDatabase(targetVersion int) error { } switch dbVersion.Version { - case 20: - return downgradeSQLiteDatabaseFromV20(p.dbHandle) - case 21: - return downgradeSQLiteDatabaseFromV21(p.dbHandle) - case 22: - return downgradeSQLiteDatabaseFromV22(p.dbHandle) - case 23: - return downgradeSQLiteDatabaseFromV23(p.dbHandle) default: - return fmt.Errorf("database schema version not handled: %v", dbVersion.Version) + return fmt.Errorf("database schema version not handled: %d", dbVersion.Version) } } @@ -693,124 +660,6 @@ func (p *SQLiteProvider) resetDatabase() error { return sqlCommonExecSQLAndUpdateDBVersion(p.dbHandle, []string{sql}, 0, false) } -func updateSQLiteDatabaseFromV19(dbHandle *sql.DB) error { - if err := updateSQLiteDatabaseFrom19To20(dbHandle); err != nil { - return err - } - return updateSQLiteDatabaseFromV20(dbHandle) -} - -func updateSQLiteDatabaseFromV20(dbHandle *sql.DB) error { - if err := updateSQLiteDatabaseFrom20To21(dbHandle); err != nil { - return err - } - return updateSQLiteDatabaseFromV21(dbHandle) -} - -func updateSQLiteDatabaseFromV21(dbHandle *sql.DB) error { - if err := updateSQLiteDatabaseFrom21To22(dbHandle); err != nil { - return err - } - return updateSQLiteDatabaseFromV22(dbHandle) -} - -func updateSQLiteDatabaseFromV22(dbHandle *sql.DB) error { - return updateSQLiteDatabaseFrom22To23(dbHandle) -} - -func downgradeSQLiteDatabaseFromV20(dbHandle *sql.DB) error { - return downgradeSQLiteDatabaseFrom20To19(dbHandle) -} - -func downgradeSQLiteDatabaseFromV21(dbHandle *sql.DB) error { - if err := downgradeSQLiteDatabaseFrom21To20(dbHandle); err != nil { - return err - } - return downgradeSQLiteDatabaseFromV20(dbHandle) -} - -func downgradeSQLiteDatabaseFromV22(dbHandle *sql.DB) error { - if err := downgradeSQLiteDatabaseFrom22To21(dbHandle); err != nil { - return err - } - return downgradeSQLiteDatabaseFromV21(dbHandle) -} - -func downgradeSQLiteDatabaseFromV23(dbHandle *sql.DB) error { - if err := downgradeSQLiteDatabaseFrom23To22(dbHandle); err != nil { - return err - } - return downgradeSQLiteDatabaseFromV22(dbHandle) -} - -func updateSQLiteDatabaseFrom19To20(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 19 -> 20") - providerLog(logger.LevelInfo, "updating database schema version: 19 -> 20") - sql := strings.ReplaceAll(sqliteV20SQL, "{{events_actions}}", sqlTableEventsActions) - sql = strings.ReplaceAll(sql, "{{events_rules}}", sqlTableEventsRules) - sql = strings.ReplaceAll(sql, "{{rules_actions_mapping}}", sqlTableRulesActionsMapping) - sql = strings.ReplaceAll(sql, "{{tasks}}", sqlTableTasks) - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 20, true) -} - -func updateSQLiteDatabaseFrom20To21(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 20 -> 21") - providerLog(logger.LevelInfo, "updating database schema version: 20 -> 21") - sql := strings.ReplaceAll(sqliteV21SQL, "{{users}}", sqlTableUsers) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 21, true) -} - -func updateSQLiteDatabaseFrom21To22(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 21 -> 22") - providerLog(logger.LevelInfo, "updating database schema version: 21 -> 22") - sql := strings.ReplaceAll(sqliteV22SQL, "{{admins_groups_mapping}}", sqlTableAdminsGroupsMapping) - sql = strings.ReplaceAll(sql, "{{admins}}", sqlTableAdmins) - sql = strings.ReplaceAll(sql, "{{groups}}", sqlTableGroups) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 22, true) -} - -func updateSQLiteDatabaseFrom22To23(dbHandle *sql.DB) error { - logger.InfoToConsole("updating database schema version: 22 -> 23") - providerLog(logger.LevelInfo, "updating database schema version: 22 -> 23") - - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{`SELECT 1`}, 23, true) -} - -func downgradeSQLiteDatabaseFrom20To19(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 20 -> 19") - providerLog(logger.LevelInfo, "downgrading database schema version: 20 -> 19") - sql := strings.ReplaceAll(sqliteV20DownSQL, "{{events_actions}}", sqlTableEventsActions) - sql = strings.ReplaceAll(sql, "{{events_rules}}", sqlTableEventsRules) - sql = strings.ReplaceAll(sql, "{{rules_actions_mapping}}", sqlTableRulesActionsMapping) - sql = strings.ReplaceAll(sql, "{{users}}", sqlTableUsers) - sql = strings.ReplaceAll(sql, "{{tasks}}", sqlTableTasks) - sql = strings.ReplaceAll(sql, "{{prefix}}", config.SQLTablesPrefix) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 19, false) -} - -func downgradeSQLiteDatabaseFrom21To20(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 21 -> 20") - providerLog(logger.LevelInfo, "downgrading database schema version: 21 -> 20") - sql := strings.ReplaceAll(sqliteV21DownSQL, "{{users}}", sqlTableUsers) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 20, false) -} - -func downgradeSQLiteDatabaseFrom22To21(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 22 -> 21") - providerLog(logger.LevelInfo, "downgrading database schema version: 22 -> 21") - sql := strings.ReplaceAll(sqliteV22DownSQL, "{{admins_groups_mapping}}", sqlTableAdminsGroupsMapping) - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{sql}, 21, false) -} - -func downgradeSQLiteDatabaseFrom23To22(dbHandle *sql.DB) error { - logger.InfoToConsole("downgrading database schema version: 23 -> 22") - providerLog(logger.LevelInfo, "downgrading database schema version: 23 -> 22") - return sqlCommonExecSQLAndUpdateDBVersion(dbHandle, []string{`SELECT 1`}, 22, false) -} - /*func setPragmaFK(dbHandle *sql.DB, value string) error { ctx, cancel := context.WithTimeout(context.Background(), longSQLQueryTimeout) defer cancel()