jkaninda/mysql-bkup
1
1
Fork 0
mirror of https://github.com/jkaninda/mysql-bkup.git synced 2025-12-06 05:29:41 +01:00
Code Issues Actions Projects Releases Wiki Activity

feat: add backup all databases

Browse Source
This commit is contained in:
Jonas Kaninda
2025-03-12 15:50:30 +01:00
parent 0bc7497512
commit d5061453b0
7 changed files with 110 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cmd/backup.go
View File

@@ -50,5 +50,6 @@ func init() {
BackupCmd.PersistentFlags().StringP("cron-expression", "e", "", "Backup cron expression (e.g., `0 0 * * *` or `@daily`)")
BackupCmd.PersistentFlags().StringP("config", "c", "", "Configuration file for multi database backup. (e.g: `/backup/config.yaml`)")
BackupCmd.PersistentFlags().BoolP("disable-compression", "", false, "Disable backup compression")
BackupCmd.PersistentFlags().BoolP("all", "a", false, "Backup all databases")
}

2
pkg/azure.go
View File

@@ -39,7 +39,7 @@ func azureBackup(db *dbConfig, config *BackupConfig) {
utils.Info("Backup database to Azure Blob Storage")
// Backup database
err := BackupDatabase(db, config.backupFileName, disableCompression)
err := BackupDatabase(db, config.backupFileName, disableCompression, config.all)
if err != nil {
recoverMode(err, "Error backing up database")
return

150
pkg/backup.go
View File

@@ -197,79 +197,131 @@ func startMultiBackup(bkConfig *BackupConfig, configFile string) {
}
// BackupDatabase backup database
func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool) error {
func BackupDatabase(db *dbConfig, backupFileName string, disableCompression, all bool) error {
storagePath = os.Getenv("STORAGE_PATH")
utils.Info("Starting database backup...")
err := os.Setenv("MYSQL_PWD", db.dbPassword)
if err != nil {
return fmt.Errorf("failed to set MYSQL_PWD environment variable: %v", err)
}
err = testDatabaseConnection(db)
//err := os.Setenv("MYSQL_PWD", db.dbPassword)
//if err != nil {
// return fmt.Errorf("failed to set MYSQL_PWD environment variable: %v", err)
//}
err := testDatabaseConnection(db)
if err != nil {
return errors.New(err.Error())
}
// Backup Database database
utils.Info("Backing up database...")
// Verify is compression is disabled
if disableCompression {
// Execute mysqldump
cmd := exec.Command("mysqldump",
fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), db.dbName,
)
output, err := cmd.Output()
if err != nil {
return fmt.Errorf("failed to backup database: %v output: %v", err, output)
}
// save output
file, err := os.Create(filepath.Join(tmpPath, backupFileName))
if err != nil {
return fmt.Errorf("failed to create backup file: %v", err)
}
defer func(file *os.File) {
err := file.Close()
if all {
// Backup all databases
// Execute mysqldump
cmd := exec.Command("mysqldump",
fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), "--all-databases", "--single-transaction", "--routines", "--triggers",
)
output, err := cmd.Output()
if err != nil {
return
return fmt.Errorf("failed to backup database: %v output: %v", err, string(output))
}
}(file)
_, err = file.Write(output)
if err != nil {
return err
// save output
file, err := os.Create(filepath.Join(tmpPath, backupFileName))
if err != nil {
return fmt.Errorf("failed to create backup file: %v", err)
}
defer func(file *os.File) {
err := file.Close()
if err != nil {
return
}
}(file)
_, err = file.Write(output)
if err != nil {
return err
}
utils.Info("Database has been backed up")
} else {
// Execute mysqldump
cmd := exec.Command("mysqldump",
fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), db.dbName,
)
output, err := cmd.Output()
if err != nil {
return fmt.Errorf("failed to backup database: %v output: %v", err, string(output))
}
// save output
file, err := os.Create(filepath.Join(tmpPath, backupFileName))
if err != nil {
return fmt.Errorf("failed to create backup file: %v", err)
}
defer func(file *os.File) {
err := file.Close()
if err != nil {
return
}
}(file)
_, err = file.Write(output)
if err != nil {
return err
}
utils.Info("Database has been backed up")
}
utils.Info("Database has been backed up")
} else {
// Execute mysqldump
cmd := exec.Command("mysqldump", fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), db.dbName)
stdout, err := cmd.StdoutPipe()
if err != nil {
return fmt.Errorf("failed to backup database: %v output: %v", err, stdout)
}
gzipCmd := exec.Command("gzip")
gzipCmd.Stdin = stdout
gzipCmd.Stdout, err = os.Create(filepath.Join(tmpPath, backupFileName))
err = gzipCmd.Start()
if err != nil {
return fmt.Errorf("failed to backup database: %v", err)
}
if err := cmd.Run(); err != nil {
log.Fatal(err)
}
if err := gzipCmd.Wait(); err != nil {
log.Fatal(err)
}
if all {
// Execute mysqldump
cmd := exec.Command("mysqldump", fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), "--all-databases", "--single-transaction", "--routines", "--triggers")
stdout, err := cmd.StdoutPipe()
if err != nil {
return fmt.Errorf("failed to backup database: %v output: %v", err, stdout)
}
gzipCmd := exec.Command("gzip")
gzipCmd.Stdin = stdout
gzipCmd.Stdout, err = os.Create(filepath.Join(tmpPath, backupFileName))
err = gzipCmd.Start()
if err != nil {
return fmt.Errorf("failed to backup database: %v", err)
}
if err := cmd.Run(); err != nil {
log.Fatal(err)
}
if err := gzipCmd.Wait(); err != nil {
log.Fatal(err)
}
} else {
// Execute mysqldump
cmd := exec.Command("mysqldump", fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), db.dbName)
stdout, err := cmd.StdoutPipe()
if err != nil {
return fmt.Errorf("failed to backup database: %v output: %v", err, stdout)
}
gzipCmd := exec.Command("gzip")
gzipCmd.Stdin = stdout
gzipCmd.Stdout, err = os.Create(filepath.Join(tmpPath, backupFileName))
err = gzipCmd.Start()
if err != nil {
return fmt.Errorf("failed to backup database: %v", err)
}
if err := cmd.Run(); err != nil {
log.Fatal(err)
}
if err := gzipCmd.Wait(); err != nil {
log.Fatal(err)
}
}
}
utils.Info("Database has been backed up")
return nil
}
func localBackup(db *dbConfig, config *BackupConfig) {
utils.Info("Backup database to local storage")
err := BackupDatabase(db, config.backupFileName, disableCompression)
err := BackupDatabase(db, config.backupFileName, disableCompression, config.all)
if err != nil {
recoverMode(err, "Error backing up database")
return

3
pkg/config.go
View File

@@ -77,6 +77,7 @@ type BackupConfig struct {
publicKey string
storage string
cronExpression string
all bool
}
type FTPConfig struct {
host string
@@ -256,6 +257,7 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
prune = true
}
disableCompression, _ = cmd.Flags().GetBool("disable-compression")
all, _ := cmd.Flags().GetBool("all")
_, _ = cmd.Flags().GetString("mode")
passphrase := os.Getenv("GPG_PASSPHRASE")
_ = utils.GetEnv(cmd, "path", "AWS_S3_PATH")
@@ -281,6 +283,7 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
config.publicKey = publicKeyFile
config.usingKey = usingKey
config.cronExpression = cronExpression
config.all = all
return &config
}

2
pkg/migrate.go
View File

@@ -51,7 +51,7 @@ func StartMigration(cmd *cobra.Command) {
conf := &RestoreConfig{}
conf.file = backupFileName
// Backup source Database
err := BackupDatabase(dbConf, backupFileName, true)
err := BackupDatabase(dbConf, backupFileName, true, false)
if err != nil {
utils.Fatal("Error backing up database: %s", err)
}

4
pkg/remote.go
View File

@@ -39,7 +39,7 @@ import (
func sshBackup(db *dbConfig, config *BackupConfig) {
utils.Info("Backup database to Remote server")
// Backup database
err := BackupDatabase(db, config.backupFileName, disableCompression)
err := BackupDatabase(db, config.backupFileName, disableCompression, config.all)
if err != nil {
recoverMode(err, "Error backing up database")
return
@@ -160,7 +160,7 @@ func ftpBackup(db *dbConfig, config *BackupConfig) {
utils.Info("Backup database to the remote FTP server")
// Backup database
err := BackupDatabase(db, config.backupFileName, disableCompression)
err := BackupDatabase(db, config.backupFileName, disableCompression, config.all)
if err != nil {
recoverMode(err, "Error backing up database")
return

2
pkg/s3.go
View File

@@ -39,7 +39,7 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
utils.Info("Backup database to s3 storage")
// Backup database
err := BackupDatabase(db, config.backupFileName, disableCompression)
err := BackupDatabase(db, config.backupFileName, disableCompression, config.all)
if err != nil {
recoverMode(err, "Error backing up database")
return