refactor: refactoring of code

internal/backup.go

@@ -31,6 +31,7 @@ import (
 	"github.com/jkaninda/go-storage/pkg/local"
 	"github.com/jkaninda/go-storage/pkg/s3"
 	"github.com/jkaninda/go-storage/pkg/ssh"
+	"github.com/jkaninda/mysql-bkup/pkg/logger"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"github.com/robfig/cron/v3"
 	"github.com/spf13/cobra"
@@ -43,9 +44,9 @@ import (
 
 func StartBackup(cmd *cobra.Command) {
 	intro()
-	//Initialize backup configs
+	// Initialize backup configs
 	config := initBackupConfig(cmd)
-	//Load backup configuration file
+	// Load backup configuration file
 	configFile, err := loadConfigFile()
 	if err != nil {
 		dbConf = initDbConfig(cmd)
@@ -55,7 +56,7 @@ func StartBackup(cmd *cobra.Command) {
 			if utils.IsValidCronExpression(config.cronExpression) {
 				scheduledMode(dbConf, config)
 			} else {
-				utils.Fatal("Cron expression is not valid: %s", config.cronExpression)
+				logger.Fatal("Cron expression is not valid: %s", config.cronExpression)
 			}
 		}
 	} else {
@@ -66,22 +67,22 @@ func StartBackup(cmd *cobra.Command) {
 
 // scheduledMode Runs backup in scheduled mode
 func scheduledMode(db *dbConfig, config *BackupConfig) {
-	utils.Info("Running in Scheduled mode")
-	utils.Info("Backup cron expression:  %s", config.cronExpression)
-	utils.Info("The next scheduled time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
-	utils.Info("Storage type %s ", config.storage)
+	logger.Info("Running in Scheduled mode")
+	logger.Info("Backup cron expression:  %s", config.cronExpression)
+	logger.Info("The next scheduled time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
+	logger.Info("Storage type %s ", config.storage)
 
-	//Test backup
-	utils.Info("Testing backup configurations...")
-	BackupTask(db, config)
-	utils.Info("Testing backup configurations...done")
-	utils.Info("Creating backup job...")
+	// Test backup
+	logger.Info("Testing backup configurations...")
+	testDatabaseConnection(db)
+	logger.Info("Testing backup configurations...done")
+	logger.Info("Creating backup job...")
 	// Create a new cron instance
 	c := cron.New()
 
 	_, err := c.AddFunc(config.cronExpression, func() {
 		BackupTask(db, config)
-		utils.Info("Next backup time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
+		logger.Info("Next backup time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
 
 	})
 	if err != nil {
@@ -89,8 +90,8 @@ func scheduledMode(db *dbConfig, config *BackupConfig) {
 	}
 	// Start the cron scheduler
 	c.Start()
-	utils.Info("Creating backup job...done")
-	utils.Info("Backup job started")
+	logger.Info("Creating backup job...done")
+	logger.Info("Backup job started")
 	defer c.Stop()
 	select {}
 }
@@ -98,7 +99,7 @@ func scheduledMode(db *dbConfig, config *BackupConfig) {
 // multiBackupTask backup multi database
 func multiBackupTask(databases []Database, bkConfig *BackupConfig) {
 	for _, db := range databases {
-		//Check if path is defined in config file
+		// Check if path is defined in config file
 		if db.Path != "" {
 			bkConfig.remotePath = db.Path
 		}
@@ -108,8 +109,8 @@ func multiBackupTask(databases []Database, bkConfig *BackupConfig) {
 
 // BackupTask backups database
 func BackupTask(db *dbConfig, config *BackupConfig) {
-	utils.Info("Starting backup task...")
-	//Generate file name
+	logger.Info("Starting backup task...")
+	// Generate file name
 	backupFileName := fmt.Sprintf("%s_%s.sql.gz", db.dbName, time.Now().Format("20060102_150405"))
 	if config.disableCompression {
 		backupFileName = fmt.Sprintf("%s_%s.sql", db.dbName, time.Now().Format("20060102_150405"))
@@ -129,37 +130,42 @@ func BackupTask(db *dbConfig, config *BackupConfig) {
 	}
 }
 func startMultiBackup(bkConfig *BackupConfig, configFile string) {
-	utils.Info("Starting backup task...")
+	logger.Info("Starting backup task...")
 	conf, err := readConf(configFile)
 	if err != nil {
-		utils.Fatal("Error reading config file: %s", err)
+		logger.Fatal("Error reading config file: %s", err)
 	}
-	//Check if cronExpression is defined in config file
+	// Check if cronExpression is defined in config file
 	if conf.CronExpression != "" {
 		bkConfig.cronExpression = conf.CronExpression
 	}
+	if len(conf.Databases) == 0 {
+		logger.Fatal("No databases found")
+	}
 	// Check if cronExpression is defined
 	if bkConfig.cronExpression == "" {
 		multiBackupTask(conf.Databases, bkConfig)
 	} else {
 		// Check if cronExpression is valid
 		if utils.IsValidCronExpression(bkConfig.cronExpression) {
-			utils.Info("Running backup in Scheduled mode")
-			utils.Info("Backup cron expression:  %s", bkConfig.cronExpression)
-			utils.Info("The next scheduled time is: %v", utils.CronNextTime(bkConfig.cronExpression).Format(timeFormat))
-			utils.Info("Storage type %s ", bkConfig.storage)
+			logger.Info("Running backup in Scheduled mode")
+			logger.Info("Backup cron expression:  %s", bkConfig.cronExpression)
+			logger.Info("The next scheduled time is: %v", utils.CronNextTime(bkConfig.cronExpression).Format(timeFormat))
+			logger.Info("Storage type %s ", bkConfig.storage)
 
-			//Test backup
-			utils.Info("Testing backup configurations...")
-			multiBackupTask(conf.Databases, bkConfig)
-			utils.Info("Testing backup configurations...done")
-			utils.Info("Creating backup job...")
+			// Test backup
+			logger.Info("Testing backup configurations...")
+			for _, db := range conf.Databases {
+				testDatabaseConnection(getDatabase(db))
+			}
+			logger.Info("Testing backup configurations...done")
+			logger.Info("Creating backup job...")
 			// Create a new cron instance
 			c := cron.New()
 
 			_, err := c.AddFunc(bkConfig.cronExpression, func() {
 				multiBackupTask(conf.Databases, bkConfig)
-				utils.Info("Next backup time is: %v", utils.CronNextTime(bkConfig.cronExpression).Format(timeFormat))
+				logger.Info("Next backup time is: %v", utils.CronNextTime(bkConfig.cronExpression).Format(timeFormat))
 
 			})
 			if err != nil {
@@ -167,13 +173,13 @@ func startMultiBackup(bkConfig *BackupConfig, configFile string) {
 			}
 			// Start the cron scheduler
 			c.Start()
-			utils.Info("Creating backup job...done")
-			utils.Info("Backup job started")
+			logger.Info("Creating backup job...done")
+			logger.Info("Backup job started")
 			defer c.Stop()
 			select {}
 
 		} else {
-			utils.Fatal("Cron expression is not valid: %s", bkConfig.cronExpression)
+			logger.Fatal("Cron expression is not valid: %s", bkConfig.cronExpression)
 		}
 	}
 
@@ -181,10 +187,9 @@ func startMultiBackup(bkConfig *BackupConfig, configFile string) {
 
 // BackupDatabase backup database
 func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool) {
-
 	storagePath = os.Getenv("STORAGE_PATH")
 
-	utils.Info("Starting database backup...")
+	logger.Info("Starting database backup...")
 
 	err := os.Setenv("MYSQL_PWD", db.dbPassword)
 	if err != nil {
@@ -192,7 +197,7 @@ func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool
 	}
 	testDatabaseConnection(db)
 	// Backup Database database
-	utils.Info("Backing up database...")
+	logger.Info("Backing up database...")
 
 	// Verify is compression is disabled
 	if disableCompression {
@@ -205,21 +210,26 @@ func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool
 		)
 		output, err := cmd.Output()
 		if err != nil {
-			log.Fatal(err)
+			logger.Fatal(err.Error())
 		}
 
 		// save output
 		file, err := os.Create(filepath.Join(tmpPath, backupFileName))
 		if err != nil {
-			log.Fatal(err)
+			logger.Fatal(err.Error())
 		}
-		defer file.Close()
+		defer func(file *os.File) {
+			err := file.Close()
+			if err != nil {
+				logger.Fatal(err.Error())
+			}
+		}(file)
 
 		_, err = file.Write(output)
 		if err != nil {
-			log.Fatal(err)
+			logger.Fatal(err.Error())
 		}
-		utils.Info("Database has been backed up")
+		logger.Info("Database has been backed up")
 
 	} else {
 		// Execute mysqldump
@@ -231,9 +241,9 @@ func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool
 		gzipCmd := exec.Command("gzip")
 		gzipCmd.Stdin = stdout
 		gzipCmd.Stdout, err = os.Create(filepath.Join(tmpPath, backupFileName))
-		gzipCmd.Start()
+		err = gzipCmd.Start()
 		if err != nil {
-			log.Fatal(err)
+			return
 		}
 		if err := cmd.Run(); err != nil {
 			log.Fatal(err)
@@ -241,12 +251,12 @@ func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool
 		if err := gzipCmd.Wait(); err != nil {
 			log.Fatal(err)
 		}
-		utils.Info("Database has been backed up")
+		logger.Info("Database has been backed up")
 
 	}
 }
 func localBackup(db *dbConfig, config *BackupConfig) {
-	utils.Info("Backup database to local storage")
+	logger.Info("Backup database to local storage")
 	startTime = time.Now().Format(utils.TimeFormat())
 	BackupDatabase(db, config.backupFileName, disableCompression)
 	finalFileName := config.backupFileName
@@ -256,20 +266,20 @@ func localBackup(db *dbConfig, config *BackupConfig) {
 	}
 	fileInfo, err := os.Stat(filepath.Join(tmpPath, finalFileName))
 	if err != nil {
-		utils.Error("Error: %s", err)
+		logger.Error("Error: %s", err)
 	}
 	backupSize = fileInfo.Size()
-	utils.Info("Backup name is %s", finalFileName)
+	logger.Info("Backup name is %s", finalFileName)
 	localStorage := local.NewStorage(local.Config{
 		LocalPath:  tmpPath,
 		RemotePath: storagePath,
 	})
 	err = localStorage.Copy(finalFileName)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
-	utils.Info("Backup saved in %s", filepath.Join(storagePath, finalFileName))
-	//Send notification
+	logger.Info("Backup saved in %s", filepath.Join(storagePath, finalFileName))
+	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
 		BackupSize:     backupSize,
@@ -279,36 +289,36 @@ func localBackup(db *dbConfig, config *BackupConfig) {
 		StartTime:      startTime,
 		EndTime:        time.Now().Format(utils.TimeFormat()),
 	})
-	//Delete old backup
+	// Delete old backup
 	if config.prune {
 		err = localStorage.Prune(config.backupRetention)
 		if err != nil {
-			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+			logger.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
 		}
 
 	}
-	//Delete temp
+	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	logger.Info("Backup completed successfully")
 }
 
 func s3Backup(db *dbConfig, config *BackupConfig) {
 
-	utils.Info("Backup database to s3 storage")
+	logger.Info("Backup database to s3 storage")
 	startTime = time.Now().Format(utils.TimeFormat())
-	//Backup database
+	// Backup database
 	BackupDatabase(db, config.backupFileName, disableCompression)
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
 		finalFileName = fmt.Sprintf("%s.%s", config.backupFileName, "gpg")
 	}
-	utils.Info("Uploading backup archive to remote storage S3 ... ")
+	logger.Info("Uploading backup archive to remote storage S3 ... ")
 	awsConfig := initAWSConfig()
 	if config.remotePath == "" {
 		config.remotePath = awsConfig.remotePath
 	}
-	utils.Info("Backup name is %s", finalFileName)
+	logger.Info("Backup name is %s", finalFileName)
 	s3Storage, err := s3.NewStorage(s3.Config{
 		Endpoint:       awsConfig.endpoint,
 		Bucket:         awsConfig.bucket,
@@ -321,20 +331,20 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 		LocalPath:      tmpPath,
 	})
 	if err != nil {
-		utils.Fatal("Error creating s3 storage: %s", err)
+		logger.Fatal("Error creating s3 storage: %s", err)
 	}
 	err = s3Storage.Copy(finalFileName)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
-	//Get backup info
+	// Get backup info
 	fileInfo, err := os.Stat(filepath.Join(tmpPath, finalFileName))
 	if err != nil {
-		utils.Error("Error: %s", err)
+		logger.Error("Error: %s", err)
 	}
 	backupSize = fileInfo.Size()
 
-	//Delete backup file from tmp folder
+	// Delete backup file from tmp folder
 	err = utils.DeleteFile(filepath.Join(tmpPath, config.backupFileName))
 	if err != nil {
 		fmt.Println("Error deleting file: ", err)
@@ -344,12 +354,12 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 	if config.prune {
 		err := s3Storage.Prune(config.backupRetention)
 		if err != nil {
-			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+			logger.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
 		}
 	}
-	utils.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
-	utils.Info("Uploading backup archive to remote storage S3 ... done ")
-	//Send notification
+	logger.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
+	logger.Info("Uploading backup archive to remote storage S3 ... done ")
+	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
 		BackupSize:     backupSize,
@@ -359,67 +369,66 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 		StartTime:      startTime,
 		EndTime:        time.Now().Format(utils.TimeFormat()),
 	})
-	//Delete temp
+	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	logger.Info("Backup completed successfully")
 
 }
 func sshBackup(db *dbConfig, config *BackupConfig) {
-	utils.Info("Backup database to Remote server")
+	logger.Info("Backup database to Remote server")
 	startTime = time.Now().Format(utils.TimeFormat())
-	//Backup database
+	// Backup database
 	BackupDatabase(db, config.backupFileName, disableCompression)
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
 		finalFileName = fmt.Sprintf("%s.%s", config.backupFileName, "gpg")
 	}
-	utils.Info("Uploading backup archive to remote storage ... ")
-	utils.Info("Backup name is %s", finalFileName)
+	logger.Info("Uploading backup archive to remote storage ... ")
+	logger.Info("Backup name is %s", finalFileName)
 	sshConfig, err := loadSSHConfig()
 	if err != nil {
-		utils.Fatal("Error loading ssh config: %s", err)
+		logger.Fatal("Error loading ssh config: %s", err)
 	}
 
 	sshStorage, err := ssh.NewStorage(ssh.Config{
-		Host:         sshConfig.hostName,
-		Port:         sshConfig.port,
-		User:         sshConfig.user,
-		Password:     sshConfig.password,
-		IdentifyFile: sshConfig.identifyFile,
-		RemotePath:   config.remotePath,
-		LocalPath:    tmpPath,
+		Host:       sshConfig.hostName,
+		Port:       sshConfig.port,
+		User:       sshConfig.user,
+		Password:   sshConfig.password,
+		RemotePath: config.remotePath,
+		LocalPath:  tmpPath,
 	})
 	if err != nil {
-		utils.Fatal("Error creating SSH storage: %s", err)
+		logger.Fatal("Error creating SSH storage: %s", err)
 	}
 	err = sshStorage.Copy(finalFileName)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
-	//Get backup info
+	// Get backup info
 	fileInfo, err := os.Stat(filepath.Join(tmpPath, finalFileName))
 	if err != nil {
-		utils.Error("Error: %s", err)
+		logger.Error("Error: %s", err)
 	}
 	backupSize = fileInfo.Size()
-	utils.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
+	logger.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
 
-	//Delete backup file from tmp folder
+	// Delete backup file from tmp folder
 	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
 	if err != nil {
-		utils.Error("Error deleting file: %v", err)
+		logger.Error("Error deleting file: %v", err)
 
 	}
 	if config.prune {
 		err := sshStorage.Prune(config.backupRetention)
 		if err != nil {
-			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+			logger.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
 		}
 
 	}
-	utils.Info("Uploading backup archive to remote storage ... done ")
-	//Send notification
+	logger.Info("Uploading backup archive to remote storage ... done ")
+	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
 		BackupSize:     backupSize,
@@ -429,24 +438,24 @@ func sshBackup(db *dbConfig, config *BackupConfig) {
 		StartTime:      startTime,
 		EndTime:        time.Now().Format(utils.TimeFormat()),
 	})
-	//Delete temp
+	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	logger.Info("Backup completed successfully")
 
 }
 func ftpBackup(db *dbConfig, config *BackupConfig) {
-	utils.Info("Backup database to the remote FTP server")
+	logger.Info("Backup database to the remote FTP server")
 	startTime = time.Now().Format(utils.TimeFormat())
 
-	//Backup database
+	// Backup database
 	BackupDatabase(db, config.backupFileName, disableCompression)
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
 		finalFileName = fmt.Sprintf("%s.%s", config.backupFileName, "gpg")
 	}
-	utils.Info("Uploading backup archive to the remote FTP server ... ")
-	utils.Info("Backup name is %s", finalFileName)
+	logger.Info("Uploading backup archive to the remote FTP server ... ")
+	logger.Info("Backup name is %s", finalFileName)
 	ftpConfig := loadFtpConfig()
 	ftpStorage, err := ftp.NewStorage(ftp.Config{
 		Host:       ftpConfig.host,
@@ -457,36 +466,36 @@ func ftpBackup(db *dbConfig, config *BackupConfig) {
 		LocalPath:  tmpPath,
 	})
 	if err != nil {
-		utils.Fatal("Error creating SSH storage: %s", err)
+		logger.Fatal("Error creating SSH storage: %s", err)
 	}
 	err = ftpStorage.Copy(finalFileName)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
-	utils.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
-	//Get backup info
+	logger.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
+	// Get backup info
 	fileInfo, err := os.Stat(filepath.Join(tmpPath, finalFileName))
 	if err != nil {
-		utils.Error("Error: %s", err)
+		logger.Error("Error: %s", err)
 	}
 	backupSize = fileInfo.Size()
-	//Delete backup file from tmp folder
+	// Delete backup file from tmp folder
 	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
 	if err != nil {
-		utils.Error("Error deleting file: %v", err)
+		logger.Error("Error deleting file: %v", err)
 
 	}
 	if config.prune {
 		err := ftpStorage.Prune(config.backupRetention)
 		if err != nil {
-			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+			logger.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
 		}
 
 	}
 
-	utils.Info("Uploading backup archive to the remote FTP server ... done ")
+	logger.Info("Uploading backup archive to the remote FTP server ... done ")
 
-	//Send notification
+	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
 		BackupSize:     backupSize,
@@ -496,36 +505,36 @@ func ftpBackup(db *dbConfig, config *BackupConfig) {
 		StartTime:      startTime,
 		EndTime:        time.Now().Format(utils.TimeFormat()),
 	})
-	//Delete temp
+	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	logger.Info("Backup completed successfully")
 }
 
 func encryptBackup(config *BackupConfig) {
 	backupFile, err := os.ReadFile(filepath.Join(tmpPath, config.backupFileName))
 	outputFile := fmt.Sprintf("%s.%s", filepath.Join(tmpPath, config.backupFileName), gpgExtension)
 	if err != nil {
-		utils.Fatal("Error reading backup file: %s ", err)
+		logger.Fatal("Error reading backup file: %s ", err)
 	}
 	if config.usingKey {
-		utils.Info("Encrypting backup using public key...")
+		logger.Info("Encrypting backup using public key...")
 		pubKey, err := os.ReadFile(config.publicKey)
 		if err != nil {
-			utils.Fatal("Error reading public key: %s ", err)
+			logger.Fatal("Error reading public key: %s ", err)
 		}
 		err = encryptor.EncryptWithPublicKey(backupFile, fmt.Sprintf("%s.%s", filepath.Join(tmpPath, config.backupFileName), gpgExtension), pubKey)
 		if err != nil {
-			utils.Fatal("Error encrypting backup file: %v ", err)
+			logger.Fatal("Error encrypting backup file: %v ", err)
 		}
-		utils.Info("Encrypting backup using public key...done")
+		logger.Info("Encrypting backup using public key...done")
 
 	} else if config.passphrase != "" {
-		utils.Info("Encrypting backup using passphrase...")
+		logger.Info("Encrypting backup using passphrase...")
 		err := encryptor.Encrypt(backupFile, outputFile, config.passphrase)
 		if err != nil {
-			utils.Fatal("error during encrypting backup %v", err)
+			logger.Fatal("error during encrypting backup %v", err)
 		}
-		utils.Info("Encrypting backup using passphrase...done")
+		logger.Info("Encrypting backup using passphrase...done")
 
 	}
 

internal/config.go

@@ -26,6 +26,7 @@ package internal
 
 import (
 	"fmt"
+	"github.com/jkaninda/mysql-bkup/pkg/logger"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"github.com/spf13/cobra"
 	"os"
@@ -104,7 +105,7 @@ type AWSConfig struct {
 }
 
 func initDbConfig(cmd *cobra.Command) *dbConfig {
-	//Set env
+	// Set env
 	utils.GetEnv(cmd, "dbname", "DB_NAME")
 	dConf := dbConfig{}
 	dConf.dbHost = os.Getenv("DB_HOST")
@@ -115,8 +116,8 @@ func initDbConfig(cmd *cobra.Command) *dbConfig {
 
 	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)
+		logger.Error("Please make sure all required environment variables for database are set")
+		logger.Fatal("Error checking environment variables: %s", err)
 	}
 	return &dConf
 }
@@ -149,7 +150,7 @@ func loadSSHConfig() (*SSHConfig, error) {
 	}, nil
 }
 func loadFtpConfig() *FTPConfig {
-	//Initialize data configs
+	// Initialize data configs
 	fConfig := FTPConfig{}
 	fConfig.host = utils.GetEnvVariable("FTP_HOST", "FTP_HOST_NAME")
 	fConfig.user = os.Getenv("FTP_USER")
@@ -158,13 +159,13 @@ func loadFtpConfig() *FTPConfig {
 	fConfig.remotePath = os.Getenv("REMOTE_PATH")
 	err := utils.CheckEnvVars(ftpVars)
 	if err != nil {
-		utils.Error("Please make sure all required environment variables for FTP are set")
-		utils.Fatal("Error missing environment variables: %s", err)
+		logger.Error("Please make sure all required environment variables for FTP are set")
+		logger.Fatal("Error missing environment variables: %s", err)
 	}
 	return &fConfig
 }
 func initAWSConfig() *AWSConfig {
-	//Initialize AWS configs
+	// Initialize AWS configs
 	aConfig := AWSConfig{}
 	aConfig.endpoint = utils.GetEnvVariable("AWS_S3_ENDPOINT", "S3_ENDPOINT")
 	aConfig.accessKey = utils.GetEnvVariable("AWS_ACCESS_KEY", "ACCESS_KEY")
@@ -185,8 +186,8 @@ func initAWSConfig() *AWSConfig {
 	aConfig.forcePathStyle = forcePathStyle
 	err = utils.CheckEnvVars(awsVars)
 	if err != nil {
-		utils.Error("Please make sure all required environment variables for AWS S3 are set")
-		utils.Fatal("Error checking environment variables: %s", err)
+		logger.Error("Please make sure all required environment variables for AWS S3 are set")
+		logger.Fatal("Error checking environment variables: %s", err)
 	}
 	return &aConfig
 }
@@ -194,7 +195,7 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
 	utils.SetEnv("STORAGE_PATH", storagePath)
 	utils.GetEnv(cmd, "cron-expression", "BACKUP_CRON_EXPRESSION")
 	utils.GetEnv(cmd, "path", "REMOTE_PATH")
-	//Get flag value and set env
+	// Get flag value and set env
 	remotePath := utils.GetEnvVariable("REMOTE_PATH", "SSH_REMOTE_PATH")
 	storage = utils.GetEnv(cmd, "storage", "STORAGE")
 	prune := false
@@ -216,7 +217,7 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
 		encryption = true
 		usingKey = false
 	}
-	//Initialize backup configs
+	// Initialize backup configs
 	config := BackupConfig{}
 	config.backupRetention = backupRetention
 	config.disableCompression = disableCompression
@@ -246,7 +247,7 @@ func initRestoreConfig(cmd *cobra.Command) *RestoreConfig {
 	utils.SetEnv("STORAGE_PATH", storagePath)
 	utils.GetEnv(cmd, "path", "REMOTE_PATH")
 
-	//Get flag value and set env
+	// Get flag value and set env
 	s3Path := utils.GetEnv(cmd, "path", "AWS_S3_PATH")
 	remotePath := utils.GetEnvVariable("REMOTE_PATH", "SSH_REMOTE_PATH")
 	storage = utils.GetEnv(cmd, "storage", "STORAGE")
@@ -260,7 +261,7 @@ func initRestoreConfig(cmd *cobra.Command) *RestoreConfig {
 		usingKey = false
 	}
 
-	//Initialize restore configs
+	// Initialize restore configs
 	rConfig := RestoreConfig{}
 	rConfig.s3Path = s3Path
 	rConfig.remotePath = remotePath
@@ -276,15 +277,15 @@ func initRestoreConfig(cmd *cobra.Command) *RestoreConfig {
 func initTargetDbConfig() *targetDbConfig {
 	tdbConfig := targetDbConfig{}
 	tdbConfig.targetDbHost = os.Getenv("TARGET_DB_HOST")
-	tdbConfig.targetDbPort = utils.EnvWithDefault("TARGET_DB_PORT", "5432")
+	tdbConfig.targetDbPort = utils.EnvWithDefault("TARGET_DB_PORT", "3306")
 	tdbConfig.targetDbName = os.Getenv("TARGET_DB_NAME")
 	tdbConfig.targetDbUserName = os.Getenv("TARGET_DB_USERNAME")
 	tdbConfig.targetDbPassword = os.Getenv("TARGET_DB_PASSWORD")
 
 	err := utils.CheckEnvVars(tdbRVars)
 	if err != nil {
-		utils.Error("Please make sure all required environment variables for the target database are set")
-		utils.Fatal("Error checking target database environment variables: %s", err)
+		logger.Error("Please make sure all required environment variables for the target database are set")
+		logger.Fatal("Error checking target database environment variables: %s", err)
 	}
 	return &tdbConfig
 }

internal/helper.go

@@ -27,6 +27,7 @@ package internal
 import (
 	"bytes"
 	"fmt"
+	"github.com/jkaninda/mysql-bkup/pkg/logger"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"gopkg.in/yaml.v3"
 	"os"
@@ -36,13 +37,14 @@ import (
 )
 
 func intro() {
-	utils.Info("Starting MySQL Backup...")
-	utils.Info("Copyright (c) 2024 Jonas Kaninda ")
+	fmt.Println("Starting MySQL Backup...")
+	fmt.Printf("Version: %s\n", utils.Version)
+	fmt.Println("Copyright (c) 2024 Jonas Kaninda")
 }
 
 // copyToTmp copy file to temporary directory
 func deleteTemp() {
-	utils.Info("Deleting %s ...", tmpPath)
+	logger.Info("Deleting %s ...", tmpPath)
 	err := filepath.Walk(tmpPath, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
@@ -58,9 +60,9 @@ func deleteTemp() {
 		return nil
 	})
 	if err != nil {
-		utils.Error("Error deleting files: %v", err)
+		logger.Error("Error deleting files: %v", err)
 	} else {
-		utils.Info("Deleting %s ... done", tmpPath)
+		logger.Info("Deleting %s ... done", tmpPath)
 	}
 }
 
@@ -70,7 +72,7 @@ func testDatabaseConnection(db *dbConfig) {
 	if err != nil {
 		return
 	}
-	utils.Info("Connecting to %s database ...", db.dbName)
+	logger.Info("Connecting to %s database ...", db.dbName)
 	cmd := exec.Command("mysql", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, db.dbName, "-e", "quit")
 	// Capture the output
 	var out bytes.Buffer
@@ -78,10 +80,10 @@ func testDatabaseConnection(db *dbConfig) {
 	cmd.Stderr = &out
 	err = cmd.Run()
 	if err != nil {
-		utils.Fatal("Error testing database connection: %v\nOutput: %s", err, out.String())
+		logger.Fatal("Error testing database connection: %v\nOutput: %s", err, out.String())
 
 	}
-	utils.Info("Successfully connected to %s database", db.dbName)
+	logger.Info("Successfully connected to %s database", db.dbName)
 
 }
 

internal/migrate.go

@@ -26,19 +26,19 @@ package internal
 
 import (
 	"fmt"
-	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/jkaninda/mysql-bkup/pkg/logger"
 	"github.com/spf13/cobra"
 	"time"
 )
 
 func StartMigration(cmd *cobra.Command) {
 	intro()
-	utils.Info("Starting database migration...")
-	//Get DB config
+	logger.Info("Starting database migration...")
+	// Get DB config
 	dbConf = initDbConfig(cmd)
 	targetDbConf = initTargetDbConfig()
 
-	//Defining the target database variables
+	// Defining the target database variables
 	newDbConfig := dbConfig{}
 	newDbConfig.dbHost = targetDbConf.targetDbHost
 	newDbConfig.dbPort = targetDbConf.targetDbPort
@@ -46,15 +46,15 @@ func StartMigration(cmd *cobra.Command) {
 	newDbConfig.dbUserName = targetDbConf.targetDbUserName
 	newDbConfig.dbPassword = targetDbConf.targetDbPassword
 
-	//Generate file name
+	// Generate file name
 	backupFileName := fmt.Sprintf("%s_%s.sql", dbConf.dbName, time.Now().Format("20060102_150405"))
 	conf := &RestoreConfig{}
 	conf.file = backupFileName
-	//Backup source Database
+	// Backup source Database
 	BackupDatabase(dbConf, backupFileName, true)
-	//Restore source database into target database
-	utils.Info("Restoring [%s] database into [%s] database...", dbConf.dbName, targetDbConf.targetDbName)
+	// Restore source database into target database
+	logger.Info("Restoring [%s] database into [%s] database...", dbConf.dbName, targetDbConf.targetDbName)
 	RestoreDatabase(&newDbConfig, conf)
-	utils.Info("[%s] database has been restored into [%s] database", dbConf.dbName, targetDbConf.targetDbName)
-	utils.Info("Database migration completed.")
+	logger.Info("[%s] database has been restored into [%s] database", dbConf.dbName, targetDbConf.targetDbName)
+	logger.Info("Database migration completed.")
 }

internal/restore.go

@@ -1,9 +1,4 @@
 // Package internal /
-/*****
-@author    Jonas Kaninda
-@license   MIT License <https://opensource.org/licenses/MIT>
-@Copyright © 2024 Jonas Kaninda
-**/
 package internal
 
 /*
@@ -35,6 +30,7 @@ import (
 	"github.com/jkaninda/go-storage/pkg/local"
 	"github.com/jkaninda/go-storage/pkg/s3"
 	"github.com/jkaninda/go-storage/pkg/ssh"
+	"github.com/jkaninda/mysql-bkup/pkg/logger"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"github.com/spf13/cobra"
 	"os"
@@ -61,20 +57,20 @@ func StartRestore(cmd *cobra.Command) {
 	}
 }
 func localRestore(dbConf *dbConfig, restoreConf *RestoreConfig) {
-	utils.Info("Restore database from local")
+	logger.Info("Restore database from local")
 	localStorage := local.NewStorage(local.Config{
 		RemotePath: storagePath,
 		LocalPath:  tmpPath,
 	})
 	err := localStorage.CopyFrom(restoreConf.file)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
 	RestoreDatabase(dbConf, restoreConf)
 
 }
 func restoreFromS3(db *dbConfig, conf *RestoreConfig) {
-	utils.Info("Restore database from s3")
+	logger.Info("Restore database from s3")
 	awsConfig := initAWSConfig()
 	if conf.remotePath == "" {
 		conf.remotePath = awsConfig.remotePath
@@ -91,40 +87,41 @@ func restoreFromS3(db *dbConfig, conf *RestoreConfig) {
 		LocalPath:      tmpPath,
 	})
 	if err != nil {
-		utils.Fatal("Error creating s3 storage: %s", err)
+		logger.Fatal("Error creating s3 storage: %s", err)
 	}
 	err = s3Storage.CopyFrom(conf.file)
 	if err != nil {
-		utils.Fatal("Error download file from S3 storage: %s", err)
+		logger.Fatal("Error download file from S3 storage: %s", err)
 	}
 	RestoreDatabase(db, conf)
 }
 func restoreFromRemote(db *dbConfig, conf *RestoreConfig) {
-	utils.Info("Restore database from remote server")
+	logger.Info("Restore database from remote server")
 	sshConfig, err := loadSSHConfig()
 	if err != nil {
-		utils.Fatal("Error loading ssh config: %s", err)
+		logger.Fatal("Error loading ssh config: %s", err)
 	}
 
 	sshStorage, err := ssh.NewStorage(ssh.Config{
-		Host:       sshConfig.hostName,
-		Port:       sshConfig.port,
-		User:       sshConfig.user,
-		Password:   sshConfig.password,
-		RemotePath: conf.remotePath,
-		LocalPath:  tmpPath,
+		Host:         sshConfig.hostName,
+		Port:         sshConfig.port,
+		User:         sshConfig.user,
+		Password:     sshConfig.password,
+		IdentifyFile: sshConfig.identifyFile,
+		RemotePath:   conf.remotePath,
+		LocalPath:    tmpPath,
 	})
 	if err != nil {
-		utils.Fatal("Error creating SSH storage: %s", err)
+		logger.Fatal("Error creating SSH storage: %s", err)
 	}
 	err = sshStorage.CopyFrom(conf.file)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
 	RestoreDatabase(db, conf)
 }
 func restoreFromFTP(db *dbConfig, conf *RestoreConfig) {
-	utils.Info("Restore database from FTP server")
+	logger.Info("Restore database from FTP server")
 	ftpConfig := loadFtpConfig()
 	ftpStorage, err := ftp.NewStorage(ftp.Config{
 		Host:       ftpConfig.host,
@@ -135,11 +132,11 @@ func restoreFromFTP(db *dbConfig, conf *RestoreConfig) {
 		LocalPath:  tmpPath,
 	})
 	if err != nil {
-		utils.Fatal("Error creating SSH storage: %s", err)
+		logger.Fatal("Error creating SSH storage: %s", err)
 	}
 	err = ftpStorage.CopyFrom(conf.file)
 	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
+		logger.Fatal("Error copying backup file: %s", err)
 	}
 	RestoreDatabase(db, conf)
 }
@@ -147,42 +144,42 @@ func restoreFromFTP(db *dbConfig, conf *RestoreConfig) {
 // RestoreDatabase restore database
 func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
 	if conf.file == "" {
-		utils.Fatal("Error, file required")
+		logger.Fatal("Error, file required")
 	}
 	extension := filepath.Ext(filepath.Join(tmpPath, conf.file))
 	rFile, err := os.ReadFile(filepath.Join(tmpPath, conf.file))
 	outputFile := RemoveLastExtension(filepath.Join(tmpPath, conf.file))
 	if err != nil {
-		utils.Fatal("Error reading backup file: %s ", err)
+		logger.Fatal("Error reading backup file: %s ", err)
 	}
 
 	if extension == ".gpg" {
 
 		if conf.usingKey {
-			utils.Info("Decrypting backup using private key...")
-			utils.Warn("Backup decryption using a private key is not fully supported")
+			logger.Info("Decrypting backup using private key...")
+			logger.Warn("Backup decryption using a private key is not fully supported")
 			prKey, err := os.ReadFile(conf.privateKey)
 			if err != nil {
-				utils.Fatal("Error reading public key: %s ", err)
+				logger.Fatal("Error reading public key: %s ", err)
 			}
 			err = encryptor.DecryptWithPrivateKey(rFile, outputFile, prKey, conf.passphrase)
 			if err != nil {
-				utils.Fatal("error during decrypting backup %v", err)
+				logger.Fatal("error during decrypting backup %v", err)
 			}
-			utils.Info("Decrypting backup using private key...done")
+			logger.Info("Decrypting backup using private key...done")
 		} else {
 			if conf.passphrase == "" {
-				utils.Error("Error, passphrase or private key required")
-				utils.Fatal("Your file seems to be a GPG file.\nYou need to provide GPG keys. GPG_PASSPHRASE or GPG_PRIVATE_KEY environment variable is required.")
+				logger.Error("Error, passphrase or private key required")
+				logger.Fatal("Your file seems to be a GPG file.\nYou need to provide GPG keys. GPG_PASSPHRASE or GPG_PRIVATE_KEY environment variable is required.")
 			} else {
-				utils.Info("Decrypting backup using passphrase...")
-				//decryptWithGPG file
+				logger.Info("Decrypting backup using passphrase...")
+				// decryptWithGPG file
 				err := encryptor.Decrypt(rFile, outputFile, conf.passphrase)
 				if err != nil {
-					utils.Fatal("Error decrypting file %s %v", file, err)
+					logger.Fatal("Error decrypting file %s %v", file, err)
 				}
-				utils.Info("Decrypting backup using passphrase...done")
-				//Update file name
+				logger.Info("Decrypting backup using passphrase...done")
+				// Update file name
 				conf.file = RemoveLastExtension(file)
 			}
 		}
@@ -195,7 +192,7 @@ func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
 			return
 		}
 		testDatabaseConnection(db)
-		utils.Info("Restoring database...")
+		logger.Info("Restoring database...")
 
 		extension := filepath.Ext(filepath.Join(tmpPath, conf.file))
 		// Restore from compressed file / .sql.gz
@@ -203,29 +200,29 @@ func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
 			str := "zcat " + filepath.Join(tmpPath, conf.file) + " | mysql -h " + db.dbHost + " -P " + db.dbPort + " -u " + db.dbUserName + " " + db.dbName
 			_, err := exec.Command("sh", "-c", str).Output()
 			if err != nil {
-				utils.Fatal("Error, in restoring the database  %v", err)
+				logger.Fatal("Error, in restoring the database  %v", err)
 			}
-			utils.Info("Restoring database... done")
-			utils.Info("Database has been restored")
-			//Delete temp
+			logger.Info("Restoring database... done")
+			logger.Info("Database has been restored")
+			// Delete temp
 			deleteTemp()
 
 		} else if extension == ".sql" {
-			//Restore from sql file
+			// Restore from sql file
 			str := "cat " + filepath.Join(tmpPath, conf.file) + " | mysql -h " + db.dbHost + " -P " + db.dbPort + " -u " + db.dbUserName + " " + db.dbName
 			_, err := exec.Command("sh", "-c", str).Output()
 			if err != nil {
-				utils.Fatal("Error in restoring the database %v", err)
+				logger.Fatal("Error in restoring the database %v", err)
 			}
-			utils.Info("Restoring database... done")
-			utils.Info("Database has been restored")
-			//Delete temp
+			logger.Info("Restoring database... done")
+			logger.Info("Database has been restored")
+			// Delete temp
 			deleteTemp()
 		} else {
-			utils.Fatal("Unknown file extension %s", extension)
+			logger.Fatal("Unknown file extension %s", extension)
 		}
 
 	} else {
-		utils.Fatal("File not found in %s", filepath.Join(tmpPath, conf.file))
+		logger.Fatal("File not found in %s", filepath.Join(tmpPath, conf.file))
 	}
 }