fix: database name not set error when using flag -d (#183)

* fix: database name not set error when using flag -d

.env.example

@@ -15,6 +15,7 @@ TZ=Europe/Paris
 
 ### Backup restoration
 #FILE_NAME=
+
 ### AWS  S3 Storage
 #ACCESS_KEY=
 #SECRET_KEY=
@@ -43,19 +44,30 @@ TZ=Europe/Paris
 #FTP_USER=
 #FTP_PORT=21
 #REMOTE_PATH=
+
+## Azure Blob storage
+AZURE_STORAGE_CONTAINER_NAME=
+AZURE_STORAGE_ACCOUNT_NAME=
+AZURE_STORAGE_ACCOUNT_KEY=
+
 #### Backup encryption
 #GPG_PUBLIC_KEY=/config/public_key.asc
 #GPG_PRIVATE_KEY=/config/private_key.asc
 #GPG_PASSPHRASE=Your strong passphrase
+
 ## For multiple database backup on Docker or Docker in Swarm mode
 #BACKUP_CONFIG_FILE=/config/config.yaml
+
 ### Database restoration
 #FILE_NAME=
+
 ### Notification
 #BACKUP_REFERENCE=K8s/Paris cluster
+
 ## Telegram
 #TG_TOKEN=
 #TG_CHAT_ID=
+
 ### Email
 #MAIL_HOST=
 #MAIL_PORT=

.github/workflows/build.yml

@@ -1,7 +1,7 @@
 name: Build
 on:
   push:
-    branches: ['develop']
+    branches: ['nightly']
 env:
   BUILDKIT_IMAGE: jkaninda/mysql-bkup
 jobs:
@@ -28,7 +28,7 @@ jobs:
           file: "./Dockerfile"
           platforms: linux/amd64,linux/arm64,linux/arm/v7
           build-args: |
-            appVersion=develop-${{ github.sha }}
+            appVersion=nightly
           tags: |
-            "${{vars.BUILDKIT_IMAGE}}:develop-${{ github.sha }}"
+            "${{vars.BUILDKIT_IMAGE}}:nightly"
 

.github/workflows/deploy-docs.yml

@@ -32,14 +32,14 @@ jobs:
           working-directory: docs
       - name: Setup Pages
         id: pages
-        uses: actions/configure-pages@v2
+        uses: actions/configure-pages@v5
       - name: Build with Jekyll
         working-directory: docs
         run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
         env:
           JEKYLL_ENV: production
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v1
+        uses: actions/upload-pages-artifact@v3
         with:
           path: 'docs/_site/'
 
@@ -52,4 +52,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v1
+        uses: actions/deploy-pages@v4

.github/workflows/lint.yml

@@ -0,0 +1,23 @@
+name: Lint
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  lint:
+    name: Run on Ubuntu
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone the code
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '~1.23'
+
+      - name: Run linter
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.61

.github/workflows/tests.yml

@@ -0,0 +1,289 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+      - nightly
+  pull_request:
+    branches:
+      - main
+env:
+  IMAGE_NAME: mysql-bkup
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    services:
+      mysql:
+        image: mysql:9
+        env:
+          MYSQL_ROOT_PASSWORD: password
+          MYSQL_DATABASE: testdb
+          MYSQL_USER: user
+          MYSQL_PASSWORD: password
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h 127.0.0.1 -uuser -ppassword"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=5
+      mysql8:
+        image: mysql:8
+        env:
+          MYSQL_ROOT_PASSWORD: password
+          MYSQL_DATABASE: testdb
+          MYSQL_USER: user
+          MYSQL_PASSWORD: password
+        ports:
+          - 3308:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h 127.0.0.1 -uuser -ppassword"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=5
+      mysql5:
+        image: mysql:5
+        env:
+          MYSQL_ROOT_PASSWORD: password
+          MYSQL_DATABASE: testdb
+          MYSQL_USER: user
+          MYSQL_PASSWORD: password
+        ports:
+          - 3305:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h 127.0.0.1 -uuser -ppassword"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=5
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Create Minio container
+        run: |
+          docker run -d --rm --name minio \
+            --network host \
+            -p 9000:9000 \
+            -e MINIO_ACCESS_KEY=minioadmin \
+            -e MINIO_SECRET_KEY=minioadmin \
+            -e MINIO_REGION_NAME="eu" \
+            minio/minio server /data
+          echo "Create Minio container completed"
+      - name: Install MinIO Client (mc)
+        run: |
+          curl -O https://dl.min.io/client/mc/release/linux-amd64/mc
+          chmod +x mc
+          sudo mv mc /usr/local/bin/
+
+      - name: Wait for MinIO to be ready
+        run: sleep 5
+
+      - name: Configure MinIO Client
+        run: |
+          mc alias set local http://localhost:9000 minioadmin minioadmin
+          mc alias list
+
+      - name: Create MinIO Bucket
+        run: |
+          mc mb local/backups
+          echo "Bucket backups created successfully."
+      # Build the Docker image
+      - name: Build Docker Image
+        run: |
+          docker buildx build --build-arg appVersion=test -t ${{ env.IMAGE_NAME }}:latest --load .
+
+      - name: Verify Docker images
+        run: |
+          docker images
+
+      - name: Wait for MySQL to be ready
+        run: |
+          docker run --rm --network host mysql:9 mysqladmin ping -h 127.0.0.1 -uuser -ppassword --wait
+      - name: Test restore
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=root \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest restore -f init.sql
+          echo "Database restore completed"
+      - name: Test restore Mysql8
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_PORT=3308 \
+            -e DB_USERNAME=root \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest restore -f init.sql
+          echo "Test restore Mysql8 completed"
+      - name: Test restore Mysql5
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_PORT=3305 \
+            -e DB_USERNAME=root \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest restore -f init.sql
+          echo "Test restore Mysql5 completed"
+      - name: Test backup
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest backup
+          echo "Database backup completed"
+      - name: Test backup Mysql8
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_PORT=3308 \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest backup
+          echo "Test backup Mysql8 completed"
+      - name: Test backup Mysql5
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_PORT=3305 \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest backup
+          echo "Test backup Mysql5 completed"
+      - name: Test encrypted backup
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e GPG_PASSPHRASE=password \
+            ${{ env.IMAGE_NAME }}:latest backup -d testdb --disable-compression --custom-name encrypted-bkup
+          echo "Database encrypted backup completed"
+      - name: Test restore encrypted backup | testdb -> testdb2
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=root \
+            -e DB_PASSWORD=password \
+            -e GPG_PASSPHRASE=password \
+            -e DB_NAME=testdb2 \
+            ${{ env.IMAGE_NAME }}:latest restore -f /backup/encrypted-bkup.sql.gpg
+          echo "Test restore encrypted backup completed"
+      - name: Test migrate database testdb -> testdb3
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=root \
+            -e DB_PASSWORD=password \
+            -e GPG_PASSPHRASE=password \
+            -e DB_NAME=testdb \
+            -e TARGET_DB_HOST=127.0.0.1 \
+            -e TARGET_DB_PORT=3306 \
+            -e TARGET_DB_NAME=testdb3 \
+            -e TARGET_DB_USERNAME=root \
+            -e TARGET_DB_PASSWORD=password \
+            ${{ env.IMAGE_NAME }}:latest migrate
+          echo "Test migrate database testdb -> testdb3 completed"
+      - name: Test backup all databases
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=root \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest backup --all-databases
+          echo "Database backup completed"
+      - name: Test multiple backup
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e TESTDB2_DB_USERNAME=root \
+            -e TESTDB2_DB_PASSWORD=password \
+            -e TESTDB2_DB_HOST=127.0.0.1 \
+            ${{ env.IMAGE_NAME }}:latest backup -c /backup/test_config.yaml
+          echo "Database backup completed"
+      - name: Test backup Minio (s3)
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            -e AWS_S3_ENDPOINT="http://127.0.0.1:9000" \
+            -e AWS_S3_BUCKET_NAME=backups \
+            -e AWS_ACCESS_KEY=minioadmin \
+            -e AWS_SECRET_KEY=minioadmin \
+            -e AWS_DISABLE_SSL="true" \
+            -e AWS_REGION="eu" \
+            -e AWS_FORCE_PATH_STYLE="true" ${{ env.IMAGE_NAME }}:latest backup -s s3  --custom-name minio-backup
+          echo "Test backup Minio (s3) completed"
+      - name: Test restore Minio (s3)
+        run: |
+          docker run --rm --name ${{ env.IMAGE_NAME }} \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            -e AWS_S3_ENDPOINT="http://127.0.0.1:9000" \
+            -e AWS_S3_BUCKET_NAME=backups \
+            -e AWS_ACCESS_KEY=minioadmin \
+            -e AWS_SECRET_KEY=minioadmin \
+            -e AWS_DISABLE_SSL="true" \
+            -e AWS_REGION="eu" \
+            -e AWS_FORCE_PATH_STYLE="true" ${{ env.IMAGE_NAME }}:latest restore -s s3 -f minio-backup.sql.gz
+          echo "Test backup Minio (s3) completed"
+      - name: Test scheduled backup
+        run: |
+          docker run -d --rm --name ${{ env.IMAGE_NAME }} \
+            -v ./migrations:/backup/ \
+            --network host \
+            -e DB_HOST=127.0.0.1 \
+            -e DB_USERNAME=user \
+            -e DB_PASSWORD=password \
+            -e DB_NAME=testdb \
+            ${{ env.IMAGE_NAME }}:latest backup -e "@every 10s"
+          
+          echo "Waiting for backup to be done..."
+          sleep 25
+          docker logs ${{ env.IMAGE_NAME }}
+          echo "Test scheduled backup completed"
+      # Cleanup: Stop and remove containers
+      - name: Clean up
+        run: |
+          docker stop ${{ env.IMAGE_NAME }} || true
+          docker rm ${{ env.IMAGE_NAME }} || true

.golangci.yml

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

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.23.3 AS build
+FROM golang:1.24.1 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.0
+FROM alpine:3.21.3
 ENV TZ=UTC
 ARG WORKDIR="/config"
 ARG BACKUPDIR="/backup"

README.md

@@ -3,6 +3,7 @@
 **MYSQL-BKUP** is a Docker container image designed to **backup, restore, and migrate MySQL databases**.
 It supports a variety of storage options and ensures data security through GPG encryption.
 
+[![Tests](https://github.com/jkaninda/mysql-bkup/actions/workflows/tests.yml/badge.svg)](https://github.com/jkaninda/mysql-bkup/actions/workflows/tests.yml)
 [![Build](https://github.com/jkaninda/mysql-bkup/actions/workflows/release.yml/badge.svg)](https://github.com/jkaninda/mysql-bkup/actions/workflows/release.yml)
 [![Go Report](https://goreportcard.com/badge/github.com/jkaninda/mysql-bkup)](https://goreportcard.com/report/github.com/jkaninda/mysql-bkup)
 ![Docker Image Size (latest by date)](https://img.shields.io/docker/image-size/jkaninda/mysql-bkup?style=flat-square)
@@ -24,7 +25,7 @@ It supports a variety of storage options and ensures data security through GPG e
 - **Deployment Flexibility:**
     - Available as the [jkaninda/mysql-bkup](https://hub.docker.com/r/jkaninda/mysql-bkup) Docker image.
     - Deployable on **Docker**, **Docker Swarm**, and **Kubernetes**.
-    - Supports recurring backups of PostgreSQL databases when deployed:
+    - Supports recurring backups of MySQL databases when deployed:
         - On Docker for automated backup schedules.
         - As a **Job** or **CronJob** on Kubernetes.
 
@@ -35,9 +36,9 @@ It supports a variety of storage options and ensures data security through GPG e
 
 ## Use Cases
 
-- **Automated Recurring Backups:** Schedule regular backups for PostgreSQL databases.
-- **Cross-Environment Migration:** Easily migrate your PostgreSQL databases across different environments using supported storage options.
-- **Secure Backup Management:** Protect your data with Gmysql encryption.
+- **Automated Recurring Backups:** Schedule regular backups for MySQL databases.
+- **Cross-Environment Migration:** Easily migrate your MySQL databases across different environments using supported storage options.
+- **Secure Backup Management:** Protect your data with GPG encryption.
 
 
 Successfully tested on:
@@ -74,6 +75,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 +89,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
@@ -188,13 +202,12 @@ Documentation references Docker Hub, but all examples will work using ghcr.io ju
 
 ## References
 
-We decided to publish this image as a simpler and more lightweight alternative because of the following requirements:
+We created this image as a simpler and more lightweight alternative to existing solutions. Here’s why:
 
-- The original image is based on `Alpine` and requires additional tools, making it heavy.
-- This image is written in Go.
-- `arm64` and `arm/v7` architectures are supported.
-- Docker in Swarm mode is supported.
-- Kubernetes is supported.
+- **Lightweight:** Written in Go, the image is optimized for performance and minimal resource usage.
+- **Multi-Architecture Support:** Supports `arm64` and `arm/v7` architectures.
+- **Docker Swarm Support:** Fully compatible with Docker in Swarm mode.
+- **Kubernetes Support:** Designed to work seamlessly with Kubernetes.
 
 
 ## License

cmd/backup.go

@@ -1,4 +1,3 @@
-// Package cmd /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package cmd
 
 import (
@@ -44,10 +44,14 @@ var BackupCmd = &cobra.Command{
 }
 
 func init() {
-	//Backup
-	BackupCmd.PersistentFlags().StringP("storage", "s", "local", "Define storage: local, s3, ssh, ftp")
-	BackupCmd.PersistentFlags().StringP("path", "P", "", "AWS S3 path without file name. eg: /custom_path or ssh remote path `/home/foo/backup`")
-	BackupCmd.PersistentFlags().StringP("cron-expression", "", "", "Backup cron expression")
+	// Backup
+	BackupCmd.PersistentFlags().StringP("storage", "s", "local", "Define storage: local, s3, ssh, ftp, azure")
+	BackupCmd.PersistentFlags().StringP("path", "P", "", "Storage path without file name. e.g: /custom_path or ssh remote path `/home/foo/backup`")
+	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-databases", "a", false, "Backup all databases")
+	BackupCmd.PersistentFlags().BoolP("all-in-one", "A", false, "Backup all databases in a single file")
+	BackupCmd.PersistentFlags().StringP("custom-name", "", "", "Custom backup name")
 
 }

cmd/migrate.go

@@ -1,4 +1,3 @@
-// Package cmd /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package cmd
 
 import (

cmd/restore.go

@@ -1,5 +1,3 @@
-package cmd
-
 /*
 MIT License
 
@@ -23,6 +21,9 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
+package cmd
+
 import (
 	"github.com/jkaninda/mysql-bkup/pkg"
 	"github.com/jkaninda/mysql-bkup/utils"
@@ -45,7 +46,7 @@ var RestoreCmd = &cobra.Command{
 }
 
 func init() {
-	//Restore
+	// Restore
 	RestoreCmd.PersistentFlags().StringP("file", "f", "", "File name of database")
 	RestoreCmd.PersistentFlags().StringP("storage", "s", "local", "Define storage: local, s3, ssh, ftp")
 	RestoreCmd.PersistentFlags().StringP("path", "P", "", "AWS S3 path without file name. eg: /custom_path or ssh remote path `/home/foo/backup`")

cmd/root.go

@@ -1,4 +1,3 @@
-// Package cmd /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package cmd
 
 import (
@@ -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.

cmd/version.go

@@ -1,4 +1,3 @@
-// Package cmd /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package cmd
 
 import (

docs/_config.yml

@@ -20,7 +20,7 @@ description: >- # this means to ignore newlines until "baseurl:"
   It supports local storage, AWS S3 or any S3 Alternatives for Object Storage, and SSH compatible storage.
 
 baseurl: "" # the subpath of your site, e.g. /blog
-url: "jkaninda.github.io/mysql-bkup/" # the base hostname & protocol for your site, e.g. http://example.com
+url: "" # the base hostname & protocol for your site, e.g. http://example.com
 twitter_username: jonaskaninda
 github_username:  jkaninda
 

docs/how-tos/azure-blob.md

@@ -4,22 +4,43 @@ layout: default
 parent: How Tos
 nav_order: 5
 ---
-# Azure Blob storage
 
-{: .note }
-As described on local backup section, to change the storage of you backup and use Azure Blob as storage. You need to add `--storage azure` (-s azure).
-You can also specify a folder where you want to save you data by adding `--path my-custom-path` flag.
+# Backup to Azure Blob Storage
 
+To store your backups on Azure Blob Storage, you can configure the backup process to use the `--storage azure` option.
 
-## Backup to Azure Blob storage
+This section explains how to set up and configure Azure Blob-based backups.
 
-```yml
+---
+
+## Configuration Steps
+
+1. **Specify the Storage Type**  
+   Add the `--storage azure` flag to your backup command.
+
+2. **Set the Blob Path**  
+   Optionally, specify a custom folder within your Azure Blob container where backups will be stored using the `--path` flag.  
+   Example: `--path my-custom-path`.
+
+3. **Required Environment Variables**  
+   The following environment variables are mandatory for Azure Blob-based backups:
+
+    - `AZURE_STORAGE_CONTAINER_NAME`: The name of the Azure Blob container where backups will be stored.
+    - `AZURE_STORAGE_ACCOUNT_NAME`: The name of your Azure Storage account.
+    - `AZURE_STORAGE_ACCOUNT_KEY`: The access key for your Azure Storage account.
+
+---
+
+## Example Configuration
+
+Below is an example `docker-compose.yml` configuration for backing up to Azure Blob Storage:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysqlbkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: backup --storage azure -d database --path my-custom-path
@@ -29,16 +50,23 @@ services:
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## Azure Blob configurations
+      ## Azure Blob Configuration
       - AZURE_STORAGE_CONTAINER_NAME=backup-container
       - AZURE_STORAGE_ACCOUNT_NAME=account-name
       - AZURE_STORAGE_ACCOUNT_KEY=Ppby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
-    # mysql-bkup container must be connected to the same network with your database
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
 
+---
 
+## Key Notes
 
+- **Custom Path**: Use the `--path` flag to specify a folder within your Azure Blob container for organizing backups.
+- **Security**: Ensure your `AZURE_STORAGE_ACCOUNT_KEY` is kept secure and not exposed in public repositories.
+- **Compatibility**: This configuration works with Azure Blob Storage and other compatible storage solutions.

docs/how-tos/backup-all.md

@@ -0,0 +1,61 @@
+---
+title: Backup all databases in the server
+layout: default
+parent: How Tos
+nav_order: 12
+---
+
+# Backup All Databases
+
+MySQL-Bkup supports backing up all databases on the server using the `--all-databases` (`-a`) flag. By default, this creates separate backup files for each database. If you prefer a single backup file, you can use the `--all-in-on`e (`-A`) flag.
+
+Backing up all databases is useful for creating a snapshot of the entire database server, whether for disaster recovery or migration purposes.
+## Backup Modes
+
+### Separate Backup Files (Default)
+
+Using --all-databases without --all-in-one creates individual backup files for each database.
+
+- Creates separate backup files for each database.
+- Provides more flexibility in restoring individual databases or tables.
+- Can be more manageable in cases where different databases have different retention policies.
+- Might take slightly longer due to multiple file operations.
+- It is the default behavior when using the `--all-databases` flag.
+- It does not backup system databases (`information_schema`, `performance_schema`, `mysql`, `sys`, `innodb`).
+
+**Command:**
+
+```bash
+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 --all-databases
+```
+### Single Backup File
+
+Using --all-in-one (-A) creates a single backup file containing all databases.
+
+- Creates a single backup file containing all databases.
+- Easier to manage if you need to restore everything at once.
+- Faster to back up and restore in bulk.
+- Can be problematic if you only need to restore a specific database or table.
+- It is recommended to use this option for disaster recovery purposes.
+- It backups system databases as well.
+
+```bash
+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 --all-in-one
+```
+
+### When to Use Which?
+
+- Use `--all-in-one` if you want a quick, simple backup for disaster recovery where you'll restore everything at once.
+- Use `--all-databases` if you need granularity in restoring specific databases or tables without affecting others.

docs/how-tos/backup-to-ftp.md

@@ -4,41 +4,72 @@ layout: default
 parent: How Tos
 nav_order: 4
 ---
-# Backup to FTP remote server
 
+# Backup to FTP Remote Server
 
-As described for SSH backup section, to change the storage of your backup and use FTP Remote server as storage. You need to add `--storage ftp`.
-You need to add the full remote path by adding `--path /home/jkaninda/backups` flag or using `REMOTE_PATH` environment variable.
+To store your backups on an FTP remote server, you can configure the backup process to use the `--storage ftp` option. 
 
-{: .note }
-These environment variables are required for SSH backup `FTP_HOST`, `FTP_USER`, `REMOTE_PATH`, `FTP_PORT` or `FTP_PASSWORD`.
+This section explains how to set up and configure FTP-based backups.
 
-```yml
+---
+
+## Configuration Steps
+
+1. **Specify the Storage Type**  
+   Add the `--storage ftp` flag to your backup command.
+
+2. **Set the Remote Path**  
+   Define the full remote path where backups will be stored using the `--path` flag or the `REMOTE_PATH` environment variable.  
+   Example: `--path /home/jkaninda/backups`.
+
+3. **Required Environment Variables**  
+   The following environment variables are mandatory for FTP-based backups:
+
+    - `FTP_HOST`: The hostname or IP address of the FTP server.
+    - `FTP_PORT`: The FTP port (default is `21`).
+    - `FTP_USER`: The username for FTP authentication.
+    - `FTP_PASSWORD`: The password for FTP authentication.
+    - `REMOTE_PATH`: The directory on the FTP server where backups will be stored.
+
+---
+
+## Example Configuration
+
+Below is an example `docker-compose.yml` configuration for backing up to an FTP remote server:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: backup --storage ftp -d database
     environment:
       - DB_PORT=3306
-      - DB_HOST=postgres
+      - DB_HOST=mysql
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## FTP config
+      ## FTP Configuration
       - FTP_HOST="hostname"
       - FTP_PORT=21
       - FTP_USER=user
       - FTP_PASSWORD=password
       - REMOTE_PATH=/home/jkaninda/backups
 
-    # pg-bkup container must be connected to the same network with your database
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
-```
+```
+
+---
+
+## Key Notes
+
+- **Security**: FTP transmits data, including passwords, in plaintext. For better security, consider using SFTP (SSH File Transfer Protocol) or FTPS (FTP Secure) if supported by your server.
+- **Remote Path**: Ensure the `REMOTE_PATH` directory exists on the FTP server and is writable by the specified `FTP_USER`.

docs/how-tos/backup-to-s3.md

@@ -4,85 +4,123 @@ layout: default
 parent: How Tos
 nav_order: 2
 ---
-# Backup to AWS S3 
+# Backup to AWS S3
 
-{: .note }
-As described on local backup section, to change the storage of you backup and use S3 as storage. You need to add `--storage s3` (-s s3).
-You can also specify a specify folder where you want to save you data by adding `--path /my-custom-path` flag.
+To store your backups on AWS S3, you can configure the backup process to use the `--storage s3` option. This section explains how to set up and configure S3-based backups.
 
+---
 
-## Backup to S3
+## Configuration Steps
 
-```yml
+1. **Specify the Storage Type**  
+   Add the `--storage s3` flag to your backup command.
+
+2. **Set the S3 Path**  
+   Optionally, specify a custom folder within your S3 bucket where backups will be stored using the `--path` flag.  
+   Example: `--path /my-custom-path`.
+
+3. **Required Environment Variables**  
+   The following environment variables are mandatory for S3-based backups:
+
+    - `AWS_S3_ENDPOINT`: The S3 endpoint URL (e.g., `https://s3.amazonaws.com`).
+    - `AWS_S3_BUCKET_NAME`: The name of the S3 bucket where backups will be stored.
+    - `AWS_REGION`: The AWS region where the bucket is located (e.g., `us-west-2`).
+    - `AWS_ACCESS_KEY`: Your AWS access key.
+    - `AWS_SECRET_KEY`: Your AWS secret key.
+    - `AWS_DISABLE_SSL`: Set to `"true"` if using an S3 alternative like Minio without SSL (default is `"false"`).
+    - `AWS_FORCE_PATH_STYLE`: Set to `"true"` if using an S3 alternative like Minio (default is `"false"`).
+
+---
+
+## Example Configuration
+
+Below is an example `docker-compose.yml` configuration for backing up to AWS S3:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/pg-bkup/releases
+    # for available releases.
+    image: jkaninda/pg-bkup
+    container_name: pg-bkup
     command: backup --storage s3 -d database --path /my-custom-path
     environment:
-      - DB_PORT=3306
-      - DB_HOST=mysql
+      - DB_PORT=5432
+      - DB_HOST=postgres
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## AWS configurations
+      ## AWS Configuration
       - AWS_S3_ENDPOINT=https://s3.amazonaws.com
       - AWS_S3_BUCKET_NAME=backup
-      - AWS_REGION="us-west-2"
+      - AWS_REGION=us-west-2
       - AWS_ACCESS_KEY=xxxx
       - AWS_SECRET_KEY=xxxxx
-      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      ## Optional: Disable SSL for S3 alternatives like Minio
       - AWS_DISABLE_SSL="false"
-      - AWS_FORCE_PATH_STYLE=true # true for S3 alternative such as Minio
- 
-    # mysql-bkup container must be connected to the same network with your database
+      ## Optional: Enable path-style access for S3 alternatives like Minio
+      - AWS_FORCE_PATH_STYLE=false
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
 
-### Recurring backups to S3
+---
 
-As explained above, you need just to add AWS environment variables and specify the storage type `--storage s3`.
-In case you need to use recurring backups, you can use `--cron-expression "0 1 * * *"` flag or  `BACKUP_CRON_EXPRESSION=0 1 * * *` as described below.
+## Recurring Backups to S3
 
-```yml
+To schedule recurring backups to S3, use the `--cron-expression` flag or the `BACKUP_CRON_EXPRESSION` environment variable. This allows you to define a cron schedule for automated backups.
+
+### Example: Recurring Backup Configuration
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command: backup --storage s3 -d my-database --cron-expression "0 1 * * *"
+    command: backup --storage s3 -d database --cron-expression "0 1 * * *"
     environment:
       - DB_PORT=3306
       - DB_HOST=mysql
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-     ## AWS configurations
+      ## AWS Configuration
       - AWS_S3_ENDPOINT=https://s3.amazonaws.com
       - AWS_S3_BUCKET_NAME=backup
-      - AWS_REGION="us-west-2"
+      - AWS_REGION=us-west-2
       - AWS_ACCESS_KEY=xxxx
       - AWS_SECRET_KEY=xxxxx
-      # - BACKUP_CRON_EXPRESSION=0 1 * * * # Optional
-      #Delete old backup created more than specified days ago
+      ## Optional: Define a cron schedule for recurring backups
+      #- BACKUP_CRON_EXPRESSION=0 1 * * *
+      ## Optional: Delete old backups after a specified number of days
       #- BACKUP_RETENTION_DAYS=7
-      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      ## Optional: Disable SSL for S3 alternatives like Minio
       - AWS_DISABLE_SSL="false"
-      - AWS_FORCE_PATH_STYLE=true # true for S3 alternative such as Minio
-     # mysql-bkup container must be connected to the same network with your database
+      ## Optional: Enable path-style access for S3 alternatives like Minio
+      - AWS_FORCE_PATH_STYLE=false
+
+    # Ensure the pg-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
 
+---
+
+## Key Notes
+
+- **Cron Expression**: Use the `--cron-expression` flag or `BACKUP_CRON_EXPRESSION` environment variable to define the backup schedule. For example, `0 1 * * *` runs the backup daily at 1:00 AM.
+- **Backup Retention**: Optionally, use the `BACKUP_RETENTION_DAYS` environment variable to automatically delete backups older than a specified number of days.
+- **S3 Alternatives**: If using an S3 alternative like Minio, set `AWS_DISABLE_SSL="true"` and `AWS_FORCE_PATH_STYLE="true"` as needed.
+

docs/how-tos/backup-to-ssh.md

@@ -1,91 +1,129 @@
 ---
-title: Backup to SSH
+title: Backup to SSH or SFTP
 layout: default
 parent: How Tos
 nav_order: 3
 ---
-# Backup to SSH remote server
+# Backup to SFTP or SSH Remote Server
 
+To store your backups on an `SFTP` or `SSH` remote server instead of the default storage, you can configure the backup process to use the `--storage ssh` or `--storage remote` option.
+This section explains how to set up and configure SSH-based backups.
 
-As described for s3 backup section, to change the storage of your backup and use SSH Remote server as storage. You need to add `--storage ssh` or `--storage remote`.
-You need to add the full remote path by adding `--path /home/jkaninda/backups` flag or using `REMOTE_PATH` environment variable.
+---
 
-{: .note }
-These environment variables are required for SSH backup `SSH_HOST`, `SSH_USER`, `SSH_REMOTE_PATH`, `SSH_IDENTIFY_FILE`, `SSH_PORT` or `SSH_PASSWORD` if you dont use a private key to access to your server.
-Accessing the remote server using password is not recommended, use private key instead.
+## Configuration Steps
 
-```yml
+1. **Specify the Storage Type**  
+   Add the `--storage ssh` or `--storage remote` flag to your backup command.
+
+2. **Set the Remote Path**  
+   Define the full remote path where backups will be stored using the `--path` flag or the `REMOTE_PATH` environment variable.  
+   Example: `--path /home/jkaninda/backups`.
+
+3. **Required Environment Variables**  
+   The following environment variables are mandatory for SSH-based backups:
+
+    - `SSH_HOST`: The hostname or IP address of the remote server.
+    - `SSH_USER`: The username for SSH authentication.
+    - `REMOTE_PATH`: The directory on the remote server where backups will be stored.
+    - `SSH_IDENTIFY_FILE`: The path to the private key file for SSH authentication.
+    - `SSH_PORT`: The SSH port (default is `22`).
+    - `SSH_PASSWORD`: (Optional) Use this only if you are not using a private key for authentication.
+
+   {: .note }
+   **Security Recommendation**: Using a private key (`SSH_IDENTIFY_FILE`) is strongly recommended over password-based authentication (`SSH_PASSWORD`) for better security.
+
+---
+
+## Example Configuration
+
+Below is an example `docker-compose.yml` configuration for backing up to an SSH remote server:
+
+```yaml
 services:
-  mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    command: backup --storage remote -d database
-    volumes:
-      - ./id_ed25519:/tmp/id_ed25519"
-    environment:
-      - DB_PORT=3306
-      - DB_HOST=mysql
-      #- DB_NAME=database
-      - DB_USERNAME=username
-      - DB_PASSWORD=password
-      ## SSH config
-      - SSH_HOST="hostname"
-      - SSH_PORT=22
-      - SSH_USER=user
-      - REMOTE_PATH=/home/jkaninda/backups
-      - SSH_IDENTIFY_FILE=/tmp/id_ed25519
-      ## We advise you to use a private jey instead of password
-      #- SSH_PASSWORD=password
+   mysql-bkup:
+      # In production, lock your image tag to a specific release version
+      # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+      # for available releases.
+      image: jkaninda/mysql-bkup
+      container_name: mysql-bkup
+      command: backup --storage remote -d database
+      volumes:
+         - ./id_ed25519:/tmp/id_ed25519
+      environment:
+         - DB_PORT=3306
+         - DB_HOST=mysql
+         - DB_NAME=database
+         - DB_USERNAME=username
+         - DB_PASSWORD=password
+         ## SSH Configuration
+         - SSH_HOST="hostname"
+         - SSH_PORT=22
+         - SSH_USER=user
+         - REMOTE_PATH=/home/jkaninda/backups
+         - SSH_IDENTIFY_FILE=/tmp/id_ed25519
+         ## Optional: Use password instead of private key (not recommended)
+         #- SSH_PASSWORD=password
+
+      # Ensure the mysql-bkup container is connected to the same network as your database
+      networks:
+         - web
 
-    # mysql-bkup container must be connected to the same network with your database
-    networks:
-      - web
 networks:
-  web:
+   web:
 ```
 
+---
 
-### Recurring backups to SSH remote server
+## Recurring Backups to SSH Remote Server
 
-As explained above, you need just to add required environment variables and specify the storage type `--storage ssh`.
-You can use `--cron-expression "* * * * *"` or  `BACKUP_CRON_EXPRESSION=0 1 * * *` as described below.
+To schedule recurring backups, you can use the `--cron-expression` flag or the `BACKUP_CRON_EXPRESSION` environment variable. 
+This allows you to define a cron schedule for automated backups.
 
-```yml
+### Example: Recurring Backup Configuration
+
+```yaml
 services:
-  mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+   mysql-bkup:
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command: backup -d database --storage ssh --cron-expression "0 1 * * *"
+    command: backup -d database --storage ssh --cron-expression "@daily"
     volumes:
-      - ./id_ed25519:/tmp/id_ed25519"
+      - ./id_ed25519:/tmp/id_ed25519
     environment:
       - DB_PORT=3306
-      - DB_HOST=mysql
+      - DB_HOST=postgres
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## SSH config
+      ## SSH Configuration
       - SSH_HOST="hostname"
       - SSH_PORT=22
       - SSH_USER=user
       - REMOTE_PATH=/home/jkaninda/backups
       - SSH_IDENTIFY_FILE=/tmp/id_ed25519
-     # - BACKUP_CRON_EXPRESSION=0 1 * * * # Optional
-      #Delete old backup created more than specified days ago
+      ## Optional: Delete old backups after a specified number of days
       #- BACKUP_RETENTION_DAYS=7
-      ## We advise you to use a private jey instead of password
+      ## Optional: Use password instead of private key (not recommended)
       #- SSH_PASSWORD=password
-     # mysql-bkup container must be connected to the same network with your database
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
+
+---
+
+## Key Notes
+
+- **Cron Expression**: Use the `--cron-expression` flag or `BACKUP_CRON_EXPRESSION` environment variable to define the backup schedule. For example, `0 1 * * *` runs the backup daily at 1:00 AM.
+- **Backup Retention**: Optionally, use the `BACKUP_RETENTION_DAYS` environment variable to automatically delete backups older than a specified number of days.
+- **Security**: Always prefer private key authentication (`SSH_IDENTIFY_FILE`) over password-based authentication (`SSH_PASSWORD`) for enhanced security.
+
+---

docs/how-tos/backup.md

@@ -5,26 +5,35 @@ parent: How Tos
 nav_order: 1
 ---
 
-# Backup database
+# Backup Database
 
-To backup the database, you need to add `backup` command.
+To back up your database, use the `backup` command.
+
+This section explains how to configure and run backups, including recurring backups, using Docker or Kubernetes.
+
+---
+
+## Default Configuration
+
+- **Storage**: By default, backups are stored locally in the `/backup` directory.
+- **Compression**: Backups are compressed using `gzip` by default. Use the `--disable-compression` flag to disable compression.
+- **Security**: It is recommended to create a dedicated user with read-only access for backup tasks.
 
 {: .note }
-The default storage is local storage mounted to __/backup__. The backup is compressed by default using gzip. The flag __`disable-compression`__ can be used when you need to disable backup compression.
+The backup process supports recurring backups on Docker or Docker Swarm. On Kubernetes, it can be deployed as a CronJob.
 
-{: .warning }
-Creating a user for backup tasks who has read-only access is recommended!
+---
 
-The backup process can be run in scheduled mode for the recurring backups.
-It handles __recurring__ backups of mysql database on Docker and can be deployed as __CronJob on Kubernetes__ using local, AWS S3 or SSH compatible storage.
+## Example: Basic Backup Configuration
 
-```yml
+Below is an example `docker-compose.yml` configuration for backing up a database:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: backup -d database
@@ -36,36 +45,47 @@ services:
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-    # mysql-bkup container must be connected to the same network with your database
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
 
-### Backup using Docker CLI
+---
 
-```shell
- docker run --rm --network your_network_name \
- -v $PWD/backup:/backup/ \
- -e "DB_HOST=dbhost" \
- -e "DB_USERNAME=username" \
- -e "DB_PASSWORD=password" \
- jkaninda/mysql-bkup  backup -d database_name
+## Backup Using Docker CLI
+
+You can also run backups directly using the Docker CLI:
+
+```bash
+docker run --rm --network your_network_name \
+  -v $PWD/backup:/backup/ \
+  -e "DB_HOST=dbhost" \
+  -e "DB_USERNAME=username" \
+  -e "DB_PASSWORD=password" \
+  jkaninda/pg-bkup backup -d database_name
 ```
 
-In case you need to use recurring backups, you can use `--cron-expression "0 1 * * *"` flag or  `BACKUP_CRON_EXPRESSION=0 1 * * *` as described below.
+---
 
-```yml
+## Recurring Backups
+
+To schedule recurring backups, use the `--cron-expression (-e)` flag or the `BACKUP_CRON_EXPRESSION` environment variable. This allows you to define a cron schedule for automated backups.
+
+### Example: Recurring Backup Configuration
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command: backup -d database --cron-expression "0 1 * * *"
+    command: backup -d database --cron-expression @midnight
     volumes:
       - ./backup:/backup
     environment:
@@ -74,13 +94,24 @@ services:
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      - BACKUP_CRON_EXPRESSION=0 1 * * *
-      #Delete old backup created more than specified days ago
+      ## Optional: Define a cron schedule for recurring backups
+      - BACKUP_CRON_EXPRESSION=@midnight
+      ## Optional: Delete old backups after a specified number of days
       #- BACKUP_RETENTION_DAYS=7
-    # mysql-bkup container must be connected to the same network with your database
+     
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
 
+---
+
+## Key Notes
+
+- **Cron Expression**: Use the `--cron-expression (-e)` flag or `BACKUP_CRON_EXPRESSION` environment variable to define the backup schedule. For example:
+    - `@midnight`: Runs the backup daily at midnight.
+    - `0 1 * * *`: Runs the backup daily at 1:00 AM.
+- **Backup Retention**: Optionally, use the `BACKUP_RETENTION_DAYS` environment variable to automatically delete backups older than a specified number of days.

docs/how-tos/deploy-on-kubernetes.md

@@ -5,12 +5,17 @@ parent: How Tos
 nav_order: 9
 ---
 
-## Deploy on Kubernetes
+# Deploy on Kubernetes
 
-To deploy MySQL Backup on Kubernetes, you can use Job to backup or Restore your database.
-For recurring backup you can use CronJob, you don't need to run it in scheduled mode. as described bellow.
+To deploy MySQL Backup on Kubernetes, you can use a `Job` for one-time backups or restores, and a `CronJob` for recurring backups. 
 
-## Backup to S3 storage
+Below are examples for different use cases.
+
+---
+
+## Backup Job to S3 Storage
+
+This example demonstrates how to configure a Kubernetes `Job` to back up a MySQL database to an S3-compatible storage.
 
 ```yaml
 apiVersion: batch/v1
@@ -21,50 +26,53 @@ spec:
   template:
     spec:
       containers:
-        - name: mysql-bkup
-          # In production, it is advised to lock your image tag to a proper
-          # release version instead of using `latest`.
-          # Check https://github.com/jkaninda/mysql-bkup/releases
-          # for a list of available releases.
-          image: jkaninda/mysql-bkup
-          command:
-            - /bin/sh
-            - -c
-            - backup --storage s3
-          resources:
-            limits:
-              memory: "128Mi"
-              cpu: "500m"
-          env:
-            - name: DB_PORT
-              value: "3306"
-            - name: DB_HOST
-              value: ""
-            - name: DB_NAME
-              value: "dbname"
-            - name: DB_USERNAME
-              value: "username"
-            # Please use secret!
-            - name: DB_PASSWORD
-              value: ""
-            - name: AWS_S3_ENDPOINT
-              value: "https://s3.amazonaws.com"
-            - name: AWS_S3_BUCKET_NAME
-              value: "xxx"
-            - name: AWS_REGION
-              value: "us-west-2"
-            - name: AWS_ACCESS_KEY
-              value: "xxxx"
-            - name: AWS_SECRET_KEY
-              value: "xxxx"
-            - name: AWS_DISABLE_SSL
-              value: "false"
-            - name: AWS_FORCE_PATH_STYLE
-              value: "false"
+      - name: mysql-bkup
+        # In production, lock your image tag to a specific release version
+        # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+        # for available releases.
+        image: jkaninda/mysql-bkup
+        command:
+        - /bin/sh
+        - -c
+        - backup --storage s3
+        resources:
+          limits:
+            memory: "128Mi"
+            cpu: "500m"
+        env:
+          - name: DB_PORT
+            value: "3306"
+          - name: DB_HOST
+            value: ""
+          - name: DB_NAME
+            value: ""
+          - name: DB_USERNAME
+            value: ""
+          # Use Kubernetes Secrets for sensitive data like passwords
+          - name: DB_PASSWORD
+            value: ""
+          - name: AWS_S3_ENDPOINT
+            value: "https://s3.amazonaws.com"
+          - name: AWS_S3_BUCKET_NAME
+            value: "xxx"
+          - name: AWS_REGION
+            value: "us-west-2"
+          - name: AWS_ACCESS_KEY
+            value: "xxxx"
+          - name: AWS_SECRET_KEY
+            value: "xxxx"
+          - name: AWS_DISABLE_SSL
+            value: "false"
+          - name: AWS_FORCE_PATH_STYLE
+            value: "false"
       restartPolicy: Never
 ```
 
-## Backup Job to SSH remote server
+---
+
+## Backup Job to SSH Remote Server
+
+This example demonstrates how to configure a Kubernetes `Job` to back up a MySQL database to an SSH remote server.
 
 ```yaml
 apiVersion: batch/v1
@@ -77,15 +85,14 @@ spec:
     spec:
       containers:
       - name: mysql-bkup
-        # In production, it is advised to lock your image tag to a proper
-        # release version instead of using `latest`.
-        # Check https://github.com/jkaninda/mysql-bkup/releases
-        # for a list of available releases.
+        # In production, lock your image tag to a specific release version
+        # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+        # for available releases.
         image: jkaninda/mysql-bkup
         command:
-          - /bin/sh
-          - -c
-          - backup --storage ssh
+        - /bin/sh
+        - -c
+        - backup --storage ssh --disable-compression
         resources:
           limits:
             memory: "128Mi"
@@ -98,8 +105,8 @@ spec:
           - name: DB_NAME
             value: "dbname"
           - name: DB_USERNAME
-            value: "username"
-          # Please use secret!
+            value: "postgres"
+          # Use Kubernetes Secrets for sensitive data like passwords
           - name: DB_PASSWORD
             value: ""
           - name: SSH_HOST_NAME
@@ -112,14 +119,18 @@ spec:
             value: "xxxx"
           - name: SSH_REMOTE_PATH
             value: "/home/toto/backup"
-          # Optional, required if you want to encrypt your backup
+          # Optional: Required if you want to encrypt your backup
           - name: GPG_PASSPHRASE
-            value: "secure-passphrase"
+            value: "xxxx"
       restartPolicy: Never
 ```
 
+---
+
 ## Restore Job
 
+This example demonstrates how to configure a Kubernetes `Job` to restore a MySQL database from a backup stored on an SSH remote server.
+
 ```yaml
 apiVersion: batch/v1
 kind: Job
@@ -131,48 +142,51 @@ spec:
     spec:
       containers:
       - name: mysql-bkup
-        # In production, it is advised to lock your image tag to a proper
-        # release version instead of using `latest`.
-        # Check https://github.com/jkaninda/mysql-bkup/releases
-        # for a list of available releases.
+        # In production, lock your image tag to a specific release version
+        # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+        # for available releases.
         image: jkaninda/mysql-bkup
         command:
-          - /bin/sh
-          - -c
-          - backup --storage ssh --file store_20231219_022941.sql.gz
+        - /bin/sh
+        - -c
+        - restore --storage ssh --file store_20231219_022941.sql.gz
         resources:
           limits:
             memory: "128Mi"
             cpu: "500m"
         env:
-        - name: DB_PORT
-          value: "3306" 
-        - name: DB_HOST
-          value: ""
-        - name: DB_NAME
-          value: "dbname"
-        - name: DB_USERNAME
-          value: "username"
-        # Please use secret!
-        - name: DB_PASSWORD
-          value: ""
-        - name: SSH_HOST_NAME
-          value: "xxx"
-        - name: SSH_PORT
-          value: "22"
-        - name: SSH_USER
-          value: "xxx"
-        - name: SSH_PASSWORD
-          value: "xxxx"
-        - name: SSH_REMOTE_PATH
-          value: "/home/xxxx/backup"
-          # Optional, required if your backup was encrypted
-        #- name: GPG_PASSPHRASE
-        #  value: "xxxx"
+          - name: DB_PORT
+            value: "3306"
+          - name: DB_HOST
+            value: ""
+          - name: DB_NAME
+            value: "dbname"
+          - name: DB_USERNAME
+            value: "postgres"
+          # Use Kubernetes Secrets for sensitive data like passwords
+          - name: DB_PASSWORD
+            value: ""
+          - name: SSH_HOST_NAME
+            value: "xxx"
+          - name: SSH_PORT
+            value: "22"
+          - name: SSH_USER
+            value: "xxx"
+          - name: SSH_PASSWORD
+            value: "xxxx"
+          - name: SSH_REMOTE_PATH
+            value: "/home/toto/backup"
+          # Optional: Required if your backup was encrypted
+          #- name: GPG_PASSPHRASE
+          #  value: "xxxx"
       restartPolicy: Never
 ```
 
-## Recurring backup
+---
+
+## Recurring Backup with CronJob
+
+This example demonstrates how to configure a Kubernetes `CronJob` for recurring backups to an SSH remote server.
 
 ```yaml
 apiVersion: batch/v1
@@ -187,51 +201,51 @@ spec:
         spec:
           containers:
           - name: mysql-bkup
+            # In production, lock your image tag to a specific release version
+            # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+            # for available releases.
             image: jkaninda/mysql-bkup
             command:
             - /bin/sh
             - -c
-            - bkup
-            - backup
-            - --storage
-            - ssh
-            - --disable-compression
+            - backup --storage ssh --disable-compression
             resources:
               limits:
                 memory: "128Mi"
                 cpu: "500m"
             env:
-            - name: DB_PORT
-              value: "3306" 
-            - name: DB_HOST
-              value: ""
-            - name: DB_NAME
-              value: "username"
-            - name: DB_USERNAME
-              value: "username"
-            # Please use secret!
-            - name: DB_PASSWORD
-              value: ""
-            - name: SSH_HOST_NAME
-              value: "xxx"
-            - name: SSH_PORT
-              value: "xxx"
-            - name: SSH_USER
-              value: "jkaninda"
-            - name: SSH_REMOTE_PATH
-              value: "/home/jkaninda/backup"
-            - name: SSH_PASSWORD
-              value: "password"
-            # Optional, required if you want to encrypt your backup
-            #- name: GPG_PASSPHRASE
-            #  value: "xxx"
+              - name: DB_PORT
+                value: "3306"
+              - name: DB_HOST
+                value: ""
+              - name: DB_NAME
+                value: "test"
+              - name: DB_USERNAME
+                value: "postgres"
+              # Use Kubernetes Secrets for sensitive data like passwords
+              - name: DB_PASSWORD
+                value: ""
+              - name: SSH_HOST_NAME
+                value: "192.168.1.16"
+              - name: SSH_PORT
+                value: "2222"
+              - name: SSH_USER
+                value: "jkaninda"
+              - name: SSH_REMOTE_PATH
+                value: "/config/backup"
+              - name: SSH_PASSWORD
+                value: "password"
+              # Optional: Required if you want to encrypt your backup
+              #- name: GPG_PASSPHRASE
+              #  value: "xxx"
           restartPolicy: Never
 ```
 
-## Kubernetes Rootless
+---
 
-This image also supports Kubernetes security context, you can run it in Rootless environment.
-It has been tested on Openshift, it works well.
+## Kubernetes Rootless Deployment
+
+This example demonstrates how to run the backup container in a rootless environment, suitable for platforms like OpenShift.
 
 ```yaml
 apiVersion: batch/v1
@@ -249,53 +263,52 @@ spec:
             runAsGroup: 3000
             fsGroup: 2000
           containers:
-            # In production, it is advised to lock your image tag to a proper
-            # release version instead of using `latest`.
-            # Check https://github.com/jkaninda/mysql-bkup/releases
-            # for a list of available releases.
-            - name: mysql-bkup
-              image: jkaninda/mysql-bkup
-              command:
-                - /bin/sh
-                - -c
-                - bkup
-                - backup
-                - --storage
-                - ssh
-                - --disable-compression
-              resources:
-                limits:
-                  memory: "128Mi"
-                  cpu: "500m"
-              env:
-                - name: DB_PORT
-                  value: "3306"
-                - name: DB_HOST
-                  value: ""
-                - name: DB_NAME
-                  value: "xxx"
-                - name: DB_USERNAME
-                  value: "xxx"
-                # Please use secret!
-                - name: DB_PASSWORD
-                  value: ""
-                - name: SSH_HOST_NAME
-                  value: "xxx"
-                - name: SSH_PORT
-                  value: "22"
-                - name: SSH_USER
-                  value: "jkaninda"
-                - name: SSH_REMOTE_PATH
-                  value: "/home/jkaninda/backup"
-                - name: SSH_PASSWORD
-                  value: "password"
-              # Optional, required if you want to encrypt your backup
+          - name: mysql-bkup
+            # In production, lock your image tag to a specific release version
+            # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+            # for available releases.
+            image: jkaninda/mysql-bkup
+            command:
+            - /bin/sh
+            - -c
+            - backup --storage ssh --disable-compression
+            resources:
+              limits:
+                memory: "128Mi"
+                cpu: "500m"
+            env:
+              - name: DB_PORT
+                value: "3306"
+              - name: DB_HOST
+                value: ""
+              - name: DB_NAME
+                value: "test"
+              - name: DB_USERNAME
+                value: "postgres"
+              # Use Kubernetes Secrets for sensitive data like passwords
+              - name: DB_PASSWORD
+                value: ""
+              - name: SSH_HOST_NAME
+                value: "192.168.1.16"
+              - name: SSH_PORT
+                value: "2222"
+              - name: SSH_USER
+                value: "jkaninda"
+              - name: SSH_REMOTE_PATH
+                value: "/config/backup"
+              - name: SSH_PASSWORD
+                value: "password"
+              # Optional: Required if you want to encrypt your backup
               #- name: GPG_PASSPHRASE
               #  value: "xxx"
           restartPolicy: OnFailure
 ```
 
-## Migrate database
+---
+
+## Migrate Database
+
+This example demonstrates how to configure a Kubernetes `Job` to migrate a MySQL database from one server to another.
 
 ```yaml
 apiVersion: batch/v1
@@ -308,10 +321,9 @@ spec:
     spec:
       containers:
       - name: mysql-bkup
-        # In production, it is advised to lock your image tag to a proper
-        # release version instead of using `latest`.
-        # Check https://github.com/jkaninda/mysql-bkup/releases
-        # for a list of available releases.
+        # In production, lock your image tag to a specific release version
+        # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+        # for available releases.
         image: jkaninda/mysql-bkup
         command:
         - /bin/sh
@@ -322,11 +334,11 @@ spec:
             memory: "128Mi"
             cpu: "500m"
         env:
-        ## Source Database
+          ## Source Database
           - name: DB_HOST
-            value: "mysql"    
+            value: "postgres"
           - name: DB_PORT
-            value: "3306"  
+            value: "3306"
           - name: DB_NAME
             value: "dbname"
           - name: DB_USERNAME
@@ -335,7 +347,7 @@ spec:
             value: "password"
           ## Target Database
           - name: TARGET_DB_HOST
-            value: "target-mysql"    
+            value: "target-postgres"
           - name: TARGET_DB_PORT
             value: "3306"
           - name: TARGET_DB_NAME
@@ -345,4 +357,13 @@ spec:
           - name: TARGET_DB_PASSWORD
             value: "password"
       restartPolicy: Never
-```
+```
+
+---
+
+## Key Notes
+
+- **Security**: Always use Kubernetes Secrets for sensitive data like passwords and access keys.
+- **Resource Limits**: Adjust resource limits (`memory` and `cpu`) based on your workload requirements.
+- **Cron Schedule**: Use standard cron expressions for scheduling recurring backups.
+- **Rootless Deployment**: The image supports running in rootless environments, making it suitable for platforms like OpenShift.

docs/how-tos/encrypt-backup.md

@@ -1,47 +1,38 @@
 ---
-title: Encrypt backups
+title: Encrypt backups using GPG
 layout: default
 parent: How Tos
 nav_order: 8
 ---
-# Encrypt backup
+# Encrypt Backup
 
-The image supports encrypting backups using one of two available methods: GPG with passphrase or GPG with a public key.
-
-
-The image supports encrypting backups using GPG out of the box. In case a `GPG_PASSPHRASE` or `GPG_PUBLIC_KEY` environment variable is set, the backup archive will be encrypted using the given key and saved as a sql.gpg file instead or sql.gz.gpg.
+The image supports encrypting backups using one of two methods: **GPG with a passphrase** or **GPG with a public key**. When a `GPG_PASSPHRASE` or `GPG_PUBLIC_KEY` environment variable is set, the backup archive will be encrypted and saved as a `.sql.gpg` or `.sql.gz.gpg` file.
 
 {: .warning }
-To restore an encrypted backup, you need to provide the same GPG passphrase used during backup process.
+To restore an encrypted backup, you must provide the same GPG passphrase or private key used during the backup process.
 
-- GPG home directory `/config/gnupg`
-- Cipher algorithm `aes256`
+---
 
-{: .note }
-The backup encrypted using `GPG passphrase` method can be restored automatically, no need to decrypt it before restoration.
-Suppose you used a GPG public key during the backup process. In that case, you need to decrypt your backup before restoration because decryption using a `GPG private` key is not fully supported.
+## Key Features
 
-To decrypt manually, you need to install `gnupg`
+- **Cipher Algorithm**: `aes256`
+- **Automatic Restoration**: Backups encrypted with a GPG passphrase can be restored automatically without manual decryption.
+- **Manual Decryption**: Backups encrypted with a GPG public key require manual decryption before restoration.
 
-```shell
-gpg --batch --passphrase "my-passphrase" \
---output database_20240730_044201.sql.gz \
---decrypt database_20240730_044201.sql.gz.gpg
-```
-Using your private key
+---
 
-```shell
-gpg --output database_20240730_044201.sql.gz --decrypt database_20240730_044201.sql.gz.gpg
-```
-## Using GPG passphrase
+## Using GPG Passphrase
 
-```yml
+To encrypt backups using a GPG passphrase, set the `GPG_PASSPHRASE` environment variable. The backup will be encrypted and can be restored automatically.
+
+### Example Configuration
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: backup -d database
@@ -55,26 +46,34 @@ services:
       - DB_PASSWORD=password
       ## Required to encrypt backup
       - GPG_PASSPHRASE=my-secure-passphrase
-    # mysql-bkup container must be connected to the same network with your database
+    # Ensure the pg-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
+
+---
+
 ## Using GPG Public Key
 
-```yml
+To encrypt backups using a GPG public key, set the `GPG_PUBLIC_KEY` environment variable to the path of your public key file. Backups encrypted with a public key require manual decryption before restoration.
+
+### Example Configuration
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: backup -d database
     volumes:
       - ./backup:/backup
+      - ./public_key.asc:/config/public_key.asc
     environment:
       - DB_PORT=3306
       - DB_HOST=mysql
@@ -83,9 +82,39 @@ services:
       - DB_PASSWORD=password
       ## Required to encrypt backup
       - GPG_PUBLIC_KEY=/config/public_key.asc
-    # mysql-bkup container must be connected to the same network with your database
+    # Ensure the pg-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
-```
+```
+
+---
+
+## Manual Decryption
+
+If you encrypted your backup using a GPG public key, you must manually decrypt it before restoration. Use the `gnupg` tool for decryption.
+
+### Decrypt Using a Passphrase
+
+```bash
+gpg --batch --passphrase "my-passphrase" \
+  --output database_20240730_044201.sql.gz \
+  --decrypt database_20240730_044201.sql.gz.gpg
+```
+
+### Decrypt Using a Private Key
+
+```bash
+gpg --output database_20240730_044201.sql.gz \
+  --decrypt database_20240730_044201.sql.gz.gpg
+```
+
+---
+
+## Key Notes
+
+- **Automatic Restoration**: Backups encrypted with a GPG passphrase can be restored directly without manual decryption.
+- **Manual Decryption**: Backups encrypted with a GPG public key require manual decryption using the corresponding private key.
+- **Security**: Always keep your GPG passphrase and private key secure. Use Kubernetes Secrets or other secure methods to manage sensitive data.

docs/how-tos/migrate.md

@@ -5,76 +5,102 @@ parent: How Tos
 nav_order: 10
 ---
 
-# Migrate database
+# Migrate Database
 
-To migrate the database, you need to add `migrate` command.
+To migrate a MySQL database from a source to a target database, you can use the `migrate` command. This feature simplifies the process by combining the backup and restore operations into a single step.
 
 {: .note }
-The Mysql backup has another great feature: migrating your database from a source database to a target.
-
-As you know, to restore a database from a source to a target database, you need 2 operations: which is to start by backing up the source database and then restoring the source backed database to the target database.
-Instead of proceeding like that, you can use the integrated feature `(migrate)`, which will help you migrate your database by doing only one operation.
+The `migrate` command eliminates the need for separate backup and restore operations. It directly transfers data from the source database to the target database.
 
 {: .warning }
-The `migrate` operation is irreversible, please backup your target database before this action.
+The `migrate` operation is **irreversible**. Always back up your target database before performing this action.
 
-### Docker compose
-```yml
+---
+
+## Configuration Steps
+
+1. **Source Database**: Provide connection details for the source database.
+2. **Target Database**: Provide connection details for the target database.
+3. **Run the Migration**: Use the `migrate` command to initiate the migration.
+
+---
+
+## Example: Docker Compose Configuration
+
+Below is an example `docker-compose.yml` configuration for migrating a database:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysqlbkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: migrate
     volumes:
       - ./backup:/backup
     environment:
-      ## Source database
+      ## Source Database
       - DB_PORT=3306
       - DB_HOST=mysql
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## Target database
-      - TARGET_DB_HOST=target-mysql
+
+      ## Target Database
+      - TARGET_DB_HOST=target-postgres
       - TARGET_DB_PORT=3306
       - TARGET_DB_NAME=dbname
       - TARGET_DB_USERNAME=username
       - TARGET_DB_PASSWORD=password
-    # mysql-bkup container must be connected to the same network with your database
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
 
+---
 
-### Migrate database using Docker CLI
+## Migrate Database Using Docker CLI
 
+You can also run the migration directly using the Docker CLI. Below is an example:
 
-```
-## Source database
-DB_HOST=mysql
+### Environment Variables
+
+Save your source and target database connection details in an environment file (e.g., `your-env`):
+
+```bash
+## Source Database
+DB_HOST=postgres
 DB_PORT=3306
 DB_NAME=dbname
 DB_USERNAME=username
 DB_PASSWORD=password
 
-## Taget database
-TARGET_DB_HOST=target-mysql
+## Target Database
+TARGET_DB_HOST=target-postgres
 TARGET_DB_PORT=3306
 TARGET_DB_NAME=dbname
 TARGET_DB_USERNAME=username
 TARGET_DB_PASSWORD=password
 ```
 
-```shell
- docker run --rm --network your_network_name \
- --env-file your-env
- -v $PWD/backup:/backup/ \
- jkaninda/mysql-bkup migrate
+### Run the Migration
+
+```bash
+docker run --rm --network your_network_name \
+  --env-file your-env \
+  -v $PWD/backup:/backup/ \
+  jkaninda/pg-bkup migrate
 ```
 
+---
+
+## Key Notes
+
+- **Irreversible Operation**: The `migrate` command directly transfers data from the source to the target database. Ensure you have a backup of the target database before proceeding.
+- **Network Configuration**: Ensure the `mysql-bkup` container is connected to the same network as your source and target databases.

docs/how-tos/mutli-backup.md

@@ -1,63 +1,103 @@
 ---
-title: Run multiple backup schedules in the same container
+title: Run multiple database backup schedules in the same container
 layout: default
 parent: How Tos
 nav_order: 11
 ---
 
-Multiple backup schedules with different configuration can be configured by mounting a configuration file into `/config/config.yaml`  `/config/config.yml` or by defining an environment variable `BACKUP_CONFIG_FILE=/backup/config.yaml`.
 
-## Configuration file
+# Multiple Backup Schedules
+
+This tool supports running multiple database backup schedules within the same container.
+You can configure these schedules with different settings using a **configuration file**. This flexibility allows you to manage backups for multiple databases efficiently.
+
+---
+
+## Configuration File Setup
+
+The configuration file can be mounted into the container at `/config/config.yaml`, `/config/config.yml`, or specified via the `BACKUP_CONFIG_FILE` environment variable.
+
+### Key Features:
+- **Global Environment Variables**: Use these for databases that share the same configuration.
+- **Database-Specific Overrides**: Override global settings for individual databases by specifying them in the configuration file or using the database name as a suffix in the variable name (e.g., `DB_HOST_DATABASE1`).
+- **Global Cron Expression**: Define a global `cronExpression` in the configuration file to schedule backups for all databases. If omitted, backups will run immediately.
+- **Configuration File Path**: Specify the configuration file path using:
+    - The `BACKUP_CONFIG_FILE` environment variable.
+    - The `--config` or `-c` flag for the backup command.
+
+---
+
+## Configuration File Example
+
+Below is an example configuration file (`config.yaml`) that defines multiple databases and their respective backup settings:
 
 ```yaml
-#cronExpression: "@every 20m" //Optional for scheduled backups
-cronExpression: "" 
+# Optional: Define a global cron expression for scheduled backups.
+# Example: "@every 20m" (runs every 20 minutes). If omitted, backups run immediately.
+cronExpression: "" # Optional: Define a global cron expression for scheduled backups.
+backupRescueMode: false # Optional: Set to true to enable rescue mode for backups.
 databases:
-  - host: mysql1
-    port: 3306
-    name: database1
-    user: database1
-    password: password
-    path: /s3-path/database1 #For SSH or FTP you need to define the full path (/home/toto/backup/)
-  - host: mysql2
-    port: 3306
-    name: lldap
-    user: lldap
-    password: password
-    path: /s3-path/lldap #For SSH or FTP you need to define the full path (/home/toto/backup/)
-  - host: mysql3
-    port: 3306
-    name: keycloak
-    user: keycloak
-    password: password
-    path: /s3-path/keycloak #For SSH or FTP you need to define the full path (/home/toto/backup/)
-  - host: mysql4
-    port: 3306
-    name: joplin
-    user: joplin
-    password: password
-    path: /s3-path/joplin #For SSH or FTP you need to define the full path (/home/toto/backup/)
+  - host: mysql1       # Optional: Overrides DB_HOST or uses DB_HOST_DATABASE1.
+    port: 3306            # Optional: Default is 5432. Overrides DB_PORT or uses DB_PORT_DATABASE1.
+    name: database1       # Required: Database name.
+    user: database1       # Optional: Overrides DB_USERNAME or uses DB_USERNAME_DATABASE1.
+    password: password    # Optional: Overrides DB_PASSWORD or uses DB_PASSWORD_DATABASE1.
+    path: /s3-path/database1  # Required: Backup path for SSH, FTP, or S3 (e.g., /home/toto/backup/).
+
+  - host: mysql2       # Optional: Overrides DB_HOST or uses DB_HOST_LLAP.
+    port: 3306            # Optional: Default is 5432. Overrides DB_PORT or uses DB_PORT_LLAP.
+    name: lldap           # Required: Database name.
+    user: lldap           # Optional: Overrides DB_USERNAME or uses DB_USERNAME_LLAP.
+    password: password    # Optional: Overrides DB_PASSWORD or uses DB_PASSWORD_LLAP.
+    path: /s3-path/lldap  # Required: Backup path for SSH, FTP, or S3 (e.g., /home/toto/backup/).
+
+  - host: mysql3       # Optional: Overrides DB_HOST or uses DB_HOST_KEYCLOAK.
+    port: 3306            # Optional: Default is 5432. Overrides DB_PORT or uses DB_PORT_KEYCLOAK.
+    name: keycloak        # Required: Database name.
+    user: keycloak        # Optional: Overrides DB_USERNAME or uses DB_USERNAME_KEYCLOAK.
+    password: password    # Optional: Overrides DB_PASSWORD or uses DB_PASSWORD_KEYCLOAK.
+    path: /s3-path/keycloak  # Required: Backup path for SSH, FTP, or S3 (e.g., /home/toto/backup/).
+
+  - host: mysql4       # Optional: Overrides DB_HOST or uses DB_HOST_JOPLIN.
+    port: 3306            # Optional: Default is 5432. Overrides DB_PORT or uses DB_PORT_JOPLIN.
+    name: joplin          # Required: Database name.
+    user: joplin          # Optional: Overrides DB_USERNAME or uses DB_USERNAME_JOPLIN.
+    password: password    # Optional: Overrides DB_PASSWORD or uses DB_PASSWORD_JOPLIN.
+    path: /s3-path/joplin  # Required: Backup path for SSH, FTP, or S3 (e.g., /home/toto/backup/).
 ```
-## Docker compose file
+
+---
+
+## Docker Compose Configuration
+
+To use the configuration file in a Docker Compose setup, mount the file and specify its path using the `BACKUP_CONFIG_FILE` environment variable.
+
+### Example: Docker Compose File
 
 ```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command: backup
+    command: backup #--config /backup/config.yaml # config file
     volumes:
-      - ./backup:/backup
+      - ./backup:/backup  # Mount the backup directory
+      - ./config.yaml:/backup/config.yaml  # Mount the configuration file
     environment:
-      ## Multi backup config file
+      ## Specify the path to the configuration file
       - BACKUP_CONFIG_FILE=/backup/config.yaml
-    # mysql-bkup container must be connected to the same network with your database
+    # Ensure the pg-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
-```
+```
+
+---
+
+
+

docs/how-tos/receive-notification.md

@@ -2,12 +2,22 @@
 title: Receive notifications
 layout: default
 parent: How Tos
-nav_order: 12
+nav_order: 13
 ---
-Send Email or Telegram notifications on successfully or failed backup.
 
-### Email
-To send out email notifications on failed or successfully backup runs, provide SMTP credentials, a sender and a recipient:
+# Receive Notifications
+
+You can configure the system to send email or Telegram notifications when a backup succeeds or fails. 
+
+This section explains how to set up and customize notifications.
+
+---
+
+## Email Notifications
+
+To send email notifications, provide SMTP credentials, a sender address, and recipient addresses. Notifications will be sent for both successful and failed backup runs.
+
+### Example: Email Notification Configuration
 
 ```yaml
 services:
@@ -23,25 +33,33 @@ services:
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      - MAIL_HOST=
+      ## SMTP Configuration
+      - MAIL_HOST=smtp.example.com
       - MAIL_PORT=587
-      - MAIL_USERNAME=
-      - MAIL_PASSWORD=!
+      - MAIL_USERNAME=your-email@example.com
+      - MAIL_PASSWORD=your-email-password
       - MAIL_FROM=Backup Jobs <backup@example.com>
       ## Multiple recipients separated by a comma
       - MAIL_TO=me@example.com,team@example.com,manager@example.com
       - MAIL_SKIP_TLS=false
-      ## Time format for notification 
+      ## Time format for notifications
       - TIME_FORMAT=2006-01-02 at 15:04:05
-      ## Backup reference, in case you want to identify every backup instance
+      ## Backup reference (e.g., database/cluster name or server name)
       - BACKUP_REFERENCE=database/Paris cluster
     networks:
       - web
+
 networks:
   web:
 ```
 
-### Telegram
+---
+
+## Telegram Notifications
+
+To send Telegram notifications, provide your bot token and chat ID. Notifications will be sent for both successful and failed backup runs.
+
+### Example: Telegram Notification Configuration
 
 ```yaml
 services:
@@ -57,41 +75,49 @@ services:
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
+      ## Telegram Configuration
       - TG_TOKEN=[BOT ID]:[BOT TOKEN]
-      - TG_CHAT_ID=
-      ## Time format for notification 
+      - TG_CHAT_ID=your-chat-id
+      ## Time format for notifications
       - TIME_FORMAT=2006-01-02 at 15:04:05
-      ## Backup reference, in case you want to identify every backup instance
+      ## Backup reference (e.g., database/cluster name or server name)
       - BACKUP_REFERENCE=database/Paris cluster
     networks:
       - web
+
 networks:
   web:
 ```
 
-### Customize notifications
+---
 
-The title and body of the notifications can be tailored to your needs using Go templates.
-Template sources must be mounted inside the container in /config/templates:
+## Customize Notifications
 
-- email.tmpl: Email notification template
-- telegram.tmpl: Telegram notification template
-- email-error.tmpl: Error notification template
-- telegram-error.tmpl: Error notification template
+You can customize the title and body of notifications using Go templates. Template files must be mounted inside the container at `/config/templates`. The following templates are supported:
 
-### Data
+- `email.tmpl`: Template for successful email notifications.
+- `telegram.tmpl`: Template for successful Telegram notifications.
+- `email-error.tmpl`: Template for failed email notifications.
+- `telegram-error.tmpl`: Template for failed Telegram notifications.
 
-Here is a list of all data passed to the template:
-- `Database` : Database name
-- `StartTime`: Backup start time process
-- `EndTime`: Backup start time process
-- `Storage`: Backup storage
-- `BackupLocation`: Backup location
-- `BackupSize`: Backup size
-- `BackupReference`: Backup reference(eg: database/cluster name or server name)
+### Template Data
 
->  email.template:
+The following data is passed to the templates:
 
+- `Database`: Database name.
+- `StartTime`: Backup start time.
+- `EndTime`: Backup end time.
+- `Storage`: Backup storage type (e.g., local, S3, SSH).
+- `BackupLocation`: Backup file location.
+- `BackupSize`: Backup file size in bytes.
+- `BackupReference`: Backup reference (e.g., database/cluster name or server name).
+- `Error`: Error message (only for error templates).
+
+---
+
+### Example Templates
+
+#### `email.tmpl` (Successful Backup)
 
 ```html
 <h2>Hi,</h2>
@@ -104,29 +130,29 @@ Here is a list of all data passed to the template:
     <li>Backup Storage: {{.Storage}}</li>
     <li>Backup Location: {{.BackupLocation}}</li>
     <li>Backup Size: {{.BackupSize}} bytes</li>
-    <li>Backup Reference: {{.BackupReference}} </li>
+    <li>Backup Reference: {{.BackupReference}}</li>
 </ul>
 <p>Best regards,</p>
 ```
 
-> telegram.template
+#### `telegram.tmpl` (Successful Backup)
 
 ```html
-✅  Database Backup Notification – {{.Database}}
+✅ Database Backup Notification – {{.Database}}
 Hi,
 Backup of the {{.Database}} database has been successfully completed on {{.EndTime}}.
 
 Backup Details:
 - Database Name: {{.Database}}
 - Backup Start Time: {{.StartTime}}
-- Backup EndTime: {{.EndTime}}
+- Backup End Time: {{.EndTime}}
 - Backup Storage: {{.Storage}}
 - Backup Location: {{.BackupLocation}}
 - Backup Size: {{.BackupSize}} bytes
 - Backup Reference: {{.BackupReference}}
 ```
 
-> email-error.template
+#### `email-error.tmpl` (Failed Backup)
 
 ```html
 <!DOCTYPE html>
@@ -140,16 +166,15 @@ Backup Details:
 <p>An error occurred during database backup.</p>
 <h3>Failure Details:</h3>
 <ul>
-<li>Error Message: {{.Error}}</li>
-<li>Date: {{.EndTime}}</li>
-<li>Backup Reference: {{.BackupReference}} </li>
+    <li>Error Message: {{.Error}}</li>
+    <li>Date: {{.EndTime}}</li>
+    <li>Backup Reference: {{.BackupReference}}</li>
 </ul>
 </body>
 </html>
 ```
 
-> telegram-error.template
-
+#### `telegram-error.tmpl` (Failed Backup)
 
 ```html
 🔴 Urgent: Database Backup Failure Notification
@@ -159,4 +184,14 @@ Failure Details:
 
 Error Message: {{.Error}}
 Date: {{.EndTime}}
-```
+Backup Reference: {{.BackupReference}}
+```
+
+---
+
+## Key Notes
+
+- **SMTP Configuration**: Ensure your SMTP server supports TLS unless `MAIL_SKIP_TLS` is set to `true`.
+- **Telegram Configuration**: Obtain your bot token and chat ID from Telegram.
+- **Custom Templates**: Mount custom templates to `/config/templates` to override default notifications.
+- **Time Format**: Use the `TIME_FORMAT` environment variable to customize the timestamp format in notifications.

docs/how-tos/restore-from-s3.md

@@ -5,45 +5,71 @@ parent: How Tos
 nav_order: 6
 ---
 
-# Restore database from S3 storage
+# Restore Database from S3 Storage
 
-To restore the database, you need to add `restore` command and specify the file to restore by adding `--file store_20231219_022941.sql.gz`.
+To restore a MySQL database from a backup stored in S3, use the `restore` command and specify the backup file with the `--file` flag. The system supports the following file formats:
 
-{: .note }
-It supports __.sql__,__.sql.gpg__  and __.sql.gz__,__.sql.gz.gpg__ compressed file.
+- `.sql` (uncompressed SQL dump)
+- `.sql.gz` (gzip-compressed SQL dump)
+- `.sql.gpg` (GPG-encrypted SQL dump)
+- `.sql.gz.gpg` (GPG-encrypted and gzip-compressed SQL dump)
 
-### Restore
+---
 
-```yml
+## Configuration Steps
+
+1. **Specify the Backup File**: Use the `--file` flag to specify the backup file to restore.
+2. **Set the Storage Type**: Add the `--storage s3` flag to indicate that the backup is stored in S3.
+3. **Provide S3 Configuration**: Include the necessary AWS S3 credentials and configuration.
+4. **Provide Database Credentials**: Ensure the correct database connection details are provided.
+
+---
+
+## Example: Restore from S3 Configuration
+
+Below is an example `docker-compose.yml` configuration for restoring a database from S3 storage:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: restore --storage s3 -d my-database -f store_20231219_022941.sql.gz --path /my-custom-path
     volumes:
-      - ./backup:/backup
+      - ./backup:/backup  # Mount the directory for local operations (if needed)
     environment:
       - DB_PORT=3306
       - DB_HOST=mysql
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## AWS configurations
+      ## AWS S3 Configuration
       - AWS_S3_ENDPOINT=https://s3.amazonaws.com
       - AWS_S3_BUCKET_NAME=backup
-      - AWS_REGION="us-west-2"
+      - AWS_REGION=us-west-2
       - AWS_ACCESS_KEY=xxxx
       - AWS_SECRET_KEY=xxxxx
-      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
-      - AWS_DISABLE_SSL="false"
-      - AWS_FORCE_PATH_STYLE="false"
-    # mysql-bkup container must be connected to the same network with your database
+      ## Optional: Disable SSL for S3 alternatives like Minio
+      - AWS_DISABLE_SSL=false
+      ## Optional: Enable path-style access for S3 alternatives like Minio
+      - AWS_FORCE_PATH_STYLE=false
+    # Ensure the pg-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
 ```
+
+---
+
+## Key Notes
+
+- **Supported File Formats**: The restore process supports `.sql`, `.sql.gz`, `.sql.gpg`, and `.sql.gz.gpg` files.
+- **S3 Path**: Use the `--path` flag to specify the folder within the S3 bucket where the backup file is located.
+- **Encrypted Backups**: If the backup is encrypted with GPG, ensure the `GPG_PASSPHRASE` environment variable is set for automatic decryption.
+- **S3 Alternatives**: For S3-compatible storage like Minio, set `AWS_DISABLE_SSL` and `AWS_FORCE_PATH_STYLE` as needed.
+- **Network Configuration**: Ensure the `pg-bkup` container is connected to the same network as your database.

docs/how-tos/restore-from-ssh.md

@@ -4,44 +4,71 @@ layout: default
 parent: How Tos
 nav_order: 7
 ---
-# Restore database from SSH remote server
 
-To restore the database from your remote server, you need to add `restore` command and specify the file to restore by adding `--file store_20231219_022941.sql.gz`.
+# Restore Database from SSH Remote Server
 
-{: .note }
-It supports __.sql__,__.sql.gpg__  and __.sql.gz__,__.sql.gz.gpg__ compressed file.
+To restore a MySQL database from a backup stored on an SSH remote server, use the `restore` command and specify the backup file with the `--file` flag. The system supports the following file formats:
 
-### Restore
+- `.sql` (uncompressed SQL dump)
+- `.sql.gz` (gzip-compressed SQL dump)
+- `.sql.gpg` (GPG-encrypted SQL dump)
+- `.sql.gz.gpg` (GPG-encrypted and gzip-compressed SQL dump)
 
-```yml
+---
+
+## Configuration Steps
+
+1. **Specify the Backup File**: Use the `--file` flag to specify the backup file to restore.
+2. **Set the Storage Type**: Add the `--storage ssh` flag to indicate that the backup is stored on an SSH remote server.
+3. **Provide SSH Configuration**: Include the necessary SSH credentials and configuration.
+4. **Provide Database Credentials**: Ensure the correct database connection details are provided.
+
+---
+
+## Example: Restore from SSH Remote Server Configuration
+
+Below is an example `docker-compose.yml` configuration for restoring a database from an SSH remote server:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: restore --storage ssh -d my-database -f store_20231219_022941.sql.gz --path /home/jkaninda/backups
     volumes:
-      - ./backup:/backup
+      - ./backup:/backup  # Mount the directory for local operations (if needed)
+      - ./id_ed25519:/tmp/id_ed25519  # Mount the SSH private key file
     environment:
       - DB_PORT=3306
-      - DB_HOST=postgres
+      - DB_HOST=mysql
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-      ## SSH config
-      - SSH_HOST_NAME="hostname"
+      ## SSH Configuration
+      - SSH_HOST_NAME=hostname
       - SSH_PORT=22
       - SSH_USER=user
       - SSH_REMOTE_PATH=/home/jkaninda/backups
       - SSH_IDENTIFY_FILE=/tmp/id_ed25519
-      ## We advise you to use a private jey instead of password
+      ## Optional: Use password instead of private key (not recommended)
       #- SSH_PASSWORD=password
-    # mysql-bkup container must be connected to the same network with your database
+    # Ensure the mysql-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
-```
+```
+
+---
+
+## Key Notes
+
+- **Supported File Formats**: The restore process supports `.sql`, `.sql.gz`, `.sql.gpg`, and `.sql.gz.gpg` files.
+- **SSH Path**: Use the `--path` flag to specify the folder on the SSH remote server where the backup file is located.
+- **Encrypted Backups**: If the backup is encrypted with GPG, ensure the `GPG_PASSPHRASE` environment variable is set for automatic decryption.
+- **SSH Authentication**: Use a private key (`SSH_IDENTIFY_FILE`) for SSH authentication instead of a password for better security.
+- **Network Configuration**: Ensure the `mysql-bkup` container is connected to the same network as your database.

docs/how-tos/restore.md

@@ -5,36 +5,60 @@ parent: How Tos
 nav_order: 5
 ---
 
-# Restore database
 
-To restore the database, you need to add `restore` command and specify the file to restore by adding `--file store_20231219_022941.sql.gz`.
+# Restore Database
 
-{: .note }
-It supports __.sql__,__.sql.gpg__  and __.sql.gz__,__.sql.gz.gpg__ compressed file.
+To restore a MySQL database, use the `restore` command and specify the backup file to restore with the `--file` flag. 
 
-### Restore
+The system supports the following file formats:
 
-```yml
+- `.sql` (uncompressed SQL dump)
+- `.sql.gz` (gzip-compressed SQL dump)
+- `.sql.gpg` (GPG-encrypted SQL dump)
+- `.sql.gz.gpg` (GPG-encrypted and gzip-compressed SQL dump)
+
+---
+
+## Configuration Steps
+
+1. **Specify the Backup File**: Use the `--file` flag to specify the backup file to restore.
+2. **Provide Database Credentials**: Ensure the correct database connection details are provided.
+
+---
+
+## Example: Restore Configuration
+
+Below is an example `docker-compose.yml` configuration for restoring a database:
+
+```yaml
 services:
   mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
+    # In production, lock your image tag to a specific release version
+    # instead of using `latest`. Check https://github.com/jkaninda/mysql-bkup/releases
+    # for available releases.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
     command: restore -d database -f store_20231219_022941.sql.gz
     volumes:
-      - ./backup:/backup
+      - ./backup:/backup  # Mount the directory containing the backup file
     environment:
       - DB_PORT=3306
-      - DB_HOST=mysql
+      - DB_HOST=postgres
       - DB_NAME=database
       - DB_USERNAME=username
       - DB_PASSWORD=password
-    # mysql-bkup container must be connected to the same network with your database
+    # Ensure the pg-bkup container is connected to the same network as your database
     networks:
       - web
+
 networks:
   web:
-```
+```
+
+---
+
+## Key Notes
+
+- **Supported File Formats**: The restore process supports `.sql`, `.sql.gz`, `.sql.gpg`, and `.sql.gz.gpg` files.
+- **Encrypted Backups**: If the backup is encrypted with GPG, ensure the `GPG_PASSPHRASE` environment variable is set for automatic decryption.
+- **Network Configuration**: Ensure the `mysql-bkup` container is connected to the same network as your database.

docs/index.md

@@ -10,175 +10,76 @@ nav_order: 1
 **MYSQL-BKUP** is a Docker container image designed to **backup, restore, and migrate MySQL databases**.
 It supports a variety of storage options and ensures data security through GPG encryption.
 
-## Features
+---
 
-- **Storage Options:**
-    - Local storage
-    - AWS S3 or any S3-compatible object storage
-    - FTP
-    - SSH-compatible storage
-    - Azure Blob storage
+## Key Features
 
-- **Data Security:**
-    - Backups can be encrypted using **GPG** to ensure confidentiality.
+### Storage Options
+- **Local storage**
+- **AWS S3** or any S3-compatible object storage
+- **FTP**
+- **SFTP**
+- **SSH-compatible storage**
+- **Azure Blob storage**
 
-- **Deployment Flexibility:**
-    - Available as the [jkaninda/mysql-bkup](https://hub.docker.com/r/jkaninda/mysql-bkup) Docker image.
-    - Deployable on **Docker**, **Docker Swarm**, and **Kubernetes**.
-    - Supports recurring backups of PostgreSQL databases when deployed:
-        - On Docker for automated backup schedules.
-        - As a **Job** or **CronJob** on Kubernetes.
+### Data Security
+- Backups can be encrypted using **GPG** to ensure data confidentiality.
 
-- **Notifications:**
-    - Get real-time updates on backup success or failure via:
-        - **Telegram**
-        - **Email**
+### Deployment Flexibility
+- Available as the [jkaninda/pg-bkup](https://hub.docker.com/r/jkaninda/mysql-bkup) Docker image.
+- Deployable on **Docker**, **Docker Swarm**, and **Kubernetes**.
+- Supports recurring backups of MySQL databases:
+    - On Docker for automated backup schedules.
+    - As a **Job** or **CronJob** on Kubernetes.
+
+### Notifications
+- Receive real-time updates on backup success or failure via:
+    - **Telegram**
+    - **Email**
+
+---
 
 ## Use Cases
 
-- **Automated Recurring Backups:** Schedule regular backups for PostgreSQL databases.
-- **Cross-Environment Migration:** Easily migrate your PostgreSQL databases across different environments using supported storage options.
-- **Secure Backup Management:** Protect your data with Gmysql encryption.
+- **Automated Recurring Backups:** Schedule regular backups for MySQL databases.
+- **Cross-Environment Migration:** Easily migrate MySQL databases across different environments using supported storage options.
+- **Secure Backup Management:** Protect your data with GPG encryption.
 
+---
 
+## Get Involved
+
+We welcome contributions! Feel free to give us a ⭐, submit PRs, or open issues on our [GitHub repository](https://github.com/jkaninda/mysql-bkup).
+
+{: .fs-6 .fw-300 }
+
+---
 
 {: .note }
-Code and documentation for `v1` version on [this branch][v1-branch].
+Code and documentation for the `v1` version are available on [this branch][v1-branch].
 
 [v1-branch]: https://github.com/jkaninda/mysql-bkup
 
 ---
 
-## Quickstart
+## Available Image Registries
 
-### Simple backup using Docker CLI
+The Docker image is published to both **Docker Hub** and the **GitHub Container Registry**. You can use either of the following:
 
-To run a one time backup, bind your local volume to `/backup` in the container and run the `backup` command:
-
-```shell
- docker run --rm --network your_network_name \
- -v $PWD/backup:/backup/ \
- -e "DB_HOST=dbhost" \
- -e "DB_USERNAME=username" \
- -e "DB_PASSWORD=password" \
- jkaninda/mysql-bkup backup -d database_name
-```
-
-Alternatively, pass a `--env-file` in order to use a full config as described below.
-
-```yaml
- docker run --rm --network your_network_name \
- --env-file your-env-file \
- -v $PWD/backup:/backup/ \
- jkaninda/mysql-bkup backup -d database_name
-```
-
-### Simple backup in docker compose file
-
-```yaml
-services:
-  mysql-bkup:
-    # In production, it is advised to lock your image tag to a proper
-    # release version instead of using `latest`.
-    # Check https://github.com/jkaninda/mysql-bkup/releases
-    # for a list of available releases.
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    command: backup
-    volumes:
-      - ./backup:/backup
-    environment:
-      - DB_PORT=3306
-      - DB_HOST=mysql
-      - DB_NAME=foo
-      - DB_USERNAME=bar
-      - DB_PASSWORD=password
-      - TZ=Europe/Paris
-    # mysql-bkup container must be connected to the same network with your database
-    networks:
-       - web
-networks:
-  web:
-```
-### Docker recurring backup
-
-```shell
- docker run --rm --network network_name \
- -v $PWD/backup:/backup/ \
- -e "DB_HOST=hostname" \
- -e "DB_USERNAME=user" \
- -e "DB_PASSWORD=password" \
- jkaninda/mysql-bkup backup -d dbName --cron-expression "@every 15m" #@midnight
-```
-See: https://jkaninda.github.io/mysql-bkup/reference/#predefined-schedules
-
-## Kubernetes
-
-```yaml
-apiVersion: batch/v1
-kind: Job
-metadata:
-  name: backup-job
-spec:
-  ttlSecondsAfterFinished: 100
-  template:
-    spec:
-      containers:
-        - name: mysql-bkup
-          # In production, it is advised to lock your image tag to a proper
-          # release version instead of using `latest`.
-          # Check https://github.com/jkaninda/mysql-bkup/releases
-          # for a list of available releases.
-          image: jkaninda/mysql-bkup
-          command:
-            - /bin/sh
-            - -c
-            - backup -d dbname
-          resources:
-            limits:
-              memory: "128Mi"
-              cpu: "500m"
-          env:
-            - name: DB_HOST
-              value: "mysql"
-            - name: DB_USERNAME
-              value: "user"
-            - name: DB_PASSWORD
-              value: "password"
-          volumeMounts:
-            - mountPath: /backup
-              name: backup
-      volumes:
-        - name: backup
-          hostPath:
-            path: /home/toto/backup # directory location on host
-            type: Directory # this field is optional
-      restartPolicy: Never
-```
-
-## Available image registries
-
-This Docker image is published to both Docker Hub and the GitHub container registry.
-Depending on your preferences and needs, you can reference both `jkaninda/mysql-bkup` as well as `ghcr.io/jkaninda/mysql-bkup`:
-
-```
+```bash
 docker pull jkaninda/mysql-bkup
 docker pull ghcr.io/jkaninda/mysql-bkup
 ```
 
-Documentation references Docker Hub, but all examples will work using ghcr.io just as well.
+While the documentation references Docker Hub, all examples work seamlessly with `ghcr.io`.
 
-## Supported Engines
-
-This image is developed and tested against the Docker CE engine and Kubernetes exclusively.
-While it may work against different implementations, there are no guarantees about support for non-Docker engines.
+---
 
 ## References
 
-We decided to publish this image as a simpler and more lightweight alternative because of the following requirements:
+We created this image as a simpler and more lightweight alternative to existing solutions. Here’s why:
 
-- The original image is based on `alpine` and requires additional tools, making it heavy.
-- This image is written in Go.
-- `arm64` and `arm/v7` architectures are supported.
-- Docker in Swarm mode is supported.
-- Kubernetes is supported.
+- **Lightweight:** Written in Go, the image is optimized for performance and minimal resource usage.
+- **Multi-Architecture Support:** Supports `arm64` and `arm/v7` architectures.
+- **Docker Swarm Support:** Fully compatible with Docker in Swarm mode.
+- **Kubernetes Support:** Designed to work seamlessly with Kubernetes.

docs/quickstart/index.md

@@ -0,0 +1,152 @@
+---
+title: Quickstart
+layout: home
+nav_order: 2
+---
+
+# Quickstart
+
+This guide provides quick examples for running backups using Docker CLI, Docker Compose, and Kubernetes.
+
+---
+
+## Simple Backup Using Docker CLI
+
+To run a one-time backup, bind your local volume to `/backup` in the container and execute the `backup` command:
+
+```bash
+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
+```
+
+### Using an Environment File
+
+Alternatively, you can use an `--env-file` to pass a full configuration:
+
+```bash
+docker run --rm --network your_network_name \
+  --env-file your-env-file \
+  -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 Using Docker Compose
+
+Below is an example `docker-compose.yml` configuration for running a backup:
+
+```yaml
+services:
+  mysql-bkup:
+    # In production, lock the image tag to a specific release version.
+    # Check https://github.com/jkaninda/mysql-bkup/releases for available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=foo
+      - DB_USERNAME=bar
+      - DB_PASSWORD=password
+      - TZ=Europe/Paris
+    # Ensure the mysql-bkup container is connected to the same network as your database.
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## Recurring Backup with Docker
+
+To schedule recurring backups, use the `--cron-expression` flag:
+
+```bash
+docker run --rm --network network_name \
+  -v $PWD/backup:/backup/ \
+  -e "DB_HOST=hostname" \
+  -e "DB_USERNAME=user" \
+  -e "DB_PASSWORD=password" \
+  jkaninda/mysql-bkup backup -d dbName --cron-expression "@every 15m"
+```
+
+For predefined schedules, refer to the [documentation](https://jkaninda.github.io/mysql-bkup/reference/#predefined-schedules).
+
+---
+
+## Backup Using Kubernetes
+
+Below is an example Kubernetes `Job` configuration for running a backup:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup-job
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          # In production, lock the image tag to a specific release version.
+          # Check https://github.com/jkaninda/mysql-bkup/releases for available releases.
+          image: jkaninda/mysql-bkup
+          command:
+            - /bin/sh
+            - -c
+            - backup -d dbname
+          resources:
+            limits:
+              memory: "128Mi"
+              cpu: "500m"
+          env:
+            - name: DB_HOST
+              value: "mysql"
+            - name: DB_USERNAME
+              value: "postgres"
+            - name: DB_PASSWORD
+              value: "password"
+          volumeMounts:
+            - mountPath: /backup
+              name: backup
+      volumes:
+        - name: backup
+          hostPath:
+            path: /home/toto/backup  # Directory location on the host
+            type: Directory  # Optional field
+      restartPolicy: Never
+```
+
+---
+
+## Key Notes
+
+- **Volume Binding**: Ensure the `/backup` directory is mounted to persist backup files.
+- **Environment Variables**: Use environment variables or an `--env-file` to pass database credentials and other configurations.
+- **Cron Expressions**: Use standard cron expressions or predefined schedules for recurring backups.
+- **Kubernetes Jobs**: Use Kubernetes `Job` or `CronJob` for running backups in a Kubernetes cluster.

docs/reference/index.md

@@ -1,137 +1,132 @@
 ---
 title: Configuration Reference
 layout: default
-nav_order: 2
+nav_order: 3
 ---
 
-# Configuration reference
+# Configuration Reference
 
-Backup, restore and migrate targets, schedule and retention are configured using environment variables or flags.
+MySQL backup, restore, and migration processes can be configured using **environment variables** or **CLI flags**.
 
+## CLI Utility Usage
 
+The `mysql-bkup` CLI provides commands and options to manage MySQL backups efficiently.
 
-
-
-###  CLI utility Usage
-
-| Options               | Shorts | Usage                                                                                  |
-|-----------------------|--------|----------------------------------------------------------------------------------------|
-| mysql-bkup            | bkup   | CLI utility                                                                            |
-| backup                |        | Backup database operation                                                              |
-| restore               |        | Restore database operation                                                             |
-| migrate               |        | Migrate database from one instance to another one                                      |
-| --storage             | -s     | Storage. local or s3 (default: local)                                                  |
-| --file                | -f     | File name for restoration                                                              |
-| --path                |        | AWS S3 path without file name. eg: /custom_path  or ssh remote path `/home/foo/backup` |
-| --dbname              | -d     | Database name                                                                          |
-| --port                | -p     | Database port (default: 3306)                                                          |
-| --disable-compression |        | Disable database backup compression                                                    |
-| --cron-expression     |        | Backup cron expression, eg: (* * * * *) or @daily                                      |
-| --help                | -h     | Print this help message and exit                                                       |
-| --version             | -V     | Print version information and exit                                                     |
-
-## Environment variables
-
-| Name                   | Requirement                                                   | Description                                                     |
-|------------------------|---------------------------------------------------------------|-----------------------------------------------------------------|
-| DB_PORT                | Optional, default 3306                                        | Database port number                                            |
-| DB_HOST                | Required                                                      | Database host                                                   |
-| DB_NAME                | Optional if it was provided from the -d flag                  | Database name                                                   |
-| DB_USERNAME            | Required                                                      | Database user name                                              |
-| DB_PASSWORD            | Required                                                      | Database password                                               |
-| AWS_ACCESS_KEY         | Optional, required for S3 storage                             | AWS S3 Access Key                                               |
-| AWS_SECRET_KEY         | Optional, required for S3 storage                             | AWS S3 Secret Key                                               |
-| AWS_BUCKET_NAME        | Optional, required for S3 storage                             | AWS S3 Bucket Name                                              |
-| AWS_BUCKET_NAME        | Optional, required for S3 storage                             | AWS S3 Bucket Name                                              |
-| AWS_REGION             | Optional, required for S3 storage                             | AWS Region                                                      |
-| AWS_DISABLE_SSL        | Optional, required for S3 storage                             | Disable SSL                                                     |
-| AWS_FORCE_PATH_STYLE   | Optional, required for S3 storage                             | Force path style                                                |
-| FILE_NAME              | Optional if it was provided from the --file flag              | Database file to restore (extensions: .sql, .sql.gz)            |
-| GPG_PASSPHRASE         | Optional, required to encrypt and restore backup              | GPG passphrase                                                  |
-| GPG_PUBLIC_KEY         | Optional, required to encrypt backup                          | GPG public key, used to encrypt backup (/config/public_key.asc) |
-| BACKUP_CRON_EXPRESSION | Optional if it was provided from the `--cron-expression` flag | Backup cron expression for docker in scheduled mode             |
-| BACKUP_RETENTION_DAYS  | Optional                                                      | Delete old backup created more than specified days ago          |
-| SSH_HOST               | Optional, required for SSH storage                            | ssh remote hostname or ip                                       |
-| SSH_USER               | Optional, required for SSH storage                            | ssh remote user                                                 |
-| SSH_PASSWORD           | Optional, required for SSH storage                            | ssh remote user's password                                      |
-| SSH_IDENTIFY_FILE      | Optional, required for SSH storage                            | ssh remote user's private key                                   |
-| SSH_PORT               | Optional, required for SSH storage                            | ssh remote server port                                          |
-| REMOTE_PATH            | Optional, required for SSH or FTP storage                     | remote path (/home/toto/backup)                                 |
-| FTP_HOST               | Optional, required for FTP storage                            | FTP host name                                                   |
-| FTP_PORT               | Optional, required for FTP storage                            | FTP server port number                                          |
-| FTP_USER               | Optional, required for FTP storage                            | FTP user                                                        |
-| FTP_PASSWORD           | Optional, required for FTP storage                            | FTP user password                                               |
-| TARGET_DB_HOST         | Optional, required for database migration                     | Target database host                                            |
-| TARGET_DB_PORT         | Optional, required for database migration                     | Target database port                                            |
-| TARGET_DB_NAME         | Optional, required for database migration                     | Target database name                                            |
-| TARGET_DB_USERNAME     | Optional, required for database migration                     | Target database username                                        |
-| TARGET_DB_PASSWORD     | Optional, required for database migration                     | Target database password                                        |
-| TG_TOKEN               | Optional, required for Telegram notification                  | Telegram token (`BOT-ID:BOT-TOKEN`)                             |
-| TG_CHAT_ID             | Optional, required for Telegram notification                  | Telegram Chat ID                                                |
-| TZ                     | Optional                                                      | Time Zone                                                       |
+| Option                  | Short Flag | Description                                                                             |
+|-------------------------|------------|-----------------------------------------------------------------------------------------|
+| `mysql-bkup`            | `bkup`     | CLI tool for managing MySQL backups, restoration, and migration.                        |
+| `backup`                |            | Executes a backup operation.                                                            |
+| `restore`               |            | Restores a database from a backup file.                                                 |
+| `migrate`               |            | Migrates a database from one instance to another.                                       |
+| `--storage`             | `-s`       | Specifies the storage type (`local`, `s3`, `ssh`, etc.). Default: `local`.              |
+| `--file`                | `-f`       | Defines the backup file name for restoration.                                           |
+| `--path`                |            | Sets the storage path (e.g., `/custom_path` for S3 or `/home/foo/backup` for SSH).      |
+| `--config`              | `-c`       | Provides a configuration file for multi-database backups (e.g., `/backup/config.yaml`). |
+| `--dbname`              | `-d`       | Specifies the database name to back up or restore.                                      |
+| `--port`                | `-p`       | Defines the database port. Default: `3306`.                                             |
+| `--disable-compression` |            | Disables compression for database backups.                                              |
+| `--cron-expression`     | `-e`       | Schedules backups using a cron expression (e.g., `0 0 * * *` or `@daily`).              |
+| `--all-databases`       | `-a`       | Backs up all databases separately (e.g., `backup --all-databases`).                     |
+| `--all-in-one`          | `-A`       | Backs up all databases in a single file (e.g., `backup --all-databases --single-file`). |
+| `--custom-name`         | ``         | Sets custom backup name for one time backup                                             |
+| `--help`                | `-h`       | Displays the help message and exits.                                                    |
+| `--version`             | `-V`       | Shows version information and exits.                                                    |
 
 ---
-## Run in Scheduled mode
 
-This image can be run as CronJob in Kubernetes for a regular backup which makes deployment on Kubernetes easy as Kubernetes has CronJob resources.
-For Docker, you need to run it in scheduled mode by adding `--cron-expression  "* * * * *"` flag or by defining `BACKUP_CRON_EXPRESSION=0 1 * * *` environment variable.
+## Environment Variables
 
-## Syntax of crontab (field description)
+| Name                           | Requirement                          | Description                                                                |
+|--------------------------------|--------------------------------------|----------------------------------------------------------------------------|
+| `DB_PORT`                      | Optional (default: `3306`)           | Database port number.                                                      |
+| `DB_HOST`                      | Required                             | Database host.                                                             |
+| `DB_NAME`                      | Optional (if provided via `-d` flag) | Database name.                                                             |
+| `DB_USERNAME`                  | Required                             | Database username.                                                         |
+| `DB_PASSWORD`                  | Required                             | Database password.                                                         |
+| `DB_SSL_CA`                    | Optional                             | Database client CA certificate file                                        |
+| `DB_SSL_MODE`                  | Optional(`0 or 1`) default: `0`      | Database client Enable CA validation                                       |
+| `AWS_ACCESS_KEY`               | Required for S3 storage              | AWS S3 Access Key.                                                         |
+| `AWS_SECRET_KEY`               | Required for S3 storage              | AWS S3 Secret Key.                                                         |
+| `AWS_BUCKET_NAME`              | Required for S3 storage              | AWS S3 Bucket Name.                                                        |
+| `AWS_REGION`                   | Required for S3 storage              | AWS Region.                                                                |
+| `AWS_DISABLE_SSL`              | Optional                             | Disable SSL for S3 storage.                                                |
+| `AWS_FORCE_PATH_STYLE`         | Optional                             | Force path-style access for S3 storage.                                    |
+| `FILE_NAME`                    | Optional (if provided via `--file`)  | File name for restoration (e.g., `.sql`, `.sql.gz`).                       |
+| `GPG_PASSPHRASE`               | Optional                             | GPG passphrase for encrypting/decrypting backups.                          |
+| `GPG_PUBLIC_KEY`               | Optional                             | GPG public key for encrypting backups (e.g., `/config/public_key.asc`).    |
+| `BACKUP_CRON_EXPRESSION`       | Optional (flag `-e`)                 | Cron expression for scheduled backups.                                     |
+| `BACKUP_RETENTION_DAYS`        | Optional                             | Delete backups older than the specified number of days.                    |
+| `BACKUP_CONFIG_FILE`           | Optional  (flag `-c`)                | Configuration file for multi database backup. (e.g: `/backup/config.yaml`) |
+| `SSH_HOST`                     | Required for SSH storage             | SSH remote hostname or IP.                                                 |
+| `SSH_USER`                     | Required for SSH storage             | SSH remote username.                                                       |
+| `SSH_PASSWORD`                 | Optional                             | SSH remote user's password.                                                |
+| `SSH_IDENTIFY_FILE`            | Optional                             | SSH remote user's private key.                                             |
+| `SSH_PORT`                     | Optional (default: `22`)             | SSH remote server port.                                                    |
+| `REMOTE_PATH`                  | Required for SSH/FTP storage         | Remote path (e.g., `/home/toto/backup`).                                   |
+| `FTP_HOST`                     | Required for FTP storage             | FTP hostname.                                                              |
+| `FTP_PORT`                     | Optional (default: `21`)             | FTP server port.                                                           |
+| `FTP_USER`                     | Required for FTP storage             | FTP username.                                                              |
+| `FTP_PASSWORD`                 | Required for FTP storage             | FTP user password.                                                         |
+| `TARGET_DB_HOST`               | Required for migration               | Target database host.                                                      |
+| `TARGET_DB_PORT`               | Optional (default: `5432`)           | Target database port.                                                      |
+| `TARGET_DB_NAME`               | Required for migration               | Target database name.                                                      |
+| `TARGET_DB_USERNAME`           | Required for migration               | Target database username.                                                  |
+| `TARGET_DB_PASSWORD`           | Required for migration               | Target database password.                                                  |
+| `TARGET_DB_URL`                | Optional                             | Target database URL in JDBC URI format.                                    |
+| `TG_TOKEN`                     | Required for Telegram notifications  | Telegram token (`BOT-ID:BOT-TOKEN`).                                       |
+| `TG_CHAT_ID`                   | Required for Telegram notifications  | Telegram Chat ID.                                                          |
+| `TZ`                           | Optional                             | Time zone for scheduling.                                                  |
+| `AZURE_STORAGE_CONTAINER_NAME` | Required for Azure Blob Storage      | Azure storage container name.                                              |
+| `AZURE_STORAGE_ACCOUNT_NAME`   | Required for Azure Blob Storage      | Azure storage account name.                                                |
+| `AZURE_STORAGE_ACCOUNT_KEY`    | Required for Azure Blob Storage      | Azure storage account key.                                                 |
 
-The syntax is:
+---
 
-- 1: Minute (0-59)
-- 2: Hours (0-23)
-- 3: Day (0-31)
-- 4: Month (0-12 [12 == December])
-- 5: Day of the week(0-7 [7 or 0 == sunday])
+## Scheduled Backups
 
-Easy to remember format:
+### Running in Scheduled Mode
+
+- **Docker**: Use the `--cron-expression` flag or the `BACKUP_CRON_EXPRESSION` environment variable to schedule backups.
+- **Kubernetes**: Use a `CronJob` resource for scheduled backups.
+
+### Cron Syntax
+
+The cron syntax consists of five fields:
 
 ```conf
-* * * * * command to be executed
+* * * * * command
 ```
 
+| Field         | Description                  | Values         |
+|---------------|------------------------------|----------------|
+| Minute        | Minute of the hour           | `0-59`         |
+| Hour          | Hour of the day              | `0-23`         |
+| Day of Month  | Day of the month             | `1-31`         |
+| Month         | Month of the year            | `1-12`         |
+| Day of Week   | Day of the week (0 = Sunday) | `0-7`          |
+
+#### Examples
+
+- **Every 30 minutes**: `*/30 * * * *`
+- **Every hour at minute 0**: `0 * * * *`
+- **Every day at 1:00 AM**: `0 1 * * *`
+
+### Predefined Schedules
+
+| Entry                      | Description                                | Equivalent To |
+|----------------------------|--------------------------------------------|---------------|
+| `@yearly` (or `@annually`) | Run once a year, midnight, Jan. 1st        | `0 0 1 1 *`   |
+| `@monthly`                 | Run once a month, midnight, first of month | `0 0 1 * *`   |
+| `@weekly`                  | Run once a week, midnight between Sat/Sun  | `0 0 * * 0`   |
+| `@daily` (or `@midnight`)  | Run once a day, midnight                   | `0 0 * * *`   |
+| `@hourly`                  | Run once an hour, beginning of hour        | `0 * * * *`   |
+
+### Intervals
+
+You can also schedule backups at fixed intervals using the format:
+
 ```conf
-- - - - -
-| | | | |
-| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
-| | | ------- Month (1 - 12)
-| | --------- Day of month (1 - 31)
-| ----------- Hour (0 - 23)
-------------- Minute (0 - 59)
-```
-
-> At every 30th minute
-
-```conf
-*/30 * * * *
-```
-> “At minute 0.” every hour
-```conf
-0 * * * *
-```
-
-> “At 01:00.” every day
-
-```conf
-0 1 * * *
-```
-## Predefined schedules 
-You may use one of several pre-defined schedules in place of a cron expression.
-
-| Entry                  | Description                                | Equivalent To |
-|------------------------|--------------------------------------------|---------------|
-| @yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *     |
-| @monthly               | Run once a month, midnight, first of month | 0 0 1 * *     |
-| @weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0     |
-| @daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *     |
-| @hourly                | Run once an hour, beginning of hour        | 0 * * * *     |
-
-### Intervals 
-You may also schedule backup task at fixed intervals, starting at the time it's added or cron is run. This is supported by formatting the cron spec like this:
-
 @every <duration>
-where "duration" is a string accepted by time.
+```
 
-For example, "@every 1h30m10s" would indicate a schedule that activates after 1 hour, 30 minutes, 10 seconds, and then every interval after that.
+- Example: `@every 1h30m10s` runs the backup every 1 hour, 30 minutes, and 10 seconds.

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-20241013064832-ed4bd6a1b221
-	github.com/jkaninda/go-storage v0.1.2
+	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
 )
 
@@ -17,12 +18,12 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.16.0 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.5.0 // indirect
-	github.com/ProtonMail/go-crypto v0.0.0-20230717121422-5aa5874ade95 // indirect
+	github.com/ProtonMail/go-crypto v1.1.0 // indirect
 	github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f // indirect
-	github.com/ProtonMail/gopenpgp/v2 v2.7.5 // indirect
+	github.com/ProtonMail/gopenpgp/v2 v2.8.0 // indirect
 	github.com/aws/aws-sdk-go v1.55.5 // indirect
 	github.com/bramvdbogaerde/go-scp v1.5.0 // indirect
-	github.com/cloudflare/circl v1.3.3 // indirect
+	github.com/cloudflare/circl v1.3.7 // indirect
 	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

go.sum

@@ -1,30 +1,37 @@
 github.com/Azure/azure-sdk-for-go/sdk/azcore v1.16.0 h1:JZg6HRh6W6U4OLl6lk7BZ7BLisIzM9dG1R50zUk9C/M=
 github.com/Azure/azure-sdk-for-go/sdk/azcore v1.16.0/go.mod h1:YL1xnZ6QejvQHWJrX/AvhFl4WW4rqHVoKspWNVwFk0M=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0 h1:B/dfvscEQtew9dVuoxqxrUKKv8Ih2f55PydknDamU+g=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0/go.mod h1:fiPSssYvltE08HJchL04dOy+RD4hgrjph0cwGGMntdI=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.6.0 h1:PiSrjRPpkQNjrM8H0WwKMnZUdu1RGMtd/LdGKUrOo+c=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.6.0/go.mod h1:oDrbWx4ewMylP7xHivfgixbfGBT6APAwsSoHRKotnIc=
 github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.5.0 h1:mlmW46Q0B79I+Aj4azKC6xDMFN9a9SyZWESlGWYXbFs=
 github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.5.0/go.mod h1:PXe2h+LKcWTX9afWdZoHyODqR4fBa5boUM/8uJfZ0Jo=
-github.com/ProtonMail/go-crypto v0.0.0-20230717121422-5aa5874ade95 h1:KLq8BE0KwCL+mmXnjLWEAOYO+2l2AE4YMmqG1ZpZHBs=
-github.com/ProtonMail/go-crypto v0.0.0-20230717121422-5aa5874ade95/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mxXfQidrMEnLlPk9UMeRtyBTnEFtxkV0kU=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
+github.com/ProtonMail/go-crypto v1.1.0 h1:OnlSGxXflfrWJESDsGQOmACNQRM9IflG3q8XTrOqvbE=
+github.com/ProtonMail/go-crypto v1.1.0/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
 github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f h1:tCbYj7/299ekTTXpdwKYF8eBlsYsDVoggDAuAjoK66k=
 github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f/go.mod h1:gcr0kNtGBqin9zDW9GOHcVntrwnjrK+qdJ06mWYBybw=
-github.com/ProtonMail/gopenpgp/v2 v2.7.5 h1:STOY3vgES59gNgoOt2w0nyHBjKViB/qSg7NjbQWPJkA=
-github.com/ProtonMail/gopenpgp/v2 v2.7.5/go.mod h1:IhkNEDaxec6NyzSI0PlxapinnwPVIESk8/76da3Ct3g=
+github.com/ProtonMail/gopenpgp/v2 v2.8.0 h1:WvMv3CMcFsqKSM4/Qf8sf3tgyQkzDqQmoSE49bnBuP4=
+github.com/ProtonMail/gopenpgp/v2 v2.8.0/go.mod h1:qb2GUSnmA9ipBW5GVtCtEhkummSlqs2A8Ar3S0HBgSY=
 github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
 github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
 github.com/bramvdbogaerde/go-scp v1.5.0 h1:a9BinAjTfQh273eh7vd3qUgmBC+bx+3TRDtkZWmIpzM=
 github.com/bramvdbogaerde/go-scp v1.5.0/go.mod h1:on2aH5AxaFb2G0N5Vsdy6B0Ml7k9HuHSwfo1y0QzAbQ=
-github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
-github.com/cloudflare/circl v1.3.3 h1:fE/Qz0QdIGqeWfnwq0RE0R7MI51s0M2E4Ga9kq5AEMs=
-github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
-github.com/common-nighthawk/go-figure v0.0.0-20210622060536-734e95fb86be h1:J5BL2kskAlV9ckgEsNQXscjIaLiOYiZ75d4e94E6dcQ=
-github.com/common-nighthawk/go-figure v0.0.0-20210622060536-734e95fb86be/go.mod h1:mk5IQ+Y0ZeO87b858TlA645sVcEcbiX6YqP98kt+7+w=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+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.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=
 github.com/go-mail/mail v2.3.1+incompatible h1:UzNOn0k5lpfVtO31cK3hn6I4VEVGhe3lX8AJBAxXExM=
 github.com/go-mail/mail v2.3.1+incompatible/go.mod h1:VPWjmmNyRsWXQZHVHT3g0YbIINUkSmuKOiLIDkWbL6M=
+github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
+github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
 github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -32,38 +39,45 @@ github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+l
 github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/jkaninda/encryptor v0.0.0-20241013064832-ed4bd6a1b221 h1:AwkCf7el1kzeCJ89A+gUAK0ero5JYnvLOKsYMzq+rs4=
-github.com/jkaninda/encryptor v0.0.0-20241013064832-ed4bd6a1b221/go.mod h1:9F8ZJ+ZXE8DZBo77+aneGj8LMjrYXX6eFUCC/uqZOUo=
-github.com/jkaninda/go-storage v0.1.1 h1:vjpdD/fh39S5HGyfHvLE5HGYOEPIukINlOX3OnM3GW4=
-github.com/jkaninda/go-storage v0.1.1/go.mod h1:7VK5gQISQaLxtLfBtc+een8spcgLVSBAKTRuyF1N81I=
-github.com/jkaninda/go-storage v0.1.2 h1:d7+TRPjmHXdSqO0wne3KAB8zt9ih8lf5D8aL4n7/Dds=
-github.com/jkaninda/go-storage v0.1.2/go.mod h1:zVRnLprBk/9AUz2+za6Y03MgoNYrqKLy3edVtjqMaps=
+github.com/jkaninda/encryptor v0.0.0-20241111100652-926393c9437e h1:jtFKZHt/PLGQWXNgjEFTEwVbxiQQRMoJ7m37trbkJGw=
+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.1.1 h1:PMrtXR9d51YzHo85y9Z6YVL0YyBURbRTPemHVbFDqZg=
+github.com/jkaninda/go-utils v0.1.1/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=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
+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.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
+github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+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.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+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=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
 golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
 golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
@@ -71,9 +85,7 @@ golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
 golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo=
 golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -84,23 +96,17 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
 golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.25.0 h1:WtHI/ltw4NvSUig5KARz9h521QvRC8RmF/cuYqifU24=
 golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
@@ -112,12 +118,12 @@ golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/mail.v2 v2.3.1 h1:WYFn/oANrAGP2C0dcV6/pbkPzv8yGzqTjPmTeO7qoXk=
 gopkg.in/mail.v2 v2.3.1/go.mod h1:htwXN1Qh09vZJ1NVKxQqHPBaCBbzKhp5GzuJEA4VJWw=
 gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -1,4 +1,3 @@
-// Package main /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package main
 
 import "github.com/jkaninda/mysql-bkup/cmd"

migrations/init.sql

@@ -0,0 +1,35 @@
+-- Create the database testdb2 and testdb3
+CREATE DATABASE IF NOT EXISTS testdb2;
+CREATE DATABASE IF NOT EXISTS testdb3;
+CREATE DATABASE IF NOT EXISTS fakedb;
+USE testdb;
+
+-- Create the 'users' table
+CREATE TABLE users (
+                       id INT AUTO_INCREMENT PRIMARY KEY,
+                       name VARCHAR(100) NOT NULL,
+                       email VARCHAR(100) NOT NULL UNIQUE,
+                       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create the 'orders' table
+CREATE TABLE orders (
+                        id INT AUTO_INCREMENT PRIMARY KEY,
+                        user_id INT NOT NULL,
+                        amount DECIMAL(10,2) NOT NULL,
+                        status ENUM('pending', 'completed', 'canceled') NOT NULL DEFAULT 'pending',
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Insert fake users
+INSERT INTO users (name, email) VALUES
+                                    ('Alice Smith', 'alice@example.com'),
+                                    ('Bob Johnson', 'bob@example.com'),
+                                    ('Charlie Brown', 'charlie@example.com');
+
+-- Insert fake orders
+INSERT INTO orders (user_id, amount, status) VALUES
+                                                 (1, 100.50, 'completed'),
+                                                 (2, 200.75, 'pending'),
+                                                 (3, 50.00, 'canceled');

migrations/test_config.yaml

@@ -0,0 +1,13 @@
+#cronExpression: "@every 20s"
+#backupRescueMode: false
+databases:
+  - host: 127.0.0.1
+    port: 3306
+    name: testdb
+    user: user
+    password: password
+  - name: testdb2
+    # database credentials from environment variables
+    #TESTDB2_DB_USERNAME
+    #TESTDB2_DB_PASSWORD
+    #TESTDB2_DB_HOST

pkg/azure.go

@@ -27,6 +27,7 @@ package pkg
 import (
 	"fmt"
 	"github.com/jkaninda/go-storage/pkg/azure"
+	goutils "github.com/jkaninda/go-utils"
 	"github.com/jkaninda/mysql-bkup/utils"
 
 	"os"
@@ -35,11 +36,14 @@ import (
 )
 
 func azureBackup(db *dbConfig, config *BackupConfig) {
-	utils.Info("Backup database to the remote FTP server")
-	startTime = time.Now().Format(utils.TimeFormat())
+	utils.Info("Backup database to Azure Blob Storage")
 
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.allInOne)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -83,21 +87,24 @@ func azureBackup(db *dbConfig, config *BackupConfig) {
 
 	}
 
+	utils.Info("Backup name is %s", finalFileName)
+	utils.Info("Backup size: %s", utils.ConvertBytes(uint64(backupSize)))
 	utils.Info("Uploading backup archive to Azure Blob storage ... done ")
 
+	duration := goutils.FormatDuration(time.Since(startTime), 0)
+
 	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
-		BackupSize:     backupSize,
+		BackupSize:     utils.ConvertBytes(uint64(backupSize)),
 		Database:       db.dbName,
 		Storage:        config.storage,
 		BackupLocation: filepath.Join(config.remotePath, finalFileName),
-		StartTime:      startTime,
-		EndTime:        time.Now().Format(utils.TimeFormat()),
+		Duration:       duration,
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	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

@@ -22,19 +22,23 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package pkg
 
 import (
+	"bytes"
+	"errors"
 	"fmt"
 	"github.com/jkaninda/encryptor"
 	"github.com/jkaninda/go-storage/pkg/local"
+	goutils "github.com/jkaninda/go-utils"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"github.com/robfig/cron/v3"
 	"github.com/spf13/cobra"
-	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"time"
 )
 
@@ -47,7 +51,8 @@ func StartBackup(cmd *cobra.Command) {
 	if err != nil {
 		dbConf = initDbConfig(cmd)
 		if config.cronExpression == "" {
-			BackupTask(dbConf, config)
+			config.allowCustomName = true
+			createBackupTask(dbConf, config)
 		} else {
 			if utils.IsValidCronExpression(config.cronExpression) {
 				scheduledMode(dbConf, config)
@@ -70,14 +75,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() {
-		BackupTask(db, config)
+	_, err = c.AddFunc(config.cronExpression, func() {
+		createBackupTask(db, config)
 		utils.Info("Next backup time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
 
 	})
@@ -99,27 +108,66 @@ func multiBackupTask(databases []Database, bkConfig *BackupConfig) {
 		if db.Path != "" {
 			bkConfig.remotePath = db.Path
 		}
-		BackupTask(getDatabase(db), bkConfig)
+		createBackupTask(getDatabase(db), bkConfig)
 	}
 }
 
-// BackupTask backups database
-func BackupTask(db *dbConfig, config *BackupConfig) {
+// createBackupTask backup task
+func createBackupTask(db *dbConfig, config *BackupConfig) {
+	if config.all && !config.allInOne {
+		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.allInOne {
+		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"))
+	}
+	if config.customName != "" && config.allowCustomName && !config.all {
+		backupFileName = fmt.Sprintf("%s.sql.gz", config.customName)
+		if config.disableCompression {
+			backupFileName = fmt.Sprintf("%s.sql", config.customName)
+		}
 	}
 	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":
+	case "ssh", "remote", "sftp":
 		sshBackup(db, config)
-	case "ftp", "FTP":
+	case "ftp":
 		ftpBackup(db, config)
 	case "azure":
 		azureBackup(db, config)
@@ -127,8 +175,10 @@ func BackupTask(db *dbConfig, config *BackupConfig) {
 		localBackup(db, config)
 	}
 }
+
+// startMultiBackup start multi backup
 func startMultiBackup(bkConfig *BackupConfig, configFile string) {
-	utils.Info("Starting backup task...")
+	utils.Info("Starting Multi backup task...")
 	conf, err := readConf(configFile)
 	if err != nil {
 		utils.Fatal("Error reading config file: %s", err)
@@ -144,6 +194,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")
@@ -154,7 +205,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...")
@@ -184,79 +239,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 != nil {
-		return
+	if err := testDatabaseConnection(db); err != nil {
+		return fmt.Errorf("database connection failed: %w", err)
 	}
-	testDatabaseConnection(db)
-	// Backup Database database
-	utils.Info("Backing up database...")
-
-	// Verify is compression is disabled
-	if disableCompression {
-		// Execute mysqldump
-		cmd := exec.Command("mysqldump",
-			"-h", db.dbHost,
-			"-P", db.dbPort,
-			"-u", db.dbUserName,
-			db.dbName,
-		)
-		output, err := cmd.Output()
-		if err != nil {
-			utils.Fatal(err.Error())
-		}
-
-		// save output
-		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)
-		if err != nil {
-			utils.Fatal(err.Error())
-		}
-		utils.Info("Database has been backed up")
 
+	dumpArgs := []string{fmt.Sprintf("--defaults-file=%s", mysqlClientConfig)}
+	if all && singleFile {
+		dumpArgs = append(dumpArgs, "--all-databases", "--single-transaction", "--routines", "--triggers")
 	} 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)
-		}
-		gzipCmd := exec.Command("gzip")
-		gzipCmd.Stdin = stdout
-		gzipCmd.Stdout, err = os.Create(filepath.Join(tmpPath, backupFileName))
-		err = gzipCmd.Start()
-		if err != nil {
-			return
-		}
-		if err := cmd.Run(); err != nil {
-			log.Fatal(err)
-		}
-		if err := gzipCmd.Wait(); err != nil {
-			log.Fatal(err)
-		}
-		utils.Info("Database has been backed up")
-
+		dumpArgs = append(dumpArgs, db.dbName)
 	}
+
+	backupPath := filepath.Join(tmpPath, backupFileName)
+	if disableCompression {
+		return runCommandAndSaveOutput("mysqldump", dumpArgs, backupPath)
+	}
+	return runCommandWithCompression("mysqldump", dumpArgs, backupPath)
 }
+
+// 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 {
+		return fmt.Errorf("failed to execute %s: %v, output: %s", command, err, string(output))
+	}
+
+	return os.WriteFile(outputPath, output, 0644)
+}
+
+// runCommandWithCompression runs a command and compresses the output
+func runCommandWithCompression(command string, args []string, outputPath string) error {
+	cmd := exec.Command(command, args...)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("failed to create stdout pipe: %w", err)
+	}
+
+	gzipCmd := exec.Command("gzip")
+	gzipCmd.Stdin = stdout
+	gzipFile, err := os.Create(outputPath)
+	if err != nil {
+		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 {
+		return fmt.Errorf("failed to execute %s: %w", command, err)
+	}
+	if err := gzipCmd.Wait(); err != nil {
+		return fmt.Errorf("failed to wait for gzip completion: %w", err)
+	}
+
+	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")
-	startTime = time.Now().Format(utils.TimeFormat())
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.allInOne)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -267,7 +326,6 @@ func localBackup(db *dbConfig, config *BackupConfig) {
 		utils.Error("Error: %s", err)
 	}
 	backupSize = fileInfo.Size()
-	utils.Info("Backup name is %s", finalFileName)
 	localStorage := local.NewStorage(local.Config{
 		LocalPath:  tmpPath,
 		RemotePath: storagePath,
@@ -276,16 +334,19 @@ func localBackup(db *dbConfig, config *BackupConfig) {
 	if err != nil {
 		utils.Fatal("Error copying backup file: %s", err)
 	}
+	utils.Info("Backup name is %s", finalFileName)
+	utils.Info("Backup size: %s", utils.ConvertBytes(uint64(backupSize)))
 	utils.Info("Backup saved in %s", filepath.Join(storagePath, finalFileName))
+	duration := goutils.FormatDuration(time.Since(startTime), 0)
+
 	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
-		BackupSize:     backupSize,
+		BackupSize:     utils.ConvertBytes(uint64(backupSize)),
 		Database:       db.dbName,
 		Storage:        config.storage,
 		BackupLocation: filepath.Join(storagePath, finalFileName),
-		StartTime:      startTime,
-		EndTime:        time.Now().Format(utils.TimeFormat()),
+		Duration:       duration,
 	})
 	// Delete old backup
 	if config.prune {
@@ -297,9 +358,10 @@ func localBackup(db *dbConfig, config *BackupConfig) {
 	}
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	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)
@@ -329,3 +391,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, errors.New(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

@@ -1,4 +1,3 @@
-// Package internal /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package pkg
 
 import (
@@ -30,6 +30,7 @@ import (
 	"github.com/spf13/cobra"
 	"os"
 	"strconv"
+	"strings"
 )
 
 type Database struct {
@@ -41,8 +42,9 @@ type Database struct {
 	Path     string `yaml:"path"`
 }
 type Config struct {
-	Databases      []Database `yaml:"databases"`
-	CronExpression string     `yaml:"cronExpression"`
+	CronExpression   string     `yaml:"cronExpression"`
+	BackupRescueMode bool       `yaml:"backupRescueMode"`
+	Databases        []Database `yaml:"databases"`
 }
 
 type dbConfig struct {
@@ -75,12 +77,16 @@ type BackupConfig struct {
 	publicKey          string
 	storage            string
 	cronExpression     string
+	all                bool
+	allInOne           bool
+	customName         string
+	allowCustomName    bool
 }
 type FTPConfig struct {
 	host       string
 	user       string
 	password   string
-	port       string
+	port       int
 	remotePath string
 }
 type AzureConfig struct {
@@ -94,7 +100,7 @@ type SSHConfig struct {
 	user         string
 	password     string
 	hostName     string
-	port         string
+	port         int
 	identifyFile string
 }
 type AWSConfig struct {
@@ -113,7 +119,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")
@@ -127,6 +133,11 @@ func initDbConfig(cmd *cobra.Command) *dbConfig {
 }
 
 func getDatabase(database Database) *dbConfig {
+	// Set default values from environment variables if not provided
+	database.User = getEnvOrDefault(database.User, "DB_USERNAME", database.Name, "")
+	database.Password = getEnvOrDefault(database.Password, "DB_PASSWORD", database.Name, "")
+	database.Host = getEnvOrDefault(database.Host, "DB_HOST", database.Name, "")
+	database.Port = getEnvOrDefault(database.Port, "DB_PORT", database.Name, "3306")
 	return &dbConfig{
 		dbHost:     database.Host,
 		dbPort:     database.Port,
@@ -136,6 +147,31 @@ 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 != "" {
+		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)
+}
+
 // loadSSHConfig loads the SSH configuration from environment variables
 func loadSSHConfig() (*SSHConfig, error) {
 	utils.GetEnvVariable("SSH_HOST", "SSH_HOST_NAME")
@@ -149,7 +185,7 @@ func loadSSHConfig() (*SSHConfig, error) {
 		user:         os.Getenv("SSH_USER"),
 		password:     os.Getenv("SSH_PASSWORD"),
 		hostName:     os.Getenv("SSH_HOST"),
-		port:         os.Getenv("SSH_PORT"),
+		port:         utils.GetIntEnv("SSH_PORT"),
 		identifyFile: os.Getenv("SSH_IDENTIFY_FILE"),
 	}, nil
 }
@@ -159,7 +195,7 @@ func loadFtpConfig() *FTPConfig {
 	fConfig.host = utils.GetEnvVariable("FTP_HOST", "FTP_HOST_NAME")
 	fConfig.user = os.Getenv("FTP_USER")
 	fConfig.password = os.Getenv("FTP_PASSWORD")
-	fConfig.port = os.Getenv("FTP_PORT")
+	fConfig.port = utils.GetIntEnv("FTP_PORT")
 	fConfig.remotePath = os.Getenv("REMOTE_PATH")
 	err := utils.CheckEnvVars(ftpVars)
 	if err != nil {
@@ -214,15 +250,24 @@ 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")
+	utils.GetEnv(cmd, "config", "BACKUP_CONFIG_FILE")
+	utils.GetEnv(cmd, "dbname", "DB_NAME")
 	// Get flag value and set env
 	remotePath := utils.GetEnvVariable("REMOTE_PATH", "SSH_REMOTE_PATH")
 	storage = utils.GetEnv(cmd, "storage", "STORAGE")
 	prune := false
+	configFile := os.Getenv("BACKUP_CONFIG_FILE")
 	backupRetention := utils.GetIntEnv("BACKUP_RETENTION_DAYS")
 	if backupRetention > 0 {
 		prune = true
 	}
 	disableCompression, _ = cmd.Flags().GetBool("disable-compression")
+	customName, _ := cmd.Flags().GetString("custom-name")
+	all, _ := cmd.Flags().GetBool("all-databases")
+	allInOne, _ := cmd.Flags().GetBool("all-in-one")
+	if allInOne {
+		all = true
+	}
 	_, _ = cmd.Flags().GetString("mode")
 	passphrase := os.Getenv("GPG_PASSPHRASE")
 	_ = utils.GetEnv(cmd, "path", "AWS_S3_PATH")
@@ -236,6 +281,10 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
 		encryption = true
 		usingKey = false
 	}
+	dbName := os.Getenv("DB_NAME")
+	if dbName == "" && !all && configFile == "" {
+		utils.Fatal("Database name is required, use DB_NAME environment variable or -d flag")
+	}
 	// Initialize backup configs
 	config := BackupConfig{}
 	config.backupRetention = backupRetention
@@ -248,6 +297,9 @@ func initBackupConfig(cmd *cobra.Command) *BackupConfig {
 	config.publicKey = publicKeyFile
 	config.usingKey = usingKey
 	config.cronExpression = cronExpression
+	config.all = all
+	config.allInOne = allInOne
+	config.customName = customName
 	return &config
 }
 

pkg/helper.go

@@ -1,4 +1,3 @@
-// Package internal /
 /*
 MIT License
 
@@ -22,11 +21,14 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package pkg
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
+	goutils "github.com/jkaninda/go-utils"
 	"github.com/jkaninda/mysql-bkup/utils"
 	"gopkg.in/yaml.v3"
 	"os"
@@ -36,7 +38,7 @@ import (
 )
 
 func intro() {
-	fmt.Println("Starting MySQL Backup...")
+	fmt.Println("Starting MYSQL-BKUP...")
 	fmt.Printf("Version: %s\n", utils.Version)
 	fmt.Println("Copyright (c) 2024 Jonas Kaninda")
 }
@@ -65,25 +67,30 @@ func deleteTemp() {
 	}
 }
 
-// TestDatabaseConnection  tests the database connection
-func testDatabaseConnection(db *dbConfig) {
-	err := os.Setenv("MYSQL_PWD", db.dbPassword)
-	if err != nil {
-		return
+// TestDatabaseConnection tests the database connection
+func testDatabaseConnection(db *dbConfig) error {
+	// Create the mysql client config file
+	if err := createMysqlClientConfigFile(*db); err != nil {
+		return errors.New(err.Error())
 	}
 	utils.Info("Connecting to %s database ...", db.dbName)
-	cmd := exec.Command("mysql", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, db.dbName, "-e", "quit")
+	// Set database name for notification error
+	utils.DatabaseName = db.dbName
+
+	// Prepare the command to test the database connection
+	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
@@ -153,6 +160,8 @@ func readConf(configFile string) (*Config, error) {
 
 // checkConfigFile checks config files and returns one config file
 func checkConfigFile(filePath string) (string, error) {
+	// Remove the quotes
+	filePath = strings.Trim(filePath, `"`)
 	// Define possible config file names
 	configFiles := []string{filepath.Join(workingDir, "config.yaml"), filepath.Join(workingDir, "config.yml"), filePath}
 
@@ -179,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

@@ -1,4 +1,3 @@
-// Package internal /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package pkg
 
 import (
@@ -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

@@ -28,6 +28,7 @@ import (
 	"fmt"
 	"github.com/jkaninda/go-storage/pkg/ftp"
 	"github.com/jkaninda/go-storage/pkg/ssh"
+	goutils "github.com/jkaninda/go-utils"
 	"github.com/jkaninda/mysql-bkup/utils"
 
 	"os"
@@ -37,28 +38,31 @@ import (
 
 func sshBackup(db *dbConfig, config *BackupConfig) {
 	utils.Info("Backup database to Remote server")
-	startTime = time.Now().Format(utils.TimeFormat())
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.allInOne)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	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)
 	sshConfig, err := loadSSHConfig()
 	if err != nil {
 		utils.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: config.remotePath,
-		LocalPath:  tmpPath,
+		Host:         sshConfig.hostName,
+		Port:         sshConfig.port,
+		User:         sshConfig.user,
+		Password:     sshConfig.password,
+		IdentifyFile: sshConfig.identifyFile,
+		RemotePath:   config.remotePath,
+		LocalPath:    tmpPath,
 	})
 	if err != nil {
 		utils.Fatal("Error creating SSH storage: %s", err)
@@ -73,6 +77,8 @@ func sshBackup(db *dbConfig, config *BackupConfig) {
 		utils.Error("Error: %s", err)
 	}
 	backupSize = fileInfo.Size()
+	utils.Info("Backup name is %s", finalFileName)
+	utils.Info("Backup size: %s", utils.ConvertBytes(uint64(backupSize)))
 	utils.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
 
 	// Delete backup file from tmp folder
@@ -89,86 +95,21 @@ func sshBackup(db *dbConfig, config *BackupConfig) {
 
 	}
 	utils.Info("Uploading backup archive to remote storage ... done ")
-	// Send notification
-	utils.NotifySuccess(&utils.NotificationData{
-		File:           finalFileName,
-		BackupSize:     backupSize,
-		Database:       db.dbName,
-		Storage:        config.storage,
-		BackupLocation: filepath.Join(config.remotePath, finalFileName),
-		StartTime:      startTime,
-		EndTime:        time.Now().Format(utils.TimeFormat()),
-	})
-	// Delete temp
-	deleteTemp()
-	utils.Info("Backup completed successfully")
-
-}
-func ftpBackup(db *dbConfig, config *BackupConfig) {
-	utils.Info("Backup database to the remote FTP server")
-	startTime = time.Now().Format(utils.TimeFormat())
-
-	// 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)
-	ftpConfig := loadFtpConfig()
-	ftpStorage, err := ftp.NewStorage(ftp.Config{
-		Host:       ftpConfig.host,
-		Port:       ftpConfig.port,
-		User:       ftpConfig.user,
-		Password:   ftpConfig.password,
-		RemotePath: config.remotePath,
-		LocalPath:  tmpPath,
-	})
-	if err != nil {
-		utils.Fatal("Error creating SSH storage: %s", err)
-	}
-	err = ftpStorage.Copy(finalFileName)
-	if err != nil {
-		utils.Fatal("Error copying backup file: %s", err)
-	}
-	utils.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)
-	}
-	backupSize = fileInfo.Size()
-	// Delete backup file from tmp folder
-	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
-	if err != nil {
-		utils.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)
-		}
-
-	}
-
-	utils.Info("Uploading backup archive to the remote FTP server ... done ")
+	duration := goutils.FormatDuration(time.Since(startTime), 0)
 
 	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
-		BackupSize:     backupSize,
+		BackupSize:     utils.ConvertBytes(uint64(backupSize)),
 		Database:       db.dbName,
 		Storage:        config.storage,
 		BackupLocation: filepath.Join(config.remotePath, finalFileName),
-		StartTime:      startTime,
-		EndTime:        time.Now().Format(utils.TimeFormat()),
+		Duration:       duration,
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
+
 }
 func remoteRestore(db *dbConfig, conf *RestoreConfig) {
 	utils.Info("Restore database from remote server")
@@ -215,3 +156,73 @@ func ftpRestore(db *dbConfig, conf *RestoreConfig) {
 	}
 	RestoreDatabase(db, conf)
 }
+func ftpBackup(db *dbConfig, config *BackupConfig) {
+	utils.Info("Backup database to the remote FTP server")
+
+	// Backup database
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.allInOne)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
+	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)
+	ftpConfig := loadFtpConfig()
+	ftpStorage, err := ftp.NewStorage(ftp.Config{
+		Host:       ftpConfig.host,
+		Port:       ftpConfig.port,
+		User:       ftpConfig.user,
+		Password:   ftpConfig.password,
+		RemotePath: config.remotePath,
+		LocalPath:  tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating SSH storage: %s", err)
+	}
+	err = ftpStorage.Copy(finalFileName)
+	if err != nil {
+		utils.Fatal("Error copying backup file: %s", err)
+	}
+	utils.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)
+	}
+	backupSize = fileInfo.Size()
+	// Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
+	if err != nil {
+		utils.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)
+		}
+
+	}
+	utils.Info("Backup name is %s", finalFileName)
+	utils.Info("Backup size: %s", utils.ConvertBytes(uint64(backupSize)))
+	utils.Info("Uploading backup archive to the remote FTP server ... done ")
+	duration := goutils.FormatDuration(time.Since(startTime), 0)
+
+	// Send notification
+	utils.NotifySuccess(&utils.NotificationData{
+		File:           finalFileName,
+		BackupSize:     utils.ConvertBytes(uint64(backupSize)),
+		Database:       db.dbName,
+		Storage:        config.storage,
+		BackupLocation: filepath.Join(config.remotePath, finalFileName),
+		Duration:       duration,
+	})
+	// Delete temp
+	deleteTemp()
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
+}

pkg/restore.go

@@ -1,6 +1,3 @@
-// Package internal /
-package pkg
-
 /*
 MIT License
 
@@ -24,7 +21,11 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
+package pkg
+
 import (
+	"fmt"
 	"github.com/jkaninda/encryptor"
 	"github.com/jkaninda/go-storage/pkg/local"
 	"github.com/jkaninda/mysql-bkup/utils"
@@ -56,11 +57,17 @@ func StartRestore(cmd *cobra.Command) {
 }
 func localRestore(dbConf *dbConfig, restoreConf *RestoreConfig) {
 	utils.Info("Restore database from local")
+	basePath := filepath.Dir(restoreConf.file)
+	fileName := filepath.Base(restoreConf.file)
+	restoreConf.file = fileName
+	if basePath == "" || basePath == "." {
+		basePath = storagePath
+	}
 	localStorage := local.NewStorage(local.Config{
-		RemotePath: storagePath,
+		RemotePath: basePath,
 		LocalPath:  tmpPath,
 	})
-	err := localStorage.CopyFrom(restoreConf.file)
+	err := localStorage.CopyFrom(fileName)
 	if err != nil {
 		utils.Fatal("Error copying backup file: %s", err)
 	}
@@ -68,88 +75,79 @@ func localRestore(dbConf *dbConfig, restoreConf *RestoreConfig) {
 
 }
 
-// RestoreDatabase restore database
+// RestoreDatabase restores the database from a backup file
 func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
 	if conf.file == "" {
 		utils.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))
+
+	filePath := filepath.Join(tmpPath, conf.file)
+	rFile, err := os.ReadFile(filePath)
 	if err != nil {
-		utils.Fatal("Error reading backup file: %s ", err)
+		utils.Fatal("Error reading backup file: %v", err)
 	}
 
+	extension := filepath.Ext(filePath)
+	outputFile := RemoveLastExtension(filePath)
+
 	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")
-			prKey, err := os.ReadFile(conf.privateKey)
-			if err != nil {
-				utils.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)
-			}
-			utils.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.")
-			} else {
-				utils.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)
-				}
-				utils.Info("Decrypting backup using passphrase...done")
-				// Update file name
-				conf.file = RemoveLastExtension(file)
-			}
-		}
-
+		decryptBackup(conf, rFile, outputFile)
 	}
 
-	if utils.FileExists(filepath.Join(tmpPath, conf.file)) {
-		err := os.Setenv("MYSQL_PWD", db.dbPassword)
+	restorationFile := filepath.Join(tmpPath, conf.file)
+	if !utils.FileExists(restorationFile) {
+		utils.Fatal("File not found: %s", restorationFile)
+	}
+
+	if err := testDatabaseConnection(db); err != nil {
+		utils.Fatal("Error connecting to the database: %v", err)
+	}
+
+	utils.Info("Restoring database...")
+	restoreDatabaseFile(db, restorationFile)
+}
+
+func decryptBackup(conf *RestoreConfig, rFile []byte, outputFile string) {
+	if conf.usingKey {
+		utils.Info("Decrypting backup using private key...")
+		prKey, err := os.ReadFile(conf.privateKey)
 		if err != nil {
-			return
+			utils.Fatal("Error reading private key: %v", err)
 		}
-		testDatabaseConnection(db)
-		utils.Info("Restoring database...")
-
-		extension := filepath.Ext(filepath.Join(tmpPath, conf.file))
-		// Restore from compressed file / .sql.gz
-		if extension == ".gz" {
-			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)
-			}
-			utils.Info("Restoring database... done")
-			utils.Info("Database has been restored")
-			// Delete temp
-			deleteTemp()
-
-		} else if extension == ".sql" {
-			// 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)
-			}
-			utils.Info("Restoring database... done")
-			utils.Info("Database has been restored")
-			// Delete temp
-			deleteTemp()
-		} else {
-			utils.Fatal("Unknown file extension %s", extension)
+		if err := encryptor.DecryptWithPrivateKey(rFile, outputFile, prKey, conf.passphrase); err != nil {
+			utils.Fatal("Error decrypting backup: %v", err)
 		}
-
 	} else {
-		utils.Fatal("File not found in %s", filepath.Join(tmpPath, conf.file))
+		if conf.passphrase == "" {
+			utils.Fatal("Passphrase or private key required for GPG file.")
+		}
+		utils.Info("Decrypting backup using passphrase...")
+		if err := encryptor.Decrypt(rFile, outputFile, conf.passphrase); err != nil {
+			utils.Fatal("Error decrypting file: %v", err)
+		}
+		conf.file = RemoveLastExtension(conf.file)
 	}
 }
+
+func restoreDatabaseFile(db *dbConfig, restorationFile string) {
+	extension := filepath.Ext(restorationFile)
+	var cmdStr string
+
+	switch extension {
+	case ".gz":
+		cmdStr = fmt.Sprintf("zcat %s | mariadb --defaults-file=%s %s", restorationFile, mysqlClientConfig, db.dbName)
+	case ".sql":
+		cmdStr = fmt.Sprintf("cat %s | mariadb --defaults-file=%s %s", restorationFile, mysqlClientConfig, db.dbName)
+	default:
+		utils.Fatal("Unknown file extension: %s", extension)
+	}
+
+	cmd := exec.Command("sh", "-c", cmdStr)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		utils.Fatal("Error restoring database: %v\nOutput: %s", err, string(output))
+	}
+
+	utils.Info("Database has been restored successfully.")
+	deleteTemp()
+}

pkg/s3.go

@@ -27,6 +27,7 @@ package pkg
 import (
 	"fmt"
 	"github.com/jkaninda/go-storage/pkg/s3"
+	goutils "github.com/jkaninda/go-utils"
 	"github.com/jkaninda/mysql-bkup/utils"
 
 	"os"
@@ -37,9 +38,12 @@ import (
 func s3Backup(db *dbConfig, config *BackupConfig) {
 
 	utils.Info("Backup database to s3 storage")
-	startTime = time.Now().Format(utils.TimeFormat())
 	// Backup database
-	BackupDatabase(db, config.backupFileName, disableCompression)
+	err := BackupDatabase(db, config.backupFileName, disableCompression, config.all, config.allInOne)
+	if err != nil {
+		recoverMode(err, "Error backing up database")
+		return
+	}
 	finalFileName := config.backupFileName
 	if config.encryption {
 		encryptBackup(config)
@@ -59,7 +63,7 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 		Region:         awsConfig.region,
 		DisableSsl:     awsConfig.disableSsl,
 		ForcePathStyle: awsConfig.forcePathStyle,
-		RemotePath:     awsConfig.remotePath,
+		RemotePath:     config.remotePath,
 		LocalPath:      tmpPath,
 	})
 	if err != nil {
@@ -91,19 +95,19 @@ func s3Backup(db *dbConfig, config *BackupConfig) {
 	}
 	utils.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
 	utils.Info("Uploading backup archive to remote storage S3 ... done ")
+	duration := goutils.FormatDuration(time.Since(startTime), 0)
 	// Send notification
 	utils.NotifySuccess(&utils.NotificationData{
 		File:           finalFileName,
-		BackupSize:     backupSize,
+		BackupSize:     utils.ConvertBytes(uint64(backupSize)),
 		Database:       db.dbName,
 		Storage:        config.storage,
 		BackupLocation: filepath.Join(config.remotePath, finalFileName),
-		StartTime:      startTime,
-		EndTime:        time.Now().Format(utils.TimeFormat()),
+		Duration:       duration,
 	})
 	// Delete temp
 	deleteTemp()
-	utils.Info("Backup completed successfully")
+	utils.Info("The backup of the %s database has been completed in %s", db.dbName, duration)
 
 }
 func s3Restore(db *dbConfig, conf *RestoreConfig) {
@@ -120,7 +124,7 @@ func s3Restore(db *dbConfig, conf *RestoreConfig) {
 		Region:         awsConfig.region,
 		DisableSsl:     awsConfig.disableSsl,
 		ForcePathStyle: awsConfig.forcePathStyle,
-		RemotePath:     awsConfig.remotePath,
+		RemotePath:     conf.remotePath,
 		LocalPath:      tmpPath,
 	})
 	if err != nil {

pkg/var.go

@@ -1,4 +1,3 @@
-// Package internal /
 /*
 MIT License
 
@@ -22,8 +21,14 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package pkg
 
+import (
+	"path/filepath"
+	"time"
+)
+
 const tmpPath = "/tmp/backup"
 const gpgHome = "/config/gnupg"
 const gpgExtension = "gpg"
@@ -39,20 +44,19 @@ var (
 	encryption               = false
 	usingKey                 = false
 	backupSize         int64 = 0
-	startTime          string
+	startTime                = time.Now()
+	backupRescueMode         = false
+	mysqlClientConfig        = filepath.Join(tmpPath, "my.cnf")
 )
 
 // dbHVars Required environment variables for database
 var dbHVars = []string{
 	"DB_HOST",
-	"DB_PORT",
 	"DB_PASSWORD",
 	"DB_USERNAME",
-	"DB_NAME",
 }
 var tdbRVars = []string{
 	"TARGET_DB_HOST",
-	"TARGET_DB_PORT",
 	"TARGET_DB_NAME",
 	"TARGET_DB_USERNAME",
 	"TARGET_DB_PASSWORD",
@@ -61,13 +65,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

@@ -1,18 +1,69 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
     <meta charset="UTF-8">
-    <title>🔴 Urgent: Database Backup Failure Notification</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🔴 Urgent: Database Backup Failure</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #f8f9fa;
+            color: #333;
+            margin: 0;
+            padding: 20px;
+        }
+        h2 {
+            color: #d9534f;
+        }
+        .details {
+            background-color: #ffffff;
+            border: 1px solid #ddd;
+            padding: 15px;
+            border-radius: 5px;
+            margin-top: 10px;
+        }
+        .details ul {
+            list-style-type: none;
+            padding: 0;
+        }
+        .details li {
+            margin: 5px 0;
+        }
+        a {
+            color: #0275d8;
+            text-decoration: none;
+        }
+        a:hover {
+            text-decoration: underline;
+        }
+        footer {
+            margin-top: 20px;
+            font-size: 0.9em;
+            color: #6c757d;
+        }
+    </style>
 </head>
 <body>
-<h2>Hi,</h2>
-<p>An error occurred during database backup.</p>
-<h3>Failure Details:</h3>
-<ul>
-<li>Error Message: {{.Error}}</li>
-<li>Date: {{.EndTime}}</li>
-<li>Backup Reference: {{.BackupReference}} </li>
-</ul>
-<p>©2024 <a href="https://github.com/jkaninda/mysql-bkup">mysql-bkup</a></p>
+    <h2>🔴 Urgent: Database Backup Failure Notification</h2>
+    <p>Hi,</p>
+    <p>An error occurred during the database backup process. Please review the details below and take the necessary actions:</p>
+
+    <div class="details">
+        <h3>Failure Details:</h3>
+        <ul>
+            <li><strong>Database Name:</strong> {{.DatabaseName}}</li>
+            <li><strong>Date:</strong> {{.EndTime}}</li>
+            <li><strong>Backup Reference:</strong> {{.BackupReference}}</li>
+            <li><strong>Error Message:</strong> {{.Error}}</li>
+        </ul>
+    </div>
+
+    <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/mysql-bkup">mysql-bkup documentation</a>.</p>
+
+    <footer>
+        &copy; 2024 <a href="https://github.com/jkaninda/mysql-bkup">mysql-bkup</a> | Automated Backup System
+    </footer>
 </body>
-</html>
+</html>

templates/email.tmpl

@@ -1,24 +1,69 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
     <meta charset="UTF-8">
-    <title>✅  Database Backup Notification – {{.Database}}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>✅ Database Backup Successful – {{.Database}}</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #f8f9fa;
+            color: #333;
+            margin: 0;
+            padding: 20px;
+        }
+        h2 {
+            color: #5cb85c;
+        }
+        .details {
+            background-color: #ffffff;
+            border: 1px solid #ddd;
+            padding: 15px;
+            border-radius: 5px;
+            margin-top: 10px;
+        }
+        .details ul {
+            list-style-type: none;
+            padding: 0;
+        }
+        .details li {
+            margin: 5px 0;
+        }
+        a {
+            color: #0275d8;
+            text-decoration: none;
+        }
+        a:hover {
+            text-decoration: underline;
+        }
+        footer {
+            margin-top: 20px;
+            font-size: 0.9em;
+            color: #6c757d;
+        }
+    </style>
 </head>
 <body>
-<h2>Hi,</h2>
-<p>Backup of the {{.Database}} database has been successfully completed on {{.EndTime}}.</p>
-<h3>Backup Details:</h3>
-<ul>
-<li>Database Name: {{.Database}}</li>
-<li>Backup Start Time: {{.StartTime}}</li>
-<li>Backup End Time: {{.EndTime}}</li>
-<li>Backup Storage: {{.Storage}}</li>
-<li>Backup Location: {{.BackupLocation}}</li>
-<li>Backup Size: {{.BackupSize}} bytes</li>
-<li>Backup Reference: {{.BackupReference}} </li>
-</ul>
-<p>Best regards,</p>
-<p>©2024 <a href="https://github.com/jkaninda/mysql-bkup">mysql-bkup</a></p>
-<href>
+    <h2>✅ Database Backup Successful</h2>
+    <p>Hi,</p>
+    <p>The backup process for the <strong>{{.Database}}</strong> database was successfully completed. Please find the details below:</p>
+
+    <div class="details">
+        <h3>Backup Details:</h3>
+        <ul>
+            <li><strong>Database Name:</strong> {{.Database}}</li>
+            <li><strong>Backup Duration:</strong> {{.Duration}}</li>
+            <li><strong>Backup Storage:</strong> {{.Storage}}</li>
+            <li><strong>Backup Location:</strong> {{.BackupLocation}}</li>
+            <li><strong>Backup Size:</strong> {{.BackupSize}}</li>
+            <li><strong>Backup Reference:</strong> {{.BackupReference}}</li>
+        </ul>
+    </div>
+
+    <p>You can access the backup at the specified location if needed. Thank you for using <a href="https://jkaninda.github.io/mysql-bkup/">mysql-bkup</a>.</p>
+
+    <footer>
+        &copy; 2024 <a href="https://github.com/jkaninda/mysql-bkup">mysql-bkup</a> | Automated Backup System
+    </footer>
 </body>
-</html>
+</html>

templates/telegram-error.tmpl

@@ -1,8 +1,11 @@
 🔴 Urgent: Database Backup Failure Notification
+
 Hi,
-An error occurred during database backup.
+An error occurred during the database backup process.
+Please review the details below and take the necessary actions:
 Failure Details:
+- Database Name: {{.DatabaseName}}
 - Date: {{.EndTime}}
 - Backup Reference: {{.BackupReference}}
 - Error Message: {{.Error}}
-
+We recommend investigating the issue as soon as possible to prevent potential data loss or service disruptions.

templates/telegram.tmpl

@@ -1,12 +1,15 @@
-[✅  Database Backup Notification – {{.Database}}
+✅ Database Backup Successful
+
 Hi,
-Backup of the {{.Database}} database has been successfully completed on {{.EndTime}}.
+The backup process for the {{.Database}} database was successfully completed.
+Please find the details below:
 
 Backup Details:
 - Database Name: {{.Database}}
-- Backup Start Time: {{.StartTime}}
-- Backup EndTime: {{.EndTime}}
+- Backup Duration: {{.Duration}}
 - Backup Storage: {{.Storage}}
 - Backup Location: {{.BackupLocation}}
-- Backup Size: {{.BackupSize}} bytes
+- Backup Size: {{.BackupSize}}
 - Backup Reference: {{.BackupReference}}
+
+You can access the backup at the specified location if needed.

utils/config.go

@@ -1,5 +1,3 @@
-package utils
-
 /*
 MIT License
 
@@ -23,6 +21,9 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
+package utils
+
 import "os"
 
 type MailConfig struct {
@@ -36,10 +37,9 @@ type MailConfig struct {
 }
 type NotificationData struct {
 	File            string
-	BackupSize      int64
+	BackupSize      string
 	Database        string
-	StartTime       string
-	EndTime         string
+	Duration        string
 	Storage         string
 	BackupLocation  string
 	BackupReference string
@@ -49,6 +49,7 @@ type ErrorMessage struct {
 	EndTime         string
 	Error           string
 	BackupReference string
+	DatabaseName    string
 }
 
 // loadMailConfig gets mail environment variables and returns MailConfig
@@ -80,3 +81,15 @@ func backupReference() string {
 }
 
 const templatePath = "/config/templates"
+
+var DatabaseName = ""
+var vars = []string{
+	"TG_TOKEN",
+	"TG_CHAT_ID",
+}
+var mailVars = []string{
+	"MAIL_HOST",
+	"MAIL_PORT",
+	"MAIL_FROM",
+	"MAIL_TO",
+}

utils/constant.go

@@ -1,4 +1,3 @@
-// Package utils /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package utils
 
 const RestoreExample = "restore --dbname database --file db_20231219_022941.sql.gz\n" +

utils/logger.go

@@ -1,13 +1,3 @@
-package utils
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"runtime"
-	"strings"
-)
-
 /*
 MIT License
 
@@ -32,6 +22,16 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
+package utils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+	"strings"
+)
+
 // Info returns info log
 func Info(msg string, args ...interface{}) {
 	log.SetOutput(getStd("/dev/stdout"))

utils/notification.go

@@ -1,5 +1,3 @@
-package utils
-
 /*
 MIT License
 
@@ -24,6 +22,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
+package utils
+
 import (
 	"bytes"
 	"crypto/tls"
@@ -107,19 +107,6 @@ func sendMessage(msg string) error {
 }
 func NotifySuccess(notificationData *NotificationData) {
 	notificationData.BackupReference = backupReference()
-	var vars = []string{
-		"TG_TOKEN",
-		"TG_CHAT_ID",
-	}
-	var mailVars = []string{
-		"MAIL_HOST",
-		"MAIL_PORT",
-		"MAIL_USERNAME",
-		"MAIL_PASSWORD",
-		"MAIL_FROM",
-		"MAIL_TO",
-	}
-
 	// Email notification
 	err := CheckEnvVars(mailVars)
 	if err == nil {
@@ -147,18 +134,6 @@ func NotifySuccess(notificationData *NotificationData) {
 	}
 }
 func NotifyError(error string) {
-	var vars = []string{
-		"TG_TOKEN",
-		"TG_CHAT_ID",
-	}
-	var mailVars = []string{
-		"MAIL_HOST",
-		"MAIL_PORT",
-		"MAIL_USERNAME",
-		"MAIL_PASSWORD",
-		"MAIL_FROM",
-		"MAIL_TO",
-	}
 
 	// Email notification
 	err := CheckEnvVars(mailVars)
@@ -167,6 +142,7 @@ func NotifyError(error string) {
 			Error:           error,
 			EndTime:         time.Now().Format(TimeFormat()),
 			BackupReference: os.Getenv("BACKUP_REFERENCE"),
+			DatabaseName:    DatabaseName,
 		}, "email-error.tmpl")
 		if err != nil {
 			Error("Could not parse error template: %v", err)
@@ -183,6 +159,7 @@ func NotifyError(error string) {
 			Error:           error,
 			EndTime:         time.Now().Format(TimeFormat()),
 			BackupReference: os.Getenv("BACKUP_REFERENCE"),
+			DatabaseName:    DatabaseName,
 		}, "telegram-error.tmpl")
 		if err != nil {
 			Error("Could not parse error template: %v", err)

utils/utils.go

@@ -1,4 +1,3 @@
-// Package utils /
 /*
 MIT License
 
@@ -22,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
+
 package utils
 
 import (
@@ -254,3 +254,19 @@ func CronNextTime(cronExpr string) time.Time {
 	next := schedule.Next(now)
 	return next
 }
+
+// ConvertBytes converts bytes to a human-readable string with the appropriate unit (bytes, MiB, or GiB).
+func ConvertBytes(bytes uint64) string {
+	const (
+		MiB = 1024 * 1024
+		GiB = MiB * 1024
+	)
+	switch {
+	case bytes >= GiB:
+		return fmt.Sprintf("%.2f GiB", float64(bytes)/float64(GiB))
+	case bytes >= MiB:
+		return fmt.Sprintf("%.2f MiB", float64(bytes)/float64(MiB))
+	default:
+		return fmt.Sprintf("%d bytes", bytes)
+	}
+}