Add SSH storage, add database backup encrypt and decrypt

pkg/backup.go

@@ -17,6 +17,7 @@ import (
 )
 
 func StartBackup(cmd *cobra.Command) {
+	_, _ = cmd.Flags().GetString("operation")
 	//Set env
 	utils.SetEnv("STORAGE_PATH", storagePath)
 	utils.GetEnv(cmd, "dbname", "DB_NAME")
@@ -24,23 +25,41 @@ func StartBackup(cmd *cobra.Command) {
 	utils.GetEnv(cmd, "period", "SCHEDULE_PERIOD")
 
 	//Get flag value and set env
-	s3Path = utils.GetEnv(cmd, "path", "S3_PATH")
+	s3Path := utils.GetEnv(cmd, "path", "AWS_S3_PATH")
+	remotePath := utils.GetEnv(cmd, "path", "SSH_REMOTE_PATH")
 	storage = utils.GetEnv(cmd, "storage", "STORAGE")
 	file = utils.GetEnv(cmd, "file", "FILE_NAME")
-	disableCompression, _ = cmd.Flags().GetBool("disable-compression")
-	keepLast, _ := cmd.Flags().GetInt("keep-last")
+	backupRetention, _ := cmd.Flags().GetInt("keep-last")
 	prune, _ := cmd.Flags().GetBool("prune")
+	disableCompression, _ = cmd.Flags().GetBool("disable-compression")
 	executionMode, _ = cmd.Flags().GetString("mode")
+	dbName = os.Getenv("DB_NAME")
+	gpqPassphrase := os.Getenv("GPG_PASSPHRASE")
+	//
+	if gpqPassphrase != "" {
+		encryption = true
+	}
+
+	//Generate file name
+	backupFileName := fmt.Sprintf("%s_%s.sql.gz", dbName, time.Now().Format("20060102_150405"))
+	if disableCompression {
+		backupFileName = fmt.Sprintf("%s_%s.sql", dbName, time.Now().Format("20060102_150405"))
+	}
 
 	if executionMode == "default" {
-		if storage == "s3" {
-			utils.Info("Backup database to s3 storage")
-			s3Backup(disableCompression, s3Path, prune, keepLast)
-		} else {
-			utils.Info("Backup database to local storage")
-			BackupDatabase(disableCompression, prune, keepLast)
-
+		switch storage {
+		case "s3":
+			s3Backup(backupFileName, s3Path, disableCompression, prune, backupRetention, encryption)
+		case "local":
+			localBackup(backupFileName, disableCompression, prune, backupRetention, encryption)
+		case "ssh", "remote":
+			sshBackup(backupFileName, remotePath, disableCompression, prune, backupRetention, encryption)
+		case "ftp":
+			utils.Fatal("Not supported storage type: %s", storage)
+		default:
+			localBackup(backupFileName, disableCompression, prune, backupRetention, encryption)
 		}
+
 	} else if executionMode == "scheduled" {
 		scheduledMode()
 	} else {
@@ -71,9 +90,9 @@ func scheduledMode() {
 	cmd := exec.Command("supervisord", "-c", supervisorConfig)
 	err := cmd.Start()
 	if err != nil {
-		utils.Fatal("Failed to start supervisord: %v", err)
+		utils.Fatal(fmt.Sprintf("Failed to start supervisord: %v", err))
 	}
-	utils.Info("Starting backup job...")
+	utils.Info("Backup job started")
 	defer func() {
 		if err := cmd.Process.Kill(); err != nil {
 			utils.Info("Failed to kill supervisord process: %v", err)
@@ -82,11 +101,11 @@ func scheduledMode() {
 		}
 	}()
 	if _, err := os.Stat(cronLogFile); os.IsNotExist(err) {
-		utils.Fatal("Log file %s does not exist.", cronLogFile)
+		utils.Fatal(fmt.Sprintf("Log file %s does not exist.", cronLogFile))
 	}
 	t, err := tail.TailFile(cronLogFile, tail.Config{Follow: true})
 	if err != nil {
-		utils.Fatalf("Failed to tail file: %v", err)
+		utils.Fatal("Failed to tail file: %v", err)
 	}
 
 	// Read and print new lines from the log file
@@ -96,136 +115,171 @@ func scheduledMode() {
 }
 
 // BackupDatabase backup database
-func BackupDatabase(disableCompression bool, prune bool, keepLast int) {
+func BackupDatabase(backupFileName string, disableCompression bool) {
 	dbHost = os.Getenv("DB_HOST")
-	dbPassword := os.Getenv("DB_PASSWORD")
-	dbUserName := os.Getenv("DB_USERNAME")
+	dbPassword = os.Getenv("DB_PASSWORD")
+	dbUserName = os.Getenv("DB_USERNAME")
 	dbName = os.Getenv("DB_NAME")
 	dbPort = os.Getenv("DB_PORT")
 	storagePath = os.Getenv("STORAGE_PATH")
 
-	if os.Getenv("DB_HOST") == "" || os.Getenv("DB_NAME") == "" || os.Getenv("DB_USERNAME") == "" || os.Getenv("DB_PASSWORD") == "" {
-		utils.Fatal("Please make sure all required environment variables for database are set")
-	} else {
-		utils.TestDatabaseConnection()
-		// Backup Database database
-		utils.Info("Backing up database...")
-		//Generate file name
-		bkFileName := fmt.Sprintf("%s_%s.sql.gz", dbName, time.Now().Format("20060102_150405"))
-
-		// Verify is compression is disabled
-		if disableCompression {
-			//Generate file name
-			bkFileName = fmt.Sprintf("%s_%s.sql", dbName, time.Now().Format("20060102_150405"))
-			// Execute mysqldump
-			cmd := exec.Command("mysqldump",
-				"-h", dbHost,
-				"-P", dbPort,
-				"-u", dbUserName,
-				"--password="+dbPassword,
-				dbName,
-			)
-			output, err := cmd.Output()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			// save output
-			file, err := os.Create(fmt.Sprintf("%s/%s", storagePath, bkFileName))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer file.Close()
-
-			_, err = file.Write(output)
-			if err != nil {
-				log.Fatal(err)
-			}
-			utils.Done("Database has been backed up")
-
-		} else {
-			// Execute mysqldump
-			cmd := exec.Command("mysqldump", "-h", dbHost, "-P", dbPort, "-u", dbUserName, "--password="+dbPassword, dbName)
-			stdout, err := cmd.StdoutPipe()
-			if err != nil {
-				log.Fatal(err)
-			}
-			gzipCmd := exec.Command("gzip")
-			gzipCmd.Stdin = stdout
-			gzipCmd.Stdout, err = os.Create(fmt.Sprintf("%s/%s", storagePath, bkFileName))
-			gzipCmd.Start()
-			if err != nil {
-				log.Fatal(err)
-			}
-			if err := cmd.Run(); err != nil {
-				log.Fatal(err)
-			}
-			if err := gzipCmd.Wait(); err != nil {
-				log.Fatal(err)
-			}
-			utils.Done("Database has been backed up")
-		}
-
-		//Delete old backup
-		if prune {
-			deleteOldBackup(keepLast)
-		}
-		historyFile, err := os.OpenFile(fmt.Sprintf("%s/history.txt", storagePath), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer historyFile.Close()
-		if _, err := historyFile.WriteString(bkFileName + "\n"); err != nil {
-			log.Fatal(err)
-		}
+	// dbHVars Required environment variables for database
+	var dbHVars = []string{
+		"DB_HOST",
+		"DB_PASSWORD",
+		"DB_USERNAME",
+		"DB_NAME",
 	}
-
-}
-
-func s3Backup(disableCompression bool, s3Path string, prune bool, keepLast int) {
-	// Backup Database to S3 storage
-	MountS3Storage(s3Path)
-	BackupDatabase(disableCompression, prune, keepLast)
-}
-
-func deleteOldBackup(keepLast int) {
-	utils.Info("Deleting old backups...")
-	storagePath = os.Getenv("STORAGE_PATH")
-	// Define the directory path
-	backupDir := storagePath + "/"
-	// Get current time
-	currentTime := time.Now()
-	// Delete file
-	deleteFile := func(filePath string) error {
-		err := os.Remove(filePath)
-		if err != nil {
-			utils.Fatal("Error:", err)
-		} else {
-			utils.Done("File ", filePath, " deleted successfully")
-		}
-		return err
-	}
-
-	// Walk through the directory and delete files modified more than specified days ago
-	err := filepath.Walk(backupDir, func(filePath string, fileInfo os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		// Check if it's a regular file and if it was modified more than specified days ago
-		if fileInfo.Mode().IsRegular() {
-			timeDiff := currentTime.Sub(fileInfo.ModTime())
-			if timeDiff.Hours() > 24*float64(keepLast) {
-				err := deleteFile(filePath)
-				if err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	})
-
+	err := utils.CheckEnvVars(dbHVars)
 	if err != nil {
-		utils.Fatal("Error:", err)
-		return
+		utils.Error("Please make sure all required environment variables for database are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
+
+	utils.Info("Starting database backup...")
+	utils.TestDatabaseConnection()
+
+	// Backup Database database
+	utils.Info("Backing up database...")
+
+	if disableCompression {
+		// Execute mysqldump
+		cmd := exec.Command("mysqldump",
+			"-h", dbHost,
+			"-P", dbPort,
+			"-u", dbUserName,
+			"--password="+dbPassword,
+			dbName,
+		)
+		output, err := cmd.Output()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// save output
+		file, err := os.Create(fmt.Sprintf("%s/%s", tmpPath, backupFileName))
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer file.Close()
+
+		_, err = file.Write(output)
+		if err != nil {
+			log.Fatal(err)
+		}
+		utils.Done("Database has been backed up")
+
+	} else {
+		// Execute mysqldump
+		cmd := exec.Command("mysqldump", "-h", dbHost, "-P", dbPort, "-u", dbUserName, "--password="+dbPassword, dbName)
+		stdout, err := cmd.StdoutPipe()
+		if err != nil {
+			log.Fatal(err)
+		}
+		gzipCmd := exec.Command("gzip")
+		gzipCmd.Stdin = stdout
+		gzipCmd.Stdout, err = os.Create(fmt.Sprintf("%s/%s", tmpPath, backupFileName))
+		gzipCmd.Start()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := cmd.Run(); err != nil {
+			log.Fatal(err)
+		}
+		if err := gzipCmd.Wait(); err != nil {
+			log.Fatal(err)
+		}
+		utils.Done("Database has been backed up")
+
+	}
+
+}
+func localBackup(backupFileName string, disableCompression bool, prune bool, backupRetention int, encrypt bool) {
+	utils.Info("Backup database to local storage")
+	BackupDatabase(backupFileName, disableCompression)
+	finalFileName := backupFileName
+	if encrypt {
+		encryptBackup(backupFileName)
+		finalFileName = fmt.Sprintf("%s.%s", backupFileName, gpgExtension)
+	}
+	utils.Info("Backup name is %s", finalFileName)
+	moveToBackup(finalFileName, storagePath)
+	//Delete old backup
+	if prune {
+		deleteOldBackup(backupRetention)
 	}
 }
+
+func s3Backup(backupFileName string, s3Path string, disableCompression bool, prune bool, backupRetention int, encrypt bool) {
+	bucket := utils.GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+	utils.Info("Backup database to s3 storage")
+	//Backup database
+	BackupDatabase(backupFileName, disableCompression)
+	finalFileName := backupFileName
+	if encrypt {
+		encryptBackup(backupFileName)
+		finalFileName = fmt.Sprintf("%s.%s", backupFileName, "gpg")
+	}
+	utils.Info("Uploading backup file to S3 storage...")
+	utils.Info("Backup name is %s", finalFileName)
+	err := utils.UploadFileToS3(tmpPath, finalFileName, bucket, s3Path)
+	if err != nil {
+		utils.Fatal("Error uploading file to S3: %s ", err)
+
+	}
+
+	//Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, backupFileName))
+	if err != nil {
+		fmt.Println("Error deleting file: ", err)
+
+	}
+	// Delete old backup
+	if prune {
+		err := utils.DeleteOldBackup(bucket, s3Path, backupRetention)
+		if err != nil {
+			utils.Fatal("Error deleting old backup from S3: %s ", err)
+		}
+	}
+	utils.Done("Database has been backed up and uploaded to s3 ")
+}
+func sshBackup(backupFileName, remotePath string, disableCompression bool, prune bool, backupRetention int, encrypt bool) {
+	utils.Info("Backup database to Remote server")
+	//Backup database
+	BackupDatabase(backupFileName, disableCompression)
+	finalFileName := backupFileName
+	if encrypt {
+		encryptBackup(backupFileName)
+		finalFileName = fmt.Sprintf("%s.%s", backupFileName, "gpg")
+	}
+	utils.Info("Uploading backup file to remote server...")
+	utils.Info("Backup name is %s", finalFileName)
+	err := CopyToRemote(finalFileName, remotePath)
+	if err != nil {
+		utils.Fatal("Error uploading file to the remote server: %s ", err)
+
+	}
+
+	//Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
+	if err != nil {
+		fmt.Println("Error deleting file: ", err)
+
+	}
+	if prune {
+		//TODO: Delete old backup from remote server
+		utils.Info("Deleting old backup from a remote server is not implemented yet")
+
+	}
+
+	utils.Done("Database has been backed up and uploaded to remote server ")
+}
+
+func encryptBackup(backupFileName string) {
+	gpgPassphrase := os.Getenv("GPG_PASSPHRASE")
+	err := Encrypt(filepath.Join(tmpPath, backupFileName), gpgPassphrase)
+	if err != nil {
+		utils.Fatal("Error during encrypting backup %s", err)
+	}
+
+}

pkg/config.go

@@ -0,0 +1,4 @@
+package pkg
+
+type Config struct {
+}

pkg/encrypt.go

@@ -0,0 +1,48 @@
+package pkg
+
+import (
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+func Decrypt(inputFile string, passphrase string) error {
+	utils.Info("Decrypting backup file: " + inputFile + " ...")
+	cmd := exec.Command("gpg", "--batch", "--passphrase", passphrase, "--output", RemoveLastExtension(inputFile), "--decrypt", inputFile)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		return err
+	}
+
+	utils.Info("Backup file decrypted successful!")
+	return nil
+}
+
+func Encrypt(inputFile string, passphrase string) error {
+	utils.Info("Encrypting backup...")
+	cmd := exec.Command("gpg", "--batch", "--passphrase", passphrase, "--symmetric", "--cipher-algo", algorithm, inputFile)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		return err
+	}
+
+	utils.Info("Backup file encrypted successful!")
+	return nil
+}
+
+func RemoveLastExtension(filename string) string {
+	if idx := strings.LastIndex(filename, "."); idx != -1 {
+		return filename[:idx]
+	}
+	return filename
+}

pkg/helper.go

@@ -0,0 +1,74 @@
+package pkg
+
+import (
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func copyToTmp(sourcePath string, backupFileName string) {
+	//Copy backup from storage to /tmp
+	err := utils.CopyFile(filepath.Join(sourcePath, backupFileName), filepath.Join(tmpPath, backupFileName))
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error copying file %s %s", backupFileName, err))
+
+	}
+}
+func moveToBackup(backupFileName string, destinationPath string) {
+	//Copy backup from tmp folder to storage destination
+	err := utils.CopyFile(filepath.Join(tmpPath, backupFileName), filepath.Join(destinationPath, backupFileName))
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error copying file %s %s", backupFileName, err))
+
+	}
+	//Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, backupFileName))
+	if err != nil {
+		fmt.Println("Error deleting file:", err)
+
+	}
+	utils.Done("Database has been backed up and copied to %s", filepath.Join(destinationPath, backupFileName))
+}
+func deleteOldBackup(retentionDays int) {
+	utils.Info("Deleting old backups...")
+	storagePath = os.Getenv("STORAGE_PATH")
+	// Define the directory path
+	backupDir := storagePath + "/"
+	// Get current time
+	currentTime := time.Now()
+	// Delete file
+	deleteFile := func(filePath string) error {
+		err := os.Remove(filePath)
+		if err != nil {
+			utils.Fatal(fmt.Sprintf("Error: %s", err))
+		} else {
+			utils.Done("File  %s  has been deleted successfully", filePath)
+		}
+		return err
+	}
+
+	// Walk through the directory and delete files modified more than specified days ago
+	err := filepath.Walk(backupDir, func(filePath string, fileInfo os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// Check if it's a regular file and if it was modified more than specified days ago
+		if fileInfo.Mode().IsRegular() {
+			timeDiff := currentTime.Sub(fileInfo.ModTime())
+			if timeDiff.Hours() > 24*float64(retentionDays) {
+				err := deleteFile(filePath)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error: %s", err))
+		return
+	}
+}

pkg/restore.go

@@ -17,70 +17,118 @@ func StartRestore(cmd *cobra.Command) {
 	utils.GetEnv(cmd, "port", "DB_PORT")
 
 	//Get flag value and set env
-	s3Path = utils.GetEnv(cmd, "path", "S3_PATH")
+	s3Path := utils.GetEnv(cmd, "path", "AWS_S3_PATH")
+	remotePath := utils.GetEnv(cmd, "path", "SSH_REMOTE_PATH")
 	storage = utils.GetEnv(cmd, "storage", "STORAGE")
 	file = utils.GetEnv(cmd, "file", "FILE_NAME")
 	executionMode, _ = cmd.Flags().GetString("mode")
-
-	if storage == "s3" {
-		utils.Info("Restore database from s3")
-		s3Restore(file, s3Path)
-	} else {
+	bucket := utils.GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+	switch storage {
+	case "s3":
+		restoreFromS3(file, bucket, s3Path)
+	case "local":
+		utils.Info("Restore database from local")
+		copyToTmp(storagePath, file)
+		RestoreDatabase(file)
+	case "ssh":
+		restoreFromRemote(file, remotePath)
+	case "ftp":
+		utils.Fatal("Restore from FTP is not yet supported")
+	default:
 		utils.Info("Restore database from local")
 		RestoreDatabase(file)
-
 	}
 }
 
+func restoreFromS3(file, bucket, s3Path string) {
+	utils.Info("Restore database from s3")
+	err := utils.DownloadFile(tmpPath, file, bucket, s3Path)
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error download file from s3 %s %s", file, err))
+	}
+	RestoreDatabase(file)
+}
+func restoreFromRemote(file, remotePath string) {
+	utils.Info("Restore database from remote server")
+	err := CopyFromRemote(file, remotePath)
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error download file from remote server: ", filepath.Join(remotePath, file), err))
+	}
+	RestoreDatabase(file)
+}
+
 // RestoreDatabase restore database
 func RestoreDatabase(file string) {
 	dbHost = os.Getenv("DB_HOST")
+	dbPassword = os.Getenv("DB_PASSWORD")
+	dbUserName = os.Getenv("DB_USERNAME")
 	dbName = os.Getenv("DB_NAME")
 	dbPort = os.Getenv("DB_PORT")
-	storagePath = os.Getenv("STORAGE_PATH")
+	gpgPassphrase := os.Getenv("GPG_PASSPHRASE")
 	if file == "" {
 		utils.Fatal("Error, file required")
 	}
+	// dbHVars Required environment variables for database
+	var dbHVars = []string{
+		"DB_HOST",
+		"DB_PASSWORD",
+		"DB_USERNAME",
+		"DB_NAME",
+	}
+	err := utils.CheckEnvVars(dbHVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for database are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
 
-	if os.Getenv("DB_HOST") == "" || os.Getenv("DB_NAME") == "" || os.Getenv("DB_USERNAME") == "" || os.Getenv("DB_PASSWORD") == "" || file == "" {
-		utils.Fatal("Please make sure all required environment variables are set")
-	} else {
-
-		if utils.FileExists(fmt.Sprintf("%s/%s", storagePath, file)) {
-			utils.TestDatabaseConnection()
-
-			extension := filepath.Ext(fmt.Sprintf("%s/%s", storagePath, file))
-			// Restore from compressed file / .sql.gz
-			if extension == ".gz" {
-				str := "zcat " + fmt.Sprintf("%s/%s", storagePath, file) + " | mysql -h " + os.Getenv("DB_HOST") + " -P " + os.Getenv("DB_PORT") + " -u " + os.Getenv("DB_USERNAME") + " --password=" + os.Getenv("DB_PASSWORD") + " " + os.Getenv("DB_NAME")
-				_, err := exec.Command("bash", "-c", str).Output()
-				if err != nil {
-					utils.Fatal("Error, in restoring the database")
-				}
-
-				utils.Done("Database has been restored")
-
-			} else if extension == ".sql" {
-				//Restore from sql file
-				str := "cat " + fmt.Sprintf("%s/%s", storagePath, file) + " | mysql -h " + os.Getenv("DB_HOST") + " -P " + os.Getenv("DB_PORT") + " -u " + os.Getenv("DB_USERNAME") + " --password=" + os.Getenv("DB_PASSWORD") + " " + os.Getenv("DB_NAME")
-				_, err := exec.Command("bash", "-c", str).Output()
-				if err != nil {
-					utils.Fatal("Error, in restoring the database", err)
-				}
-
-				utils.Done("Database has been restored")
-			} else {
-				utils.Fatal("Unknown file extension ", extension)
-			}
+	extension := filepath.Ext(fmt.Sprintf("%s/%s", tmpPath, file))
+	if extension == ".gpg" {
+		if gpgPassphrase == "" {
+			utils.Fatal("Error: GPG passphrase is required, your file seems to be a GPG file.\nYou need to provide GPG keys. GPG_PASSPHRASE environment variable is required.")
 
 		} else {
-			utils.Fatal("File not found in ", fmt.Sprintf("%s/%s", storagePath, file))
+			//Decrypt file
+			err := Decrypt(filepath.Join(tmpPath, file), gpgPassphrase)
+			if err != nil {
+				utils.Fatal("Error decrypting file ", file, err)
+			}
+			//Update file name
+			file = RemoveLastExtension(file)
 		}
 
 	}
-}
-func s3Restore(file, s3Path string) {
-	// Restore database from S3
-	MountS3Storage(s3Path)
-	RestoreDatabase(file)
+
+	if utils.FileExists(fmt.Sprintf("%s/%s", tmpPath, file)) {
+
+		err := os.Setenv("mysqlPASSWORD", dbPassword)
+		if err != nil {
+			return
+		}
+		utils.TestDatabaseConnection()
+
+		extension := filepath.Ext(fmt.Sprintf("%s/%s", tmpPath, file))
+		// Restore from compressed file / .sql.gz
+		if extension == ".gz" {
+			str := "zcat " + fmt.Sprintf("%s/%s", tmpPath, file) + " | mysql -h " + os.Getenv("DB_HOST") + " -P " + os.Getenv("DB_PORT") + " -u " + os.Getenv("DB_USERNAME") + " --password=" + os.Getenv("DB_PASSWORD") + " " + os.Getenv("DB_NAME")
+			_, err := exec.Command("bash", "-c", str).Output()
+			if err != nil {
+				utils.Fatal(fmt.Sprintf("Error, in restoring the database  %s", err))
+			}
+			utils.Done("Database has been restored")
+
+		} else if extension == ".sql" {
+			//Restore from sql file
+			str := "cat " + fmt.Sprintf("%s/%s", tmpPath, file) + " | mysql -h " + os.Getenv("DB_HOST") + " -P " + os.Getenv("DB_PORT") + " -u " + os.Getenv("DB_USERNAME") + " --password=" + os.Getenv("DB_PASSWORD") + " " + os.Getenv("DB_NAME")
+			_, err := exec.Command("bash", "-c", str).Output()
+			if err != nil {
+				utils.Fatal(fmt.Sprintf("Error in restoring the database %s", err))
+			}
+			utils.Done("Database has been restored")
+		} else {
+			utils.Fatal(fmt.Sprintf("Unknown file extension %s", extension))
+		}
+
+	} else {
+		utils.Fatal(fmt.Sprintf("File not found in %s", fmt.Sprintf("%s/%s", tmpPath, file)))
+	}
 }

pkg/s3fs.go

@@ -1,80 +0,0 @@
-// Package pkg /*
-/*
-Copyright © 2024 Jonas Kaninda
-*/
-package pkg
-
-import (
-	"fmt"
-	"github.com/jkaninda/mysql-bkup/utils"
-	"os"
-	"os/exec"
-)
-
-var (
-	accessKey  = ""
-	secretKey  = ""
-	bucketName = ""
-	s3Endpoint = ""
-)
-
-func S3Mount() {
-	MountS3Storage(s3Path)
-}
-
-// MountS3Storage Mount s3 storage using s3fs
-func MountS3Storage(s3Path string) {
-	accessKey = os.Getenv("ACCESS_KEY")
-	secretKey = os.Getenv("SECRET_KEY")
-	bucketName = os.Getenv("BUCKET_NAME")
-	if bucketName == "" {
-		bucketName = os.Getenv("BUCKETNAME")
-	}
-	s3Endpoint = os.Getenv("S3_ENDPOINT")
-
-	if accessKey == "" || secretKey == "" || bucketName == "" {
-		utils.Fatal("Please make sure all environment variables are set for S3")
-	} else {
-		storagePath := fmt.Sprintf("%s%s", s3MountPath, s3Path)
-		err := os.Setenv("STORAGE_PATH", storagePath)
-		if err != nil {
-			return
-		}
-
-		//Write file
-		err = utils.WriteToFile(s3fsPasswdFile, fmt.Sprintf("%s:%s", accessKey, secretKey))
-		if err != nil {
-			utils.Fatal("Error creating file")
-		}
-		//Change file permission
-		utils.ChangePermission(s3fsPasswdFile, 0600)
-
-		//Mount object storage
-		utils.Info("Mounting Object storage in ", s3MountPath)
-		if isEmpty, _ := utils.IsDirEmpty(s3MountPath); isEmpty {
-			cmd := exec.Command("s3fs", bucketName, s3MountPath,
-				"-o", "passwd_file="+s3fsPasswdFile,
-				"-o", "use_cache=/tmp/s3cache",
-				"-o", "allow_other",
-				"-o", "url="+s3Endpoint,
-				"-o", "use_path_request_style",
-			)
-
-			if err := cmd.Run(); err != nil {
-				utils.Fatal("Error mounting Object storage:", err)
-			}
-
-			if err := os.MkdirAll(storagePath, os.ModePerm); err != nil {
-				utils.Fatalf("Error creating directory %v %v", storagePath, err)
-			}
-
-		} else {
-			utils.Info("Object storage already mounted in " + s3MountPath)
-			if err := os.MkdirAll(storagePath, os.ModePerm); err != nil {
-				utils.Fatal("Error creating directory "+storagePath, err)
-			}
-
-		}
-
-	}
-}

pkg/scp.go

@@ -0,0 +1,117 @@
+package pkg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/bramvdbogaerde/go-scp"
+	"github.com/bramvdbogaerde/go-scp/auth"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"golang.org/x/crypto/ssh"
+	"golang.org/x/exp/slog"
+	"os"
+	"path/filepath"
+)
+
+func CopyToRemote(fileName, remotePath string) error {
+	sshUser := os.Getenv("SSH_USER")
+	sshPassword := os.Getenv("SSH_PASSWORD")
+	sshHostName := os.Getenv("SSH_HOST_NAME")
+	sshPort := os.Getenv("SSH_PORT")
+	sshIdentifyFile := os.Getenv("SSH_IDENTIFY_FILE")
+
+	// SSSHVars Required environment variables for SSH remote server storage
+	var sshHVars = []string{
+		"SSH_USER",
+		"SSH_REMOTE_PATH",
+		"SSH_HOST_NAME",
+		"SSH_PORT",
+	}
+	err := utils.CheckEnvVars(sshHVars)
+	if err != nil {
+		slog.Error(fmt.Sprintf("Error checking environment variables\n: %s", err))
+		os.Exit(1)
+	}
+
+	clientConfig, _ := auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+	if sshIdentifyFile != "" && utils.FileExists(sshIdentifyFile) {
+		clientConfig, _ = auth.PrivateKey(sshUser, sshIdentifyFile, ssh.InsecureIgnoreHostKey())
+
+	} else {
+		if sshPassword == "" {
+			return errors.New("SSH_PASSWORD environment variable is required if SSH_IDENTIFY_FILE is empty\n")
+		}
+		slog.Warn("Accessing the remote server using password, password is not recommended\n")
+		clientConfig, _ = auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+
+	}
+	// Create a new SCP client
+	client := scp.NewClient(fmt.Sprintf("%s:%s", sshHostName, sshPort), &clientConfig)
+
+	// Connect to the remote server
+	err = client.Connect()
+	if err != nil {
+		return errors.New("Couldn't establish a connection to the remote server\n")
+	}
+
+	// Open a file
+	file, _ := os.Open(filepath.Join(tmpPath, fileName))
+
+	// Close client connection after the file has been copied
+	defer client.Close()
+	// Close the file after it has been copied
+	defer file.Close()
+	// the context can be adjusted to provide time-outs or inherit from other contexts if this is embedded in a larger application.
+	err = client.CopyFromFile(context.Background(), *file, filepath.Join(remotePath, fileName), "0655")
+	if err != nil {
+		fmt.Println("Error while copying file ")
+		return err
+	}
+	return nil
+}
+
+func CopyFromRemote(fileName, remotePath string) error {
+	sshUser := os.Getenv("SSH_USER")
+	sshPassword := os.Getenv("SSH_PASSWORD")
+	sshHostName := os.Getenv("SSH_HOST_NAME")
+	sshPort := os.Getenv("SSH_PORT")
+	sshIdentifyFile := os.Getenv("SSH_IDENTIFY_FILE")
+
+	clientConfig, _ := auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+	if sshIdentifyFile != "" && utils.FileExists(sshIdentifyFile) {
+		clientConfig, _ = auth.PrivateKey(sshUser, sshIdentifyFile, ssh.InsecureIgnoreHostKey())
+
+	} else {
+		if sshPassword == "" {
+			return errors.New("SSH_PASSWORD environment variable is required if SSH_IDENTIFY_FILE is empty\n")
+		}
+		slog.Warn("Accessing the remote server using password, password is not recommended\n")
+		clientConfig, _ = auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+
+	}
+	// Create a new SCP client
+	client := scp.NewClient(fmt.Sprintf("%s:%s", sshHostName, sshPort), &clientConfig)
+
+	// Connect to the remote server
+	err := client.Connect()
+	if err != nil {
+		return errors.New("Couldn't establish a connection to the remote server\n")
+	}
+	// Close client connection after the file has been copied
+	defer client.Close()
+	file, err := os.OpenFile(filepath.Join(tmpPath, fileName), os.O_RDWR|os.O_CREATE, 0777)
+	if err != nil {
+		fmt.Println("Couldn't open the output file")
+	}
+	defer file.Close()
+
+	// the context can be adjusted to provide time-outs or inherit from other contexts if this is embedded in a larger application.
+	err = client.CopyFromRemote(context.Background(), file, filepath.Join(remotePath, fileName))
+
+	if err != nil {
+		fmt.Println("Error while copying file ", err)
+		return err
+	}
+	return nil
+
+}

pkg/scripts.go

@@ -15,7 +15,7 @@ func CreateCrontabScript(disableCompression bool, storage string) {
 	//task := "/usr/local/bin/backup_cron.sh"
 	touchCmd := exec.Command("touch", backupCronFile)
 	if err := touchCmd.Run(); err != nil {
-		utils.Fatalf("Error creating file %s: %v\n", backupCronFile, err)
+		utils.Fatal("Error creating file %s: %v\n", backupCronFile, err)
 	}
 	var disableC = ""
 	if disableCompression {
@@ -37,36 +37,36 @@ bkup backup --dbname %s --port %s %v
 	}
 
 	if err := utils.WriteToFile(backupCronFile, scriptContent); err != nil {
-		utils.Fatalf("Error writing to %s: %v\n", backupCronFile, err)
+		utils.Fatal("Error writing to %s: %v\n", backupCronFile, err)
 	}
 
 	chmodCmd := exec.Command("chmod", "+x", "/usr/local/bin/backup_cron.sh")
 	if err := chmodCmd.Run(); err != nil {
-		utils.Fatalf("Error changing permissions of %s: %v\n", backupCronFile, err)
+		utils.Fatal("Error changing permissions of %s: %v\n", backupCronFile, err)
 	}
 
 	lnCmd := exec.Command("ln", "-s", "/usr/local/bin/backup_cron.sh", "/usr/local/bin/backup_cron")
 	if err := lnCmd.Run(); err != nil {
-		utils.Fatalf("Error creating symbolic link: %v\n", err)
+		utils.Fatal("Error creating symbolic link: %v\n", err)
 
 	}
 
 	touchLogCmd := exec.Command("touch", cronLogFile)
 	if err := touchLogCmd.Run(); err != nil {
-		utils.Fatalf("Error creating file %s: %v\n", cronLogFile, err)
+		utils.Fatal("Error creating file %s: %v\n", cronLogFile, err)
 	}
 
 	cronJob := "/etc/cron.d/backup_cron"
 	touchCronCmd := exec.Command("touch", cronJob)
 	if err := touchCronCmd.Run(); err != nil {
-		utils.Fatalf("Error creating file %s: %v\n", cronJob, err)
+		utils.Fatal("Error creating file %s: %v\n", cronJob, err)
 	}
 
 	cronContent := fmt.Sprintf(`%s root exec /bin/bash -c ". /run/supervisord.env; /usr/local/bin/backup_cron.sh >> %s"
 `, os.Getenv("SCHEDULE_PERIOD"), cronLogFile)
 
 	if err := utils.WriteToFile(cronJob, cronContent); err != nil {
-		utils.Fatalf("Error writing to %s: %v\n", cronJob, err)
+		utils.Fatal("Error writing to %s: %v\n", cronJob, err)
 	}
 	utils.ChangePermission("/etc/cron.d/backup_cron", 0644)
 
@@ -74,5 +74,5 @@ bkup backup --dbname %s --port %s %v
 	if err := crontabCmd.Run(); err != nil {
 		utils.Fatal("Error updating crontab: ", err)
 	}
-	utils.Info("Starting backup in scheduled mode")
+	utils.Info("Backup job created.")
 }

pkg/var.go

@@ -1,18 +1,21 @@
 package pkg
 
-const s3MountPath string = "/s3mnt"
-const s3fsPasswdFile string = "/etc/passwd-s3fs"
 const cronLogFile = "/var/log/mysql-bkup.log"
+const tmpPath = "/tmp/backup"
 const backupCronFile = "/usr/local/bin/backup_cron.sh"
+const algorithm = "aes256"
+const gpgExtension = "gpg"
 
 var (
 	storage            = "local"
 	file               = ""
-	s3Path             = "/mysql-bkup"
+	dbPassword         = ""
+	dbUserName         = ""
 	dbName             = ""
 	dbHost             = ""
 	dbPort             = "3306"
 	executionMode      = "default"
 	storagePath        = "/backup"
 	disableCompression = false
+	encryption         = false
 )