chore: comment code

chore(deps): bump github.com/jkaninda/go-utils from 0.0.0-20250122060806-26119182077a to 0.1.1

.golangci.yml

@@ -27,6 +27,7 @@ linters:
     - gosimple
     - govet
     - ineffassign
+    # - lll
     - misspell
     - nakedret
     - prealloc

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.23.5 AS build
+FROM golang:1.24.0 AS build
 WORKDIR /app
 ARG appVersion=""
 
@@ -10,7 +10,7 @@ RUN go mod download
 # Build
 RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-X 'github.com/jkaninda/mysql-bkup/utils.Version=${appVersion}'" -o /app/mysql-bkup
 
-FROM alpine:3.21.2
+FROM alpine:3.21.3
 ENV TZ=UTC
 ARG WORKDIR="/config"
 ARG BACKUPDIR="/backup"

README.md

@@ -74,6 +74,7 @@ To run a one time backup, bind your local volume to `/backup` in the container a
  docker run --rm --network your_network_name \
  -v $PWD/backup:/backup/ \
  -e "DB_HOST=dbhost" \
+ -e "DB_PORT=3306" \
  -e "DB_USERNAME=username" \
  -e "DB_PASSWORD=password" \
  jkaninda/mysql-bkup backup -d database_name
@@ -87,7 +88,19 @@ Alternatively, pass a `--env-file` in order to use a full config as described be
  -v $PWD/backup:/backup/ \
  jkaninda/mysql-bkup backup -d database_name
 ```
+### Simple restore using Docker CLI
 
+To restore a database, bind your local volume to `/backup` in the container and run the `restore` command:
+
+```shell
+ docker run --rm --network your_network_name \
+ -v $PWD/backup:/backup/ \
+ -e "DB_HOST=dbhost" \
+ -e "DB_PORT=3306" \
+ -e "DB_USERNAME=username" \
+ -e "DB_PASSWORD=password" \
+ jkaninda/mysql-bkup restore -d database_name -f backup_file.sql.gz
+```
 ### Simple backup in docker compose file
 
 ```yaml

cmd/backup.go

@@ -50,5 +50,7 @@ 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")
+	BackupCmd.PersistentFlags().BoolP("single-file", "", false, "Backup all databases in a single file")
 
 }

cmd/root.go

@@ -38,7 +38,6 @@ var rootCmd = &cobra.Command{
 	Example: utils.MainExample,
 	Version: appVersion,
 }
-var operation = ""
 
 // Execute adds all child commands to the root command and sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the rootCmd.

docs/quickstart/index.md

@@ -18,6 +18,7 @@ To run a one-time backup, bind your local volume to `/backup` in the container a
 docker run --rm --network your_network_name \
   -v $PWD/backup:/backup/ \
   -e "DB_HOST=dbhost" \
+  -e "DB_PORT=3306" \
   -e "DB_USERNAME=username" \
   -e "DB_PASSWORD=password" \
   jkaninda/mysql-bkup backup -d database_name
@@ -34,6 +35,19 @@ docker run --rm --network your_network_name \
   jkaninda/mysql-bkup backup -d database_name
 ```
 
+### Simple restore using Docker CLI
+
+To restore a database, bind your local volume to `/backup` in the container and run the `restore` command:
+
+```shell
+ docker run --rm --network your_network_name \
+ -v $PWD/backup:/backup/ \
+ -e "DB_HOST=dbhost" \
+ -e "DB_PORT=3306" \
+ -e "DB_USERNAME=username" \
+ -e "DB_PASSWORD=password" \
+ jkaninda/mysql-bkup restore -d database_name -f backup_file.sql.gz
+```
 ---
 
 ## Simple Backup Using Docker Compose

go.mod

@@ -2,14 +2,15 @@ module github.com/jkaninda/mysql-bkup
 
 go 1.23.2
 
-require github.com/spf13/pflag v1.0.5 // indirect
+require github.com/spf13/pflag v1.0.6 // indirect
 
 require (
 	github.com/go-mail/mail v2.3.1+incompatible
 	github.com/jkaninda/encryptor v0.0.0-20241111100652-926393c9437e
 	github.com/jkaninda/go-storage v0.1.3
+	github.com/jkaninda/go-utils v0.1.1
 	github.com/robfig/cron/v3 v3.0.1
-	github.com/spf13/cobra v1.8.1
+	github.com/spf13/cobra v1.9.1
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -26,7 +27,6 @@ require (
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jkaninda/go-utils v0.0.0-20250122060806-26119182077a // indirect
 	github.com/jlaffaye/ftp v0.2.0 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect

go.sum

@@ -22,7 +22,7 @@ github.com/bramvdbogaerde/go-scp v1.5.0 h1:a9BinAjTfQh273eh7vd3qUgmBC+bx+3TRDtkZ
 github.com/bramvdbogaerde/go-scp v1.5.0/go.mod h1:on2aH5AxaFb2G0N5Vsdy6B0Ml7k9HuHSwfo1y0QzAbQ=
 github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
 github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -43,10 +43,8 @@ github.com/jkaninda/encryptor v0.0.0-20241111100652-926393c9437e h1:jtFKZHt/PLGQ
 github.com/jkaninda/encryptor v0.0.0-20241111100652-926393c9437e/go.mod h1:Y1EXpPWQ9PNd7y7E6ez3xgnzZc8fuDWXwX/1/dXNCE4=
 github.com/jkaninda/go-storage v0.1.3 h1:lEpHVgFLKSvjsi/6tAek96Y07za3vxmsXF2/+jiCMZU=
 github.com/jkaninda/go-storage v0.1.3/go.mod h1:zVRnLprBk/9AUz2+za6Y03MgoNYrqKLy3edVtjqMaps=
-github.com/jkaninda/go-utils v0.0.0-20250122054739-d330fecee150 h1:AgcKk58P/Z+u4DBE2MTyZ6kCweA89YUpX7TuttHS3oQ=
+github.com/jkaninda/go-utils v0.1.1 h1:PMrtXR9d51YzHo85y9Z6YVL0YyBURbRTPemHVbFDqZg=
-github.com/jkaninda/go-utils v0.0.0-20250122054739-d330fecee150/go.mod h1:pf0/U6k4JbxlablM2G4eSTZdQ2LFshfAsCK5Q8qNfGo=
+github.com/jkaninda/go-utils v0.1.1/go.mod h1:pf0/U6k4JbxlablM2G4eSTZdQ2LFshfAsCK5Q8qNfGo=
-github.com/jkaninda/go-utils v0.0.0-20250122060806-26119182077a h1:ZTpKujQGhEF266RWkD2cXnCsafk3R2+sGtfbzCQSs1s=
-github.com/jkaninda/go-utils v0.0.0-20250122060806-26119182077a/go.mod h1:pf0/U6k4JbxlablM2G4eSTZdQ2LFshfAsCK5Q8qNfGo=
 github.com/jlaffaye/ftp v0.2.0 h1:lXNvW7cBu7R/68bknOX3MrRIIqZ61zELs1P2RAiA3lg=
 github.com/jlaffaye/ftp v0.2.0/go.mod h1:is2Ds5qkhceAPy2xD6RLI6hmp/qysSoymZ+Z2uTnspI=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
@@ -70,10 +68,10 @@ github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzG
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
-github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

pkg/azure.go

@@ -39,7 +39,11 @@ func azureBackup(db *dbConfig, config *BackupConfig) {
 	utils.Info("Backup database to Azure Blob Storage")
 
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.singleFile)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -100,7 +104,7 @@ func azureBackup(db *dbConfig, config *BackupConfig) {
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup successfully completed in %s", duration)
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
 }
 func azureRestore(db *dbConfig, conf *RestoreConfig) {
 	utils.Info("Restore database from Azure Blob storage")

pkg/backup.go

@@ -26,6 +26,7 @@ SOFTWARE.
 package pkg
 
 import (
+	"bytes"
 	"fmt"
 	"github.com/jkaninda/encryptor"
 	"github.com/jkaninda/go-storage/pkg/local"
@@ -33,10 +34,10 @@ import (
 	"github.com/jkaninda/mysql-bkup/utils"
 	"github.com/robfig/cron/v3"
 	"github.com/spf13/cobra"
-	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"time"
 )
 
@@ -49,7 +50,7 @@ func StartBackup(cmd *cobra.Command) {
 	if err != nil {
 		dbConf = initDbConfig(cmd)
 		if config.cronExpression == "" {
-			BackupTask(dbConf, config)
+			createBackupTask(dbConf, config)
 		} else {
 			if utils.IsValidCronExpression(config.cronExpression) {
 				scheduledMode(dbConf, config)
@@ -72,14 +73,18 @@ func scheduledMode(db *dbConfig, config *BackupConfig) {
 
 	// Test backup
 	utils.Info("Testing backup configurations...")
-	testDatabaseConnection(db)
+	err := testDatabaseConnection(db)
+	if err != nil {
+		utils.Error("Error connecting to database: %s", db.dbName)
+		utils.Fatal("Error: %s", err)
+	}
 	utils.Info("Testing backup configurations...done")
 	utils.Info("Creating backup job...")
 	// Create a new cron instance
 	c := cron.New()
 
-	_, err := c.AddFunc(config.cronExpression, func() {
+	_, err = c.AddFunc(config.cronExpression, func() {
-		BackupTask(db, config)
+		createBackupTask(db, config)
 		utils.Info("Next backup time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
 
 	})
@@ -101,28 +106,59 @@ func multiBackupTask(databases []Database, bkConfig *BackupConfig) {
 		if db.Path != "" {
 			bkConfig.remotePath = db.Path
 		}
-		BackupTask(getDatabase(db), bkConfig)
+		createBackupTask(getDatabase(db), bkConfig)
 	}
 }
 
-// BackupTask backups database
+// createBackupTask backup task
-func BackupTask(db *dbConfig, config *BackupConfig) {
+func createBackupTask(db *dbConfig, config *BackupConfig) {
+	if config.all && !config.singleFile {
+		backupAll(db, config)
+	} else {
+		backupTask(db, config)
+	}
+}
+
+// backupAll backup all databases
+func backupAll(db *dbConfig, config *BackupConfig) {
+	databases, err := listDatabases(*db)
+	if err != nil {
+		utils.Fatal("Error listing databases: %s", err)
+	}
+	for _, dbName := range databases {
+		if dbName == "information_schema" || dbName == "performance_schema" || dbName == "mysql" || dbName == "sys" || dbName == "innodb" || dbName == "Database" {
+			continue
+		}
+		db.dbName = dbName
+		config.backupFileName = fmt.Sprintf("%s_%s.sql.gz", dbName, time.Now().Format("20060102_150405"))
+		backupTask(db, config)
+	}
+
+}
+
+// backupTask backup task
+func backupTask(db *dbConfig, config *BackupConfig) {
 	utils.Info("Starting backup task...")
 	startTime = time.Now()
+	prefix := db.dbName
+	if config.all && config.singleFile {
+		prefix = "all_databases"
+	}
 	// Generate file name
-	backupFileName := fmt.Sprintf("%s_%s.sql.gz", db.dbName, time.Now().Format("20060102_150405"))
+	backupFileName := fmt.Sprintf("%s_%s.sql.gz", prefix, time.Now().Format("20060102_150405"))
 	if config.disableCompression {
-		backupFileName = fmt.Sprintf("%s_%s.sql", db.dbName, time.Now().Format("20060102_150405"))
+		backupFileName = fmt.Sprintf("%s_%s.sql", prefix, time.Now().Format("20060102_150405"))
 	}
 	config.backupFileName = backupFileName
-	switch config.storage {
+	s := strings.ToLower(config.storage)
+	switch s {
 	case "local":
 		localBackup(db, config)
-	case "s3", "S3":
+	case "s3":
 		s3Backup(db, config)
-	case "ssh", "SSH", "remote", "sftp":
+	case "ssh", "remote", "sftp":
 		sshBackup(db, config)
-	case "ftp", "FTP":
+	case "ftp":
 		ftpBackup(db, config)
 	case "azure":
 		azureBackup(db, config)
@@ -130,6 +166,8 @@ func BackupTask(db *dbConfig, config *BackupConfig) {
 		localBackup(db, config)
 	}
 }
+
+// startMultiBackup start multi backup
 func startMultiBackup(bkConfig *BackupConfig, configFile string) {
 	utils.Info("Starting Multi backup task...")
 	conf, err := readConf(configFile)
@@ -147,6 +185,7 @@ func startMultiBackup(bkConfig *BackupConfig, configFile string) {
 	if bkConfig.cronExpression == "" {
 		multiBackupTask(conf.Databases, bkConfig)
 	} else {
+		backupRescueMode = conf.BackupRescueMode
 		// Check if cronExpression is valid
 		if utils.IsValidCronExpression(bkConfig.cronExpression) {
 			utils.Info("Running backup in Scheduled mode")
@@ -157,7 +196,11 @@ func startMultiBackup(bkConfig *BackupConfig, configFile string) {
 			// Test backup
 			utils.Info("Testing backup configurations...")
 			for _, db := range conf.Databases {
-				testDatabaseConnection(getDatabase(db))
+				err = testDatabaseConnection(getDatabase(db))
+				if err != nil {
+					recoverMode(err, fmt.Sprintf("Error connecting to database: %s", db.Name))
+					continue
+				}
 			}
 			utils.Info("Testing backup configurations...done")
 			utils.Info("Creating backup job...")
@@ -187,78 +230,83 @@ func startMultiBackup(bkConfig *BackupConfig, configFile string) {
 }
 
 // BackupDatabase backup database
-func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool) {
+func BackupDatabase(db *dbConfig, backupFileName string, disableCompression, all, singleFile bool) error {
 	storagePath = os.Getenv("STORAGE_PATH")
-
 	utils.Info("Starting database backup...")
 
-	err := os.Setenv("MYSQL_PWD", db.dbPassword)
+	if err := testDatabaseConnection(db); err != nil {
-	if err != nil {
+		return fmt.Errorf("database connection failed: %w", err)
-		return
 	}
-	testDatabaseConnection(db)
-	// Backup Database database
-	utils.Info("Backing up database...")
 
-	// Verify is compression is disabled
+	dumpArgs := []string{fmt.Sprintf("--defaults-file=%s", mysqlClientConfig)}
+	if all && singleFile {
+		dumpArgs = append(dumpArgs, "--all-databases", "--single-transaction", "--routines", "--triggers")
+	} else {
+		dumpArgs = append(dumpArgs, db.dbName)
+	}
+
+	backupPath := filepath.Join(tmpPath, backupFileName)
 	if disableCompression {
-		// Execute mysqldump
+		return runCommandAndSaveOutput("mysqldump", dumpArgs, backupPath)
-		cmd := exec.Command("mysqldump",
+	}
-			"-h", db.dbHost,
+	return runCommandWithCompression("mysqldump", dumpArgs, backupPath)
-			"-P", db.dbPort,
+}
-			"-u", db.dbUserName,
+
-			db.dbName,
+// runCommandAndSaveOutput runs a command and saves the output to a file
-		)
+func runCommandAndSaveOutput(command string, args []string, outputPath string) error {
+	cmd := exec.Command(command, args...)
 	output, err := cmd.Output()
 	if err != nil {
-			utils.Fatal(err.Error())
+		return fmt.Errorf("failed to execute %s: %v, output: %s", command, err, string(output))
 	}
 
-		// save output
+	return os.WriteFile(outputPath, output, 0644)
-		file, err := os.Create(filepath.Join(tmpPath, backupFileName))
-		if err != nil {
-			utils.Fatal(err.Error())
 }
-		defer func(file *os.File) {
-			err := file.Close()
-			if err != nil {
-				utils.Fatal(err.Error())
-			}
-		}(file)
 
-		_, err = file.Write(output)
+// runCommandWithCompression runs a command and compresses the output
-		if err != nil {
+func runCommandWithCompression(command string, args []string, outputPath string) error {
-			utils.Fatal(err.Error())
+	cmd := exec.Command(command, args...)
-		}
-		utils.Info("Database has been backed up")
-
-	} else {
-		// Execute mysqldump
-		cmd := exec.Command("mysqldump", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, db.dbName)
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-			log.Fatal(err)
+		return fmt.Errorf("failed to create stdout pipe: %w", err)
 	}
+
 	gzipCmd := exec.Command("gzip")
 	gzipCmd.Stdin = stdout
-		gzipCmd.Stdout, err = os.Create(filepath.Join(tmpPath, backupFileName))
+	gzipFile, err := os.Create(outputPath)
-		err = gzipCmd.Start()
 	if err != nil {
-			return
+		return fmt.Errorf("failed to create gzip file: %w", err)
+	}
+	defer func(gzipFile *os.File) {
+		err := gzipFile.Close()
+		if err != nil {
+			utils.Error("Error closing gzip file: %v", err)
+		}
+	}(gzipFile)
+	gzipCmd.Stdout = gzipFile
+
+	if err := gzipCmd.Start(); err != nil {
+		return fmt.Errorf("failed to start gzip: %w", err)
 	}
 	if err := cmd.Run(); err != nil {
-			log.Fatal(err)
+		return fmt.Errorf("failed to execute %s: %w", command, err)
 	}
 	if err := gzipCmd.Wait(); err != nil {
-			log.Fatal(err)
+		return fmt.Errorf("failed to wait for gzip completion: %w", err)
 	}
-		utils.Info("Database has been backed up")
 
+	utils.Info("Database has been backed up")
+	return nil
 }
-}
+
+// localBackup backup database to local storage
 func localBackup(db *dbConfig, config *BackupConfig) {
 	utils.Info("Backup database to local storage")
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.singleFile)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -301,9 +349,10 @@ func localBackup(db *dbConfig, config *BackupConfig) {
 	}
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup successfully completed in %s", duration)
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
 }
 
+// encryptBackup encrypt backup
 func encryptBackup(config *BackupConfig) {
 	backupFile, err := os.ReadFile(filepath.Join(tmpPath, config.backupFileName))
 	outputFile := fmt.Sprintf("%s.%s", filepath.Join(tmpPath, config.backupFileName), gpgExtension)
@@ -333,3 +382,43 @@ func encryptBackup(config *BackupConfig) {
 	}
 
 }
+
+// listDatabases list all databases
+func listDatabases(db dbConfig) ([]string, error) {
+	databases := []string{}
+	// Create the mysql client config file
+	if err := createMysqlClientConfigFile(db); err != nil {
+		return databases, fmt.Errorf(err.Error())
+	}
+	utils.Info("Listing databases...")
+	// Step 1: List all databases
+	cmd := exec.Command("mariadb", fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), "-e", "SHOW DATABASES;")
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		return databases, fmt.Errorf("failed to list databases: %s", err)
+	}
+	// Step 2: Parse the output
+	for _, _db := range strings.Split(out.String(), "\n") {
+		if _db != "" {
+			databases = append(databases, _db)
+		}
+	}
+	return databases, nil
+}
+func recoverMode(err error, msg string) {
+	if err != nil {
+		if backupRescueMode {
+			utils.NotifyError(fmt.Sprintf("%s : %v", msg, err))
+			utils.Error("Error: %s", msg)
+			utils.Error("Backup rescue mode is enabled")
+			utils.Error("Backup will continue")
+		} else {
+			utils.Error("Error: %s", msg)
+			utils.Fatal("Error: %v", err)
+			return
+		}
+	}
+
+}

pkg/config.go

@@ -42,8 +42,9 @@ type Database struct {
 	Path     string `yaml:"path"`
 }
 type Config struct {
-	Databases      []Database `yaml:"databases"`
 	CronExpression   string     `yaml:"cronExpression"`
+	BackupRescueMode bool       `yaml:"backupRescueMode"`
+	Databases        []Database `yaml:"databases"`
 }
 
 type dbConfig struct {
@@ -76,6 +77,8 @@ type BackupConfig struct {
 	publicKey          string
 	storage            string
 	cronExpression     string
+	all                bool
+	singleFile         bool
 }
 type FTPConfig struct {
 	host       string
@@ -114,7 +117,7 @@ func initDbConfig(cmd *cobra.Command) *dbConfig {
 	utils.GetEnv(cmd, "dbname", "DB_NAME")
 	dConf := dbConfig{}
 	dConf.dbHost = os.Getenv("DB_HOST")
-	dConf.dbPort = os.Getenv("DB_PORT")
+	dConf.dbPort = utils.EnvWithDefault("DB_PORT", "3306")
 	dConf.dbName = os.Getenv("DB_NAME")
 	dConf.dbUserName = os.Getenv("DB_USERNAME")
 	dConf.dbPassword = os.Getenv("DB_PASSWORD")
@@ -144,15 +147,26 @@ func getDatabase(database Database) *dbConfig {
 
 // Helper function to get environment variable or use a default value
 func getEnvOrDefault(currentValue, envKey, suffix, defaultValue string) string {
+	// Return the current value if it's already set
 	if currentValue != "" {
 		return currentValue
 	}
+
+	// Check for suffixed or prefixed environment variables if a suffix is provided
 	if suffix != "" {
-		envSuffix := os.Getenv(fmt.Sprintf("%s_%s", envKey, strings.ToUpper(suffix)))
+		suffixUpper := strings.ToUpper(suffix)
+		envSuffix := os.Getenv(fmt.Sprintf("%s_%s", envKey, suffixUpper))
 		if envSuffix != "" {
 			return envSuffix
 		}
+
+		envPrefix := os.Getenv(fmt.Sprintf("%s_%s", suffixUpper, envKey))
+		if envPrefix != "" {
+			return envPrefix
 		}
+	}
+
+	// Fall back to the default value using a helper function
 	return utils.EnvWithDefault(envKey, defaultValue)
 }
 
@@ -244,6 +258,8 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
 		prune = true
 	}
 	disableCompression, _ = cmd.Flags().GetBool("disable-compression")
+	all, _ := cmd.Flags().GetBool("all")
+	singleFile, _ := cmd.Flags().GetBool("single-file")
 	_, _ = cmd.Flags().GetString("mode")
 	passphrase := os.Getenv("GPG_PASSPHRASE")
 	_ = utils.GetEnv(cmd, "path", "AWS_S3_PATH")
@@ -269,6 +285,8 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
 	config.publicKey = publicKeyFile
 	config.usingKey = usingKey
 	config.cronExpression = cronExpression
+	config.all = all
+	config.singleFile = singleFile
 	return &config
 }
 

pkg/helper.go

@@ -27,6 +27,7 @@ package pkg
 import (
 	"bytes"
 	"fmt"
+	goutils "github.com/jkaninda/go-utils"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"gopkg.in/yaml.v3"
 	"os"
@@ -66,26 +67,30 @@ func deleteTemp() {
 }
 
 // TestDatabaseConnection tests the database connection
-func testDatabaseConnection(db *dbConfig) {
+func testDatabaseConnection(db *dbConfig) error {
-	err := os.Setenv("MYSQL_PWD", db.dbPassword)
+	// Create the mysql client config file
-	if err != nil {
+	if err := createMysqlClientConfigFile(*db); err != nil {
-		return
+		return fmt.Errorf(err.Error())
 	}
 	utils.Info("Connecting to %s database ...", db.dbName)
 	// Set database name for notification error
 	utils.DatabaseName = db.dbName
-	cmd := exec.Command("mariadb", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, db.dbName, "-e", "quit")
+
+	// Prepare the command to test the database connection
+	//cmd := exec.Command("mariadb", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, db.dbName, "-e", "quit")
+	cmd := exec.Command("mariadb", fmt.Sprintf("--defaults-file=%s", mysqlClientConfig), db.dbName, "-e", "quit")
 	// Capture the output
 	var out bytes.Buffer
 	cmd.Stdout = &out
 	cmd.Stderr = &out
-	err = cmd.Run()
-	if err != nil {
-		utils.Fatal("Error testing database connection: %v\nOutput: %s", err, out.String())
 
+	// Run the command
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to connect to database %s: %v, output: %s", db.dbName, err, out.String())
 	}
-	utils.Info("Successfully connected to %s database", db.dbName)
 
+	utils.Info("Successfully connected to %s database", db.dbName)
+	return nil
 }
 
 // checkPubKeyFile checks gpg public key
@@ -183,3 +188,16 @@ func RemoveLastExtension(filename string) string {
 	}
 	return filename
 }
+
+// Create mysql client config file
+func createMysqlClientConfigFile(db dbConfig) error {
+	caCertPath := goutils.GetStringEnvWithDefault("DB_SSL_CA", "/etc/ssl/certs/ca-certificates.crt")
+	sslMode := goutils.GetStringEnvWithDefault("DB_SSL_MODE", "0")
+	// Create the mysql client config file
+	mysqlClientConfigFile := filepath.Join(tmpPath, "my.cnf")
+	mysqlCl := fmt.Sprintf("[client]\nhost=%s\nport=%s\nuser=%s\npassword=%s\nssl-ca=%s\nssl=%s\n", db.dbHost, db.dbPort, db.dbUserName, db.dbPassword, caCertPath, sslMode)
+	if err := os.WriteFile(mysqlClientConfigFile, []byte(mysqlCl), 0644); err != nil {
+		return fmt.Errorf("failed to create mysql client config file: %v", err)
+	}
+	return nil
+}

pkg/migrate.go

@@ -51,7 +51,10 @@ func StartMigration(cmd *cobra.Command) {
 	conf := &RestoreConfig{}
 	conf.file = backupFileName
 	// Backup source Database
-	BackupDatabase(dbConf, backupFileName, true)
+	err := BackupDatabase(dbConf, backupFileName, true, false, false)
+	if err != nil {
+		utils.Fatal("Error backing up database: %s", err)
+	}
 	// Restore source database into target database
 	utils.Info("Restoring [%s] database into [%s] database...", dbConf.dbName, targetDbConf.targetDbName)
 	RestoreDatabase(&newDbConfig, conf)

pkg/remote.go

@@ -39,7 +39,11 @@ import (
 func sshBackup(db *dbConfig, config *BackupConfig) {
 	utils.Info("Backup database to Remote server")
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.singleFile)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -104,7 +108,7 @@ func sshBackup(db *dbConfig, config *BackupConfig) {
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup successfully completed in %s", duration)
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
 
 }
 func remoteRestore(db *dbConfig, conf *RestoreConfig) {
@@ -156,7 +160,11 @@ func ftpBackup(db *dbConfig, config *BackupConfig) {
 	utils.Info("Backup database to the remote FTP server")
 
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.singleFile)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -216,5 +224,5 @@ func ftpBackup(db *dbConfig, config *BackupConfig) {
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup successfully completed in %s", duration)
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
 }

pkg/restore.go

@@ -25,6 +25,7 @@ SOFTWARE.
 package pkg
 
 import (
+	"fmt"
 	"github.com/jkaninda/encryptor"
 	"github.com/jkaninda/go-storage/pkg/local"
 	"github.com/jkaninda/mysql-bkup/utils"
@@ -114,20 +115,19 @@ func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
 	}
 
 	if utils.FileExists(filepath.Join(tmpPath, conf.file)) {
-		err := os.Setenv("MYSQL_PWD", db.dbPassword)
+		err = testDatabaseConnection(db)
 		if err != nil {
-			return
+			utils.Fatal("Error connecting to the database %v", err)
 		}
-		testDatabaseConnection(db)
 		utils.Info("Restoring database...")
 
 		extension := filepath.Ext(filepath.Join(tmpPath, conf.file))
-		// Restore from compressed file / .sql.gz
+		// Restore from a compressed file / .sql.gz
 		if extension == ".gz" {
-			str := "zcat " + filepath.Join(tmpPath, conf.file) + " | mariadb -h " + db.dbHost + " -P " + db.dbPort + " -u " + db.dbUserName + " " + db.dbName
+			str := "zcat " + filepath.Join(tmpPath, conf.file) + " | mariadb " + fmt.Sprintf("--defaults-file=%s", mysqlClientConfig) + " " + db.dbName
-			_, err := exec.Command("sh", "-c", str).Output()
+			output, err := exec.Command("sh", "-c", str).Output()
 			if err != nil {
-				utils.Fatal("Error, in restoring the database  %v", err)
+				utils.Fatal("Error, in restoring the database  %v output: %v", err, output)
 			}
 			utils.Info("Restoring database... done")
 			utils.Info("Database has been restored")
@@ -135,11 +135,11 @@ func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
 			deleteTemp()
 
 		} else if extension == ".sql" {
-			// Restore from sql file
+			// Restore from SQL file
-			str := "cat " + filepath.Join(tmpPath, conf.file) + " | mariadb -h " + db.dbHost + " -P " + db.dbPort + " -u " + db.dbUserName + " " + db.dbName
+			str := "cat " + filepath.Join(tmpPath, conf.file) + " | mariadb " + fmt.Sprintf("--defaults-file=%s", mysqlClientConfig) + " " + db.dbName
-			_, err := exec.Command("sh", "-c", str).Output()
+			output, err := exec.Command("sh", "-c", str).Output()
 			if err != nil {
-				utils.Fatal("Error in restoring the database %v", err)
+				utils.Fatal("Error, in restoring the database  %v output: %v", err, output)
 			}
 			utils.Info("Restoring database... done")
 			utils.Info("Database has been restored")

pkg/s3.go

@@ -39,7 +39,11 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 
 	utils.Info("Backup database to s3 storage")
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.singleFile)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -103,7 +107,7 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup successfully completed in %s", duration)
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
 
 }
 func s3Restore(db *dbConfig, conf *RestoreConfig) {

pkg/var.go

@@ -24,7 +24,10 @@ SOFTWARE.
 
 package pkg
 
-import "time"
+import (
+	"path/filepath"
+	"time"
+)
 
 const tmpPath = "/tmp/backup"
 const gpgHome = "/config/gnupg"
@@ -42,6 +45,8 @@ var (
 	usingKey                 = false
 	backupSize         int64 = 0
 	startTime                = time.Now()
+	backupRescueMode         = false
+	mysqlClientConfig        = filepath.Join(tmpPath, "my.cnf")
 )
 
 // dbHVars Required environment variables for database
@@ -61,13 +66,6 @@ var tdbRVars = []string{
 var dbConf *dbConfig
 var targetDbConf *targetDbConfig
 
-// sshVars Required environment variables for SSH remote server storage
-var sshVars = []string{
-	"SSH_USER",
-	"SSH_HOST_NAME",
-	"SSH_PORT",
-	"REMOTE_PATH",
-}
 var ftpVars = []string{
 	"FTP_HOST_NAME",
 	"FTP_USER",

templates/email-error.tmpl

@@ -60,10 +60,10 @@
 
     <p>We recommend investigating the issue as soon as possible to prevent potential data loss or service disruptions.</p>
 
-    <p>For more information, visit the <a href="https://jkaninda.github.io/pg-bkup">pg-bkup documentation</a>.</p>
+    <p>For more information, visit the <a href="https://jkaninda.github.io/mysql-bkup">mysql-bkup documentation</a>.</p>
 
     <footer>
-        &copy; 2024 <a href="https://github.com/jkaninda/pg-bkup">pg-bkup</a> | Automated Backup System
+        &copy; 2024 <a href="https://github.com/jkaninda/mysql-bkup">mysql-bkup</a> | Automated Backup System
     </footer>
 </body>
 </html>