Add why use MySQL-BKUP

chore(deps): bump golang from 1.24.1 to 1.24.2

.env.example

@@ -0,0 +1,81 @@
+### Database
+DB_HOST=
+DB_PORT=3306
+DB_USERNAME=
+DB_PASSWORD=
+DB_NAME=
+TZ=Europe/Paris
+
+### Database Migration
+#TARGET_DB_HOST=
+#TARGET_DB_PORT=3306
+#TARGET_DB_NAME=
+#TARGET_DB_USERNAME=
+#TARGET_DB_PASSWORD=
+
+### Backup restoration
+#FILE_NAME=
+
+### AWS  S3 Storage
+#ACCESS_KEY=
+#SECRET_KEY=
+#AWS_S3_BUCKET_NAME=
+#AWS_S3_ENDPOINT=
+#AWS_REGION=
+#AWS_S3_PATH=
+#AWS_DISABLE_SSL=false
+#AWS_FORCE_PATH_STYLE=true
+
+### Backup Cron Expression
+#BACKUP_CRON_EXPRESSION=@midnight
+##Delete old backup created more than specified days ago
+#BACKUP_RETENTION_DAYS=7
+
+####SSH Storage
+#SSH_HOST_NAME=
+#SSH_PORT=22
+#SSH_USER=
+#SSH_PASSWORD=
+#SSH_IDENTIFY_FILE=/tmp/id_ed25519
+
+####FTP Storage
+#FTP_PASSWORD=
+#FTP_HOST_NAME=
+#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=
+#MAIL_USERNAME=
+#MAIL_PASSWORD=
+#MAIL_FROM=Backup Jobs <backup-jobs@example.com>
+#MAIL_TO=backup@example.com,me@example.com,team@example.com
+#MAIL_SKIP_TLS=false
+
+
+

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+ko_fi: jkaninda

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: docker
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: weekly

.github/workflows/build.yml

@@ -1,14 +1,7 @@
 name: Build
 on:
   push:
-    branches: [ "main" ]
-  workflow_dispatch:
-      inputs:
-        docker_tag:
-          description: 'Docker tag'
-          required: true
-          default: 'latest' 
-          type: string
+    branches: ['nightly']
 env:
   BUILDKIT_IMAGE: jkaninda/mysql-bkup
 jobs:
@@ -32,8 +25,10 @@ jobs:
         uses: docker/build-push-action@v3
         with:
           push: true
-          file: "./docker/Dockerfile"
-          platforms: linux/amd64,linux/arm64
+          file: "./Dockerfile"
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          build-args: |
+            appVersion=nightly
           tags: |
-           "${{env.BUILDKIT_IMAGE}}:v0.4"
-           "${{env.BUILDKIT_IMAGE}}:latest"
+            "${{vars.BUILDKIT_IMAGE}}:nightly"
+

.github/workflows/deploy-docs.yml

@@ -0,0 +1,55 @@
+name: Deploy Documenation site to GitHub Pages
+
+on:
+  push:
+    branches: ['main']
+    paths:
+      - 'docs/**'
+      - '.github/workflows/deploy-docs.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: 'pages'
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+          bundler-cache: true
+          cache-version: 0
+          working-directory: docs
+      - name: Setup Pages
+        id: pages
+        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@v3
+        with:
+          path: 'docs/_site/'
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        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/release.yml

@@ -0,0 +1,51 @@
+name: CI
+on:
+  push:
+    tags:
+      - v**
+env:
+  BUILDKIT_IMAGE: jkaninda/mysql-bkup
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      -
+        name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Log in to GHCR
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Get the tag name
+        id: get_tag_name
+        run: echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+      -
+        name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          push: true
+          file: "./Dockerfile"
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          build-args: |
+            appVersion=${{ env.TAG_NAME }}
+          tags: |
+            "${{vars.BUILDKIT_IMAGE}}:${{ env.TAG_NAME }}"
+            "${{vars.BUILDKIT_IMAGE}}:latest"
+            "ghcr.io/${{vars.BUILDKIT_IMAGE}}:${{ env.TAG_NAME }}"
+            "ghcr.io/${{vars.BUILDKIT_IMAGE}}:latest"
+

.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

.gitignore

@@ -8,3 +8,5 @@ test.md
 mysql-bkup
 /.DS_Store
 /.idea
+bin
+Makefile

.golangci.yml

@@ -0,0 +1,44 @@
+run:
+  timeout: 5m
+  allow-parallel-runners: true
+
+issues:
+  # don't skip warning about doc comments
+  # don't exclude the default set of lint
+  exclude-use-default: false
+  # restore some of the defaults
+  # (fill in the rest as needed)
+  exclude-rules:
+    - path: "internal/*"
+      linters:
+        - dupl
+        - lll
+        - goimports
+linters:
+  disable-all: true
+  enable:
+    - dupl
+    - errcheck
+    - copyloopvar
+    - ginkgolinter
+    - goconst
+    - gocyclo
+    - gofmt
+    - gosimple
+    - govet
+    - ineffassign
+    # - lll
+    - misspell
+    - nakedret
+    - prealloc
+    - revive
+    - staticcheck
+    - typecheck
+    - unconvert
+    - unparam
+    - unused
+
+linters-settings:
+  revive:
+    rules:
+      - name: comment-spacings

Dockerfile

@@ -0,0 +1,47 @@
+FROM golang:1.24.2 AS build
+WORKDIR /app
+ARG appVersion=""
+
+# Copy the source code.
+COPY . .
+# Installs Go dependencies
+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.3
+ENV TZ=UTC
+ARG WORKDIR="/config"
+ARG BACKUPDIR="/backup"
+ARG BACKUP_TMP_DIR="/tmp/backup"
+ARG TEMPLATES_DIR="/config/templates"
+ARG appVersion=""
+ENV VERSION=${appVersion}
+LABEL org.opencontainers.image.title="mysql-bkup"
+LABEL org.opencontainers.image.description="A lightweight MySQL backup and restore tool"
+LABEL org.opencontainers.image.licenses="MIT"
+LABEL org.opencontainers.image.authors="Jonas Kaninda <me@jonaskaninda.com>"
+LABEL org.opencontainers.image.version=${appVersion}
+LABEL org.opencontainers.image.source="https://github.com/jkaninda/mysql-bkup"
+
+RUN apk --update add --no-cache mysql-client mariadb-connector-c tzdata ca-certificates
+RUN mkdir -p $WORKDIR $BACKUPDIR $TEMPLATES_DIR $BACKUP_TMP_DIR && \
+     chmod a+rw $WORKDIR $BACKUPDIR $BACKUP_TMP_DIR
+COPY --from=build /app/mysql-bkup /usr/local/bin/mysql-bkup
+COPY ./templates/* $TEMPLATES_DIR/
+RUN chmod +x /usr/local/bin/mysql-bkup && \
+    ln -s /usr/local/bin/mysql-bkup /usr/local/bin/bkup
+
+# Create backup script and make it executable
+RUN printf '#!/bin/sh\n/usr/local/bin/mysql-bkup backup "$@"' > /usr/local/bin/backup && \
+    chmod +x /usr/local/bin/backup
+# Create restore script and make it executable
+RUN printf '#!/bin/sh\n/usr/local/bin/mysql-bkup restore "$@"' > /usr/local/bin/restore && \
+    chmod +x /usr/local/bin/restore
+# Create migrate script and make it executable
+RUN printf '#!/bin/sh\n/usr/local/bin/mysql-bkup migrate "$@"' > /usr/local/bin/migrate && \
+    chmod +x /usr/local/bin/migrate
+
+WORKDIR $WORKDIR
+ENTRYPOINT ["/usr/local/bin/mysql-bkup"]

README.md

@@ -1,22 +1,67 @@
-# MySQL Backup
-MySQL Backup and Restoration tool. Backup database to AWS S3 storage or any S3 Alternatives for Object Storage.
+# MYSQL-BKUP
 
-[![Build](https://github.com/jkaninda/mysql-bkup/actions/workflows/build.yml/badge.svg)](https://github.com/jkaninda/mysql-bkup/actions/workflows/build.yml)
+**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.
+
+MYSQL-BKUP is designed for seamless deployment on **Docker** and **Kubernetes**, simplifying MySQL backup, restoration, and migration across environments.
+It is a lightweight, multi-architecture solution compatible with **Docker**, **Docker Swarm**, **Kubernetes**, and other container orchestration platforms.
+
+
+
+
+
+[![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)
 ![Docker Pulls](https://img.shields.io/docker/pulls/jkaninda/mysql-bkup?style=flat-square)
+<a href="https://ko-fi.com/jkaninda"><img src="https://uploads-ssl.webflow.com/5c14e387dab576fe667689cf/5cbed8a4ae2b88347c06c923_BuyMeACoffee_blue.png" height="20" alt="buy ma a coffee"></a>
 
-<p align="center">
-  <a href="https://github.com/jkaninda/mysql-bkup">
-    <img src="https://www.mysql.com/common/logos/logo-mysql-170x115.png" alt="Logo">
-  </a>
-  </p>
+## Features
+
+- **Flexible Storage Backends:**
+    - Local filesystem
+    - Amazon S3 & S3-compatible storage (e.g., MinIO, Wasabi)
+    - FTP
+    - SSH-compatible storage
+    - Azure Blob storage
+
+- **Data Security:**
+    - Backups can be encrypted using **GPG** to ensure confidentiality.
+
+- **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 MySQL databases when deployed:
+        - On Docker for automated backup schedules.
+        - As a **Job** or **CronJob** on Kubernetes.
+
+- **Notifications:**
+    - Get real-time updates on backup success or failure via:
+        - **Telegram**
+        - **Email**
+
+## 💡Use Cases
+
+- **Scheduled Backups**: Automate recurring backups using Docker or Kubernetes.
+- **Disaster Recovery:** Quickly restore backups to a clean MySQL instance.
+- **Database Migration**: Seamlessly move data across environments using the built-in `migrate` feature.
+- **Secure Archiving:** Keep backups encrypted and safely stored in the cloud or remote servers.
+
+
+## ✅ Verified Platforms:
+MYSQL-BKUP has been tested and runs successfully on:
 
-> Runs on:
 - Docker
+- Docker Swarm
 - Kubernetes
+- OpenShift
+
+## Documentation is found at <https://jkaninda.github.io/mysql-bkup>
+
+
+## Links:
 
-> Links:
 - [Docker Hub](https://hub.docker.com/r/jkaninda/mysql-bkup)
 - [Github](https://github.com/jkaninda/mysql-bkup)
 
@@ -25,336 +70,261 @@ MySQL Backup and Restoration tool. Backup database to AWS S3 storage or any S3 A
 - [PostgreSQL](https://github.com/jkaninda/pg-bkup)
 
 
+## Quickstart
 
-## Storage:
-- local
-- s3
-- Object storage
+### Simple Backup Using Docker CLI
 
-## Volumes:
+To perform a one-time backup, bind your local volume to `/backup` in the container and run the `backup` command:
 
-- /s3mnt => S3 mounting path 
-- /backup => local storage mounting path
-
-## Usage
-
-| Options       | Shorts | Usage                              |
-|---------------|--------|------------------------------------|
-| mysql_bkup    | bkup   | CLI utility                    |
-| --operation   | -o     | Set operation. backup or restore (default: backup)    |
-| --storage      | -s     | Set storage. local or s3 (default: local)        |
-| --file        | -f     | Set file name for restoration      |
-| --path        |      | Set s3 path without file name. eg: /custom_path      |
-| --dbname        | -d     | Set database name      |
-| --port        | -p     | Set database port (default: 3306)      |
-| --mode     | -m     | Set execution mode. default or scheduled (default: default)        |
-| --disable-compression     |      | Disable database backup compression       |
-| --period     |      | Set crontab period for scheduled mode only. (default: "0 1 * * *")        |
-| --timeout     | -t     | Set timeout (default: 60s)        |
-| --help        | -h     | Print this help message and exit   |
-| --version     | -V     | Print version information and exit |
-
-## Note:
-
-Creating a user for backup tasks who has read-only access is recommended!
-
-> create read-only user
-
-```sh
-mysql -u root -p
+```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 backup -d database_name
 ```
 
-```sql
-CREATE USER read_only_user IDENTIFIED BY 'your_strong_password';
-
-```
-```sql
-GRANT SELECT, SHOW VIEW ON *.* TO read_only_user;
-```
-```sql
-FLUSH PRIVILEGES;
+Alternatively, use an environment file (`--env-file`) for configuration:
 
+```shell
+docker run --rm --network your_network_name \
+  --env-file your-env-file \
+  -v $PWD/backup:/backup/ \
+  jkaninda/mysql-bkup backup -d database_name
 ```
 
-## Backup database :
+### Backup All Databases
 
-Simple backup usage
+To back up all databases on the server, use the `--all-databases` or `-a` flag. By default, this creates individual backup files for each database.
 
-```sh
-bkup --operation backup --dbname database_name
-```
-```sh
-bkup -o backup -d database_name
-```
-### S3
-
-```sh
-bkup --operation backup --storage s3 --dbname database_name
-```
-## Docker run:
-
-```sh
-docker run --rm --network your_network_name --name mysql-bkup -v $PWD/backup:/backup/ -e "DB_HOST=database_host_name" -e "DB_USERNAME=username" -e "DB_PASSWORD=password" jkaninda/mysql-bkup:latest  bkup -o backup -d database_name
+```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 backup --all-databases --disable-compression
 ```
 
-## Docker compose file:
+> **Note:** Use the `--all-in-one` or `-A` flag to combine backups into a single file.
+
+---
+
+### Simple Restore Using Docker CLI
+
+To restore a database, bind your local volume to `/backup` 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
+```
+
+---
+
+### Backup with Docker Compose
+
+Below is an example of a `docker-compose.yml` file for running a one-time backup:
+
 ```yaml
-version: '3'
 services:
-  mariadb:
-    container_name: mariadb
-    image: mariadb
-    environment:
-      MYSQL_DATABASE: mariadb
-      MYSQL_USER: mariadb
-      MYSQL_PASSWORD: password
-      MYSQL_ROOT_PASSWORD: password
-  mysql-bkup:
+  pg-bkup:
+    # In production, pin your image tag to a specific release version instead of `latest`.
+    # See available releases: https://github.com/jkaninda/mysql-bkup/releases
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup -d database_name
+    command: backup
     volumes:
       - ./backup:/backup
-    environment:
-      - DB_PORT=3306
-      - DB_HOST=mariadb
-      - DB_USERNAME=mariadb
-      - DB_PASSWORD=password
-```
-## Restore database :
-
-Simple database restore operation usage
-
-```sh
-bkup --operation restore --dbname database_name --file database_20231217_115621.sql
-```
-
-```sh
-bkup -o restore -f database_20231217_115621.sql 
-```
-### S3
-
-```sh
-bkup --operation restore --storage s3 --file database_20231217_115621.sql 
-```
-
-## Docker run:
-
-```sh
-docker run --rm --network your_network_name --name mysql-bkup -v $PWD/backup:/backup/ -e "DB_HOST=database_host_name" -e "DB_USERNAME=username" -e "DB_PASSWORD=password" jkaninda/mysql-bkup  bkup -o backup -d database_name -f mydb_20231219_022941.sql.gz
-```
-
-## Docker compose file:
-
-```yaml
-version: '3'
-services:
-  mariadb:
-    container_name: mariadb
-    image: mariadb:latest
-    environment:
-      MYSQL_DATABASE: mariadb
-      MYSQL_USER: mariadb
-      MYSQL_PASSWORD: password
-      MYSQL_ROOT_PASSWORD: password
-  mysql-bkup:
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation restore --file database_20231217_115621.sql --dbname database_name
-    volumes:
-      - ./backup:/backup
-    environment:
-      #- FILE_NAME=mariadb_20231217_040238.sql # Optional if file name is set from command
-      - DB_PORT=3306
-      - DB_HOST=mariadb
-      - DB_NAME=mariadb
-      - DB_USERNAME=mariadb
-      - DB_PASSWORD=password
-```
-## Run 
-
-```sh
-docker-compose up -d
-```
-## Backup to S3
-
-```sh
-docker run --rm --privileged --device /dev/fuse --name mysql-bkup -e "DB_HOST=db_hostname" -e "DB_USERNAME=username" -e "DB_PASSWORD=password" -e "ACCESS_KEY=your_access_key" -e "SECRET_KEY=your_secret_key" -e "BUCKETNAME=your_bucket_name" -e "S3_ENDPOINT=https://s3.us-west-2.amazonaws.com" jkaninda/mysql-bkup  bkup -o backup -s s3 -d database_name
-```
-> To change s3 backup path add this flag : --path /myPath . default path is /mysql_bkup
-
-Simple S3 backup usage
-
-```sh
-bkup --operation backup --storage s3 --dbname mydatabase 
-```
-```yaml
-version: '3'
-services:
-  mysql-bkup:
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    privileged: true
-    devices:
-    - "/dev/fuse"
-    command:
-      - /bin/sh
-      - -c
-      - mysql_bkup --operation restore --storage s3 -f database_20231217_115621.sql.gz
     environment:
       - DB_PORT=3306
       - DB_HOST=mysql
-      - DB_NAME=mariadb
-      - DB_USERNAME=mariadb
+      - DB_NAME=foo
+      - DB_USERNAME=bar
       - DB_PASSWORD=password
-      - ACCESS_KEY=${ACCESS_KEY}
-      - SECRET_KEY=${SECRET_KEY}
-      - BUCKETNAME=${BUCKETNAME}
-      - S3_ENDPOINT=${S3_ENDPOINT}
+      - TZ=Europe/Paris
+    networks:
+      - web
 
-```
-## Run in Scheduled mode
-
-This tool 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 `--mode scheduled` flag and specify the periodical backup time by adding `--period "0 1 * * *"` flag.
-
-Make an automated backup on Docker
-
-## Syntax of crontab (field description)
-
-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])
-
-Easy to remember format:
-
-```conf
-* * * * * command to be executed
+networks:
+  web:
 ```
 
-```conf
-- - - - -
-| | | | |
-| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
-| | | ------- Month (1 - 12)
-| | --------- Day of month (1 - 31)
-| ----------- Hour (0 - 23)
-------------- Minute (0 - 59)
+---
+
+### Recurring Backups with Docker
+
+You can schedule recurring backups using the `--cron-expression` or `-e` flag:
+
+```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"
 ```
 
-> At every 30th minute
+For predefined schedules, refer to the [documentation](https://jkaninda.github.io/mysql-bkup/reference/#predefined-schedules).
 
-```conf
-*/30 * * * *
-```
-> “At minute 0.” every hour
-```conf
-0 * * * *
-```
+---
 
-> “At 01:00.” every day
+## Deploy on Kubernetes
 
-```conf
-0 1 * * *
-```
+For Kubernetes, you can deploy `mysql-bkup` as a Job or CronJob. Below are examples for both.
 
-## Example of scheduled mode
+### Kubernetes Backup Job
 
-> Docker run :
-
-```sh
-docker run --rm --name mysql-bkup -v $BACKUP_DIR:/backup/ -e "DB_HOST=$DB_HOST" -e "DB_USERNAME=$DB_USERNAME" -e "DB_PASSWORD=$DB_PASSWORD" jkaninda/mysql-bkup  bkup --operation backup --dbname $DB_NAME --mode scheduled --period "0 1 * * *"
-```
-
-> With Docker compose
+This example defines a one-time backup job:
 
 ```yaml
-version: "3"
-services:
-  mysql-bkup:
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    privileged: true
-    devices:
-    - "/dev/fuse"
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup --storage s3 --path /mys3_custome_path --dbname database_name --mode scheduled --period "*/30 * * * *"
-    environment:
-      - DB_PORT=3306
-      - DB_HOST=mysqlhost
-      - DB_USERNAME=userName
-      - DB_PASSWORD=${DB_PASSWORD}
-      - ACCESS_KEY=${ACCESS_KEY}
-      - SECRET_KEY=${SECRET_KEY}
-      - BUCKETNAME=${BUCKETNAME}
-      - S3_ENDPOINT=${S3_ENDPOINT}
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup-job
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          # Pin the image tag to a specific release version in production.
+          # See available releases: https://github.com/jkaninda/mysql-bkup/releases
+          image: jkaninda/mysql-bkup
+          command: ["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 the host
+            type: Directory # Optional field
+      restartPolicy: Never
 ```
 
+### Kubernetes CronJob for Scheduled Backups
 
-## Kubernetes CronJob
-For Kubernetes you don't need to run it in scheduled mode.
-
-Simple Kubernetes CronJob usage:
+For scheduled backups, use a `CronJob`:
 
 ```yaml
 apiVersion: batch/v1
 kind: CronJob
 metadata:
-  name: mysql-bkup-job
+  name: pg-bkup-cronjob
 spec:
-  schedule: "0 1 * * *"
+  schedule: "0 2 * * *" # Runs daily at 2 AM
   jobTemplate:
     spec:
       template:
         spec:
           containers:
-          - name: mysql-bkup
-            image: jkaninda/mysql-bkup
-            securityContext:
-              privileged: true
-            command:
-            - /bin/sh
-            - -c
-            - bkup -o backup -s s3 --path /custom_path
-            env:
-              - name: DB_PORT
-                value: "3306" 
-              - name: DB_HOST
-                value: ""
-              - name: DB_NAME
-                value: ""
-              - name: DB_USERNAME
-                value: ""
-              # Please use secret!
-              - name: DB_PASSWORD
-                value: "password"
-              - name: ACCESS_KEY
-                value: ""
-              - name: SECRET_KEY
-                value: ""
-              - name: BUCKETNAME
-                value: ""
-              - name: S3_ENDPOINT
-                value: "https://s3.us-west-2.amazonaws.com"
-          restartPolicy: Never
+            - name: pg-bkup
+              image: jkaninda/mysql-bkup
+              command: ["backup", "-d", "dbname"]
+              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
+                type: Directory
+          restartPolicy: OnFailure
 ```
 
-## Contributing
+---
+
+## 🚀 Why Use MYSQL-BKUP?
+
+**MYSQL-BKUP** isn't just another MySQL backup tool, it's a robust, production-ready solution purpose-built for modern DevOps workflows.
+
+Here’s why developers, sysadmins, and DevOps choose **MYSQL-BKUP**:
+
+### ✅ All-in-One Backup, Restore & Migration
+
+Whether you're backing up a single database, restoring critical data, or migrating across environments, MYSQL-BKUP handles it all with a **single, unified CLI** no scripting gymnastics required.
+
+
+### 🔄 Works Everywhere You Deploy
+
+Designed to be cloud-native:
+
+* **Runs seamlessly on Docker, Docker Swarm, and Kubernetes**
+* Supports **CronJobs** for automated scheduled backups
+* Compatible with GitOps and CI/CD workflows
+
+### ☁️ Flexible Storage Integrations
+
+Store your backups **anywhere**:
+
+* Local disks
+* Amazon S3, MinIO, Wasabi, Azure Blob, FTP, SSH
+
+### 🔒 Enterprise-Grade Security
+
+* **GPG Encryption**: Protect sensitive data with optional encryption before storing backups locally or in the cloud.
+* **Secure Storage** Options: Supports S3, Azure Blob, SFTP, and SSH with encrypted transfers, keeping backups safe from unauthorized access.
+
+### 📬 Instant Notifications
+
+Stay in the loop with real-time notifications via **Telegram** and **Email**. Know immediately when a backup succeeds—or fails.
+
+### 🏃‍♂️ Lightweight and Fast
+
+Written in **Go**, MYSQL-BKUP is fast, multi-arch compatible (`amd64`, `arm64`, `arm/v7`), and optimized for minimal memory and CPU usage. Ideal for both cloud and edge deployments.
+
+### 🧪 Tested. Verified. Trusted.
+
+Actively maintained with **automated testing**, **Docker image size optimizations**, and verified support across major container platforms.
+
+---
+## 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`:
+
+```
+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.
+
+## References
+
+We created this image as a simpler and more lightweight alternative to existing solutions. Here’s why:
+
+- **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.
 
-Contributions are welcome! If you encounter any issues or have suggestions for improvements, please create an issue or submit a pull request. 
-Make sure to follow the existing coding style and provide tests for your changes.
 
 ## License
 

build.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-if [ $# -eq 0 ]
-  then
-    tag='latest'
-  else
-    tag=$1
-fi
-
-#go build
-CGO_ENABLED=0 GOOS=linux go build
-
-docker build -f docker/Dockerfile  -t jkaninda/mysql-bkup:$tag .
-
-#docker compose up -d --force-recreate

cmd/backup.go

@@ -0,0 +1,57 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
+	"github.com/spf13/cobra"
+)
+
+var BackupCmd = &cobra.Command{
+	Use:     "backup ",
+	Short:   "Backup database operation",
+	Example: utils.BackupExample,
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			pkg.StartBackup(cmd)
+		} else {
+			utils.Fatal(`"backup" accepts no argument %q`, args)
+		}
+	},
+}
+
+func init() {
+	// 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

@@ -0,0 +1,45 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
+	"github.com/spf13/cobra"
+)
+
+var MigrateCmd = &cobra.Command{
+	Use:   "migrate",
+	Short: "Migrate database from a source database to a target database",
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			pkg.StartMigration(cmd)
+		} else {
+			utils.Fatal(`"migrate" accepts no argument %q`, args)
+
+		}
+
+	},
+}

cmd/restore.go

@@ -0,0 +1,54 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
+	"github.com/spf13/cobra"
+)
+
+var RestoreCmd = &cobra.Command{
+	Use:     "restore",
+	Short:   "Restore database operation",
+	Example: utils.RestoreExample,
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			pkg.StartRestore(cmd)
+		} else {
+			utils.Fatal(`"restore" accepts no argument %q`, args)
+
+		}
+
+	},
+}
+
+func init() {
+	// 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,23 +1,42 @@
-// Package cmd /*
 /*
-Copyright © 2024 Jonas Kaninda  <jonaskaninda@gmail.com>
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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 (
-	"os"
-
+	"github.com/jkaninda/mysql-bkup/utils"
 	"github.com/spf13/cobra"
+	"os"
 )
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
-	Use:   "mysql-bkup",
-	Short: "MySQL Backup tool, backup database to S3 or Object Storage",
-	Long:  `MySQL Backup and Restoration tool. Backup database to AWS S3 storage or any S3 Alternatives for Object Storage.`,
-	// Uncomment the following line if your bare application
-	// has an action associated with it:
-	// Run: func(cmd *cobra.Command, args []string) { },
+	Use:     "mysql-bkup [Command]",
+	Short:   "MySQL Backup tool, backup database to S3 or Object Storage",
+	Long:    `MySQL Database backup and restoration tool. Backup database to AWS S3 storage or any S3 Alternatives for Object Storage.`,
+	Example: utils.MainExample,
+	Version: appVersion,
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -30,25 +49,10 @@ func Execute() {
 }
 
 func init() {
-	// Here you will define your flags and configuration settings.
-	// Cobra supports persistent flags, which, if defined here,
-	// will be global for your application.
-
-	// rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.mysql-bkup.yaml)")
-
-	// Cobra also supports local flags, which will only run
-	// when this action is called directly.
-	rootCmd.PersistentFlags().StringP("operation", "o", "backup", "Set operation")
-	rootCmd.PersistentFlags().StringP("storage", "s", "local", "Set storage. local or s3")
-	rootCmd.PersistentFlags().StringP("file", "f", "", "Set file name")
-	rootCmd.PersistentFlags().StringP("path", "P", "/mysql-bkup", "Set s3 path, without file name")
-	rootCmd.PersistentFlags().StringP("dbname", "d", "", "Set database name")
-	rootCmd.PersistentFlags().StringP("mode", "m", "default", "Set execution mode. default or scheduled")
-	rootCmd.PersistentFlags().StringP("period", "", "0 1 * * *", "Set schedule period time")
-	rootCmd.PersistentFlags().IntP("timeout", "t", 30, "Set timeout")
-	rootCmd.PersistentFlags().BoolP("disable-compression", "", false, "Disable backup compression")
-	rootCmd.PersistentFlags().IntP("port", "p", 3306, "Set database port")
-	rootCmd.PersistentFlags().BoolP("help", "h", false, "Print this help message")
-	rootCmd.PersistentFlags().BoolP("version", "v", false, "shows version information")
+	rootCmd.PersistentFlags().StringP("dbname", "d", "", "Database name")
+	rootCmd.AddCommand(VersionCmd)
+	rootCmd.AddCommand(BackupCmd)
+	rootCmd.AddCommand(RestoreCmd)
+	rootCmd.AddCommand(MigrateCmd)
 
 }

cmd/version.go

@@ -0,0 +1,47 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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 (
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+var appVersion = os.Getenv("VERSION")
+
+var VersionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show version",
+	Run: func(cmd *cobra.Command, args []string) {
+		Version()
+	},
+}
+
+func Version() {
+	fmt.Printf("Version: %s \n", utils.Version)
+	fmt.Println()
+}

docker/Dockerfile

@@ -1,48 +0,0 @@
-FROM golang:1.21.0 AS build
-WORKDIR /app
-
-# Copy the source code.
-COPY . .
-# Installs Go dependencies
-RUN go mod download
-
-# Build
-RUN CGO_ENABLED=0 GOOS=linux go build -o /app/mysql-bkup
-
-FROM ubuntu:24.04
-ENV DB_HOST=""
-ENV DB_NAME=""
-ENV DB_USERNAME=""
-ENV DB_PASSWORD=""
-ENV DB_PORT="3306"
-ENV STORAGE=local
-ENV BUCKETNAME=""
-ENV ACCESS_KEY=""
-ENV SECRET_KEY=""
-ENV S3_ENDPOINT=https://s3.amazonaws.com
-ARG DEBIAN_FRONTEND=noninteractive
-ENV VERSION="v0.4"
-LABEL authors="Jonas Kaninda"
-
-RUN apt-get update -qq
-#RUN apt-get install build-essential libcurl4-openssl-dev libxml2-dev mime-support -y
-RUN apt install s3fs mysql-client supervisor cron -y
-
-# Clear cache
-RUN apt-get clean && rm -rf /var/lib/apt/lists/*
-
-RUN mkdir /s3mnt
-RUN mkdir /tmp/s3cache
-RUN chmod 777 /s3mnt
-RUN chmod 777 /tmp/s3cache
-
-COPY --from=build /app/mysql-bkup /usr/local/bin/mysql-bkup
-RUN chmod +x /usr/local/bin/mysql-bkup
-
-RUN ln -s /usr/local/bin/mysql-bkup /usr/local/bin/bkup
-
-ADD docker/supervisord.conf /etc/supervisor/supervisord.conf
-
-
-RUN mkdir /backup
-WORKDIR /backup

docker/supervisord.conf

@@ -1,13 +0,0 @@
-[supervisord]
-nodaemon=true
-user=root
-logfile=/var/log/supervisor/supervisord.log
-pidfile=/var/run/supervisord.pid
-
-[program:cron]
-command = /bin/bash -c "declare -p | grep -Ev '^declare -[[:alpha:]]*r' > /run/supervisord.env && /usr/sbin/cron -f -L 15"
-autostart=true
-autorestart=true
-user = root
-stderr_logfile=/var/log/cron.err.log
-stdout_logfile=/var/log/cron.out.log

docs/.gitignore

@@ -0,0 +1,3 @@
+_site
+.sass-cache
+.jekyll-metadata

docs/404.html

@@ -0,0 +1,24 @@
+---
+layout: default
+---
+
+<style type="text/css" media="screen">
+  .container {
+    margin: 10px auto;
+    max-width: 600px;
+    text-align: center;
+  }
+  h1 {
+    margin: 30px 0;
+    font-size: 4em;
+    line-height: 1;
+    letter-spacing: -1px;
+  }
+</style>
+
+<div class="container">
+  <h1>404</h1>
+
+  <p><strong>Page not found :(</strong></p>
+  <p>The requested page could not be found.</p>
+</div>

docs/Gemfile

@@ -0,0 +1,43 @@
+source "https://rubygems.org"
+
+# Hello! This is where you manage which Jekyll version is used to run.
+# When you want to use a different version, change it below, save the
+# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
+#
+#     bundle exec jekyll serve
+#
+# This will help ensure the proper Jekyll version is running.
+# Happy Jekylling!
+gem "jekyll", "~> 3.10.0"
+
+# This is the default theme for new Jekyll sites. You may change this to anything you like.
+gem "minima", "~> 2.0"
+
+# If you want to use GitHub Pages, remove the "gem "jekyll"" above and
+# uncomment the line below. To umysqlrade, run `bundle update github-pages`.
+# gem "github-pages", group: :jekyll_plugins
+
+# If you have any plugins, put them here!
+group :jekyll_plugins do
+  gem "jekyll-feed", "~> 0.6"
+end
+
+# Windows and JRuby does not include zoneinfo files, so bundle the tzinfo-data gem
+# and associated library.
+platforms :mingw, :x64_mingw, :mswin, :jruby do
+  gem "tzinfo", ">= 1", "< 3"
+  gem "tzinfo-data"
+end
+
+# Performance-booster for watching directories on Windows
+gem "wdm", "~> 0.1.0", :install_if => Gem.win_platform?
+
+# kramdown v2 ships without the gfm parser by default. If you're using
+# kramdown v1, comment out this line.
+gem "kramdown-parser-gfm"
+
+# Lock `http_parser.rb` gem to `v0.6.x` on JRuby builds since newer versions of the gem
+# do not have a Java counterpart.
+gem "http_parser.rb", "~> 0.6.0", :platforms => [:jruby]
+gem "just-the-docs"
+

docs/Gemfile.lock

@@ -0,0 +1,116 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    colorator (1.1.0)
+    concurrent-ruby (1.3.3)
+    csv (3.3.0)
+    em-websocket (0.5.3)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0)
+    eventmachine (1.2.7)
+    ffi (1.17.0)
+    ffi (1.17.0-aarch64-linux-gnu)
+    ffi (1.17.0-aarch64-linux-musl)
+    ffi (1.17.0-arm-linux-gnu)
+    ffi (1.17.0-arm-linux-musl)
+    ffi (1.17.0-arm64-darwin)
+    ffi (1.17.0-x86-linux-gnu)
+    ffi (1.17.0-x86-linux-musl)
+    ffi (1.17.0-x86_64-darwin)
+    ffi (1.17.0-x86_64-linux-gnu)
+    ffi (1.17.0-x86_64-linux-musl)
+    forwardable-extended (2.6.0)
+    http_parser.rb (0.8.0)
+    i18n (1.14.5)
+      concurrent-ruby (~> 1.0)
+    jekyll (3.10.0)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      csv (~> 3.0)
+      em-websocket (~> 0.5)
+      i18n (>= 0.7, < 2)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 2.0)
+      kramdown (>= 1.17, < 3)
+      liquid (~> 4.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (>= 1.7, < 4)
+      safe_yaml (~> 1.0)
+      webrick (>= 1.0)
+    jekyll-feed (0.17.0)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-include-cache (0.2.1)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-sass-converter (1.5.2)
+      sass (~> 3.4)
+    jekyll-seo-tag (2.8.0)
+      jekyll (>= 3.8, < 5.0)
+    jekyll-watch (2.2.1)
+      listen (~> 3.0)
+    just-the-docs (0.8.2)
+      jekyll (>= 3.8.5)
+      jekyll-include-cache
+      jekyll-seo-tag (>= 2.0)
+      rake (>= 12.3.1)
+    kramdown (2.4.0)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    liquid (4.0.4)
+    listen (3.9.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    mercenary (0.3.6)
+    minima (2.5.1)
+      jekyll (>= 3.5, < 5.0)
+      jekyll-feed (~> 0.9)
+      jekyll-seo-tag (~> 2.1)
+    pathutil (0.16.2)
+      forwardable-extended (~> 2.6)
+    public_suffix (6.0.1)
+    rake (13.2.1)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.11.1)
+      ffi (~> 1.0)
+    rexml (3.3.2)
+      strscan
+    rouge (3.30.0)
+    safe_yaml (1.0.5)
+    sass (3.7.4)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    strscan (3.1.0)
+    wdm (0.1.1)
+    webrick (1.8.1)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  ruby
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  http_parser.rb (~> 0.6.0)
+  jekyll (~> 3.10.0)
+  jekyll-feed (~> 0.6)
+  just-the-docs
+  kramdown-parser-gfm
+  minima (~> 2.0)
+  tzinfo (>= 1, < 3)
+  tzinfo-data
+  wdm (~> 0.1.0)
+
+BUNDLED WITH
+   2.5.16

docs/_config.yml

@@ -0,0 +1,71 @@
+# Welcome to Jekyll!
+#
+# This config file is meant for settings that affect your whole blog, values
+# which you are expected to set up once and rarely edit after that. If you find
+# yourself editing this file very often, consider using Jekyll's data files
+# feature for the data you need to update frequently.
+#
+# For technical reasons, this file is *NOT* reloaded automatically when you use
+# 'bundle exec jekyll serve'. If you change this file, please restart the server process.
+
+# Site settings
+# These are used to personalize your new site. If you look in the HTML files,
+# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
+# You can create any custom variable you would like, and they will be accessible
+# in the templates via {{ site.myvariable }}.
+title: MySQL Backup Docker container image
+email: hi@jonaskaninda.com
+description: >- # this means to ignore newlines until "baseurl:"
+  MySQL Backup is a Docker container image that can be used to backup and restore MySQL database. 
+  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: "" # the base hostname & protocol for your site, e.g. http://example.com
+twitter_username: jonaskaninda
+github_username:  jkaninda
+
+callouts_level: quiet
+callouts:
+  highlight:
+    color: yellow
+  important:
+    title: Important
+    color: blue
+  new:
+    title: New
+    color: green
+  note:
+    title: Note
+    color: purple
+  warning:
+    title: Warning
+    color: red
+# Build settings
+markdown: kramdown
+theme: just-the-docs
+plugins:
+  - jekyll-feed
+aux_links:
+  'GitHub Repository':
+    - https://github.com/jkaninda/mysql-bkup
+
+nav_external_links:
+  - title: GitHub Repository
+    url: https://github.com/jkaninda/mysql-bkup
+
+footer_content: >-
+  Copyright &copy; 2024 <a target="_blank" href="https://www.jonaskaninda.com">Jonas Kaninda</a>.
+  Distributed under the <a href="https://github.com/jkaninda/mysql-bkup/tree/main/LICENSE">MIT License.</a><br>
+  Something missing, unclear or not working? Open <a href="https://github.com/jkaninda/mysql-bkup/issues">an issue</a>.
+
+# Exclude from processing.
+# The following items will not be processed, by default. Create a custom list
+# to override the default setting.
+# exclude:
+#   - Gemfile
+#   - Gemfile2.lock
+#   - node_modules
+#   - vendor/bundle/
+#   - vendor/cache/
+#   - vendor/gems/
+#   - vendor/ruby/

docs/_posts/2024-07-29-welcome-to-jekyll.markdown

@@ -0,0 +1,25 @@
+---
+layout: post
+title:  "Welcome to Jekyll!"
+date:   2024-07-29 03:36:13 +0200
+categories: jekyll update
+---
+You’ll find this post in your `_posts` directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run `jekyll serve`, which launches a web server and auto-regenerates your site when a file is updated.
+
+To add new posts, simply add a file in the `_posts` directory that follows the convention `YYYY-MM-DD-name-of-post.ext` and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.
+
+Jekyll also offers powerful support for code snippets:
+
+{% highlight ruby %}
+def print_hi(name)
+  puts "Hi, #{name}"
+end
+print_hi('Tom')
+#=> prints 'Hi, Tom' to STDOUT.
+{% endhighlight %}
+
+Check out the [Jekyll docs][jekyll-docs] for more info on how to get the most out of Jekyll. File all bugs/feature requests at [Jekyll’s GitHub repo][jekyll-gh]. If you have questions, you can ask them on [Jekyll Talk][jekyll-talk].
+
+[jekyll-docs]: https://jekyllrb.com/docs/home
+[jekyll-gh]:   https://github.com/jekyll/jekyll
+[jekyll-talk]: https://talk.jekyllrb.com/

docs/how-tos/azure-blob.md

@@ -0,0 +1,72 @@
+---
+title: Azure Blob storage
+layout: default
+parent: How Tos
+nav_order: 5
+---
+
+# 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.
+
+This section explains how to set up and configure Azure Blob-based backups.
+
+---
+
+## 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, 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
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## Azure Blob Configuration
+      - AZURE_STORAGE_CONTAINER_NAME=backup-container
+      - AZURE_STORAGE_ACCOUNT_NAME=account-name
+      - AZURE_STORAGE_ACCOUNT_KEY=Ppby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
+
+    # 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-one` (`-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

@@ -0,0 +1,75 @@
+---
+title: Backup to FTP remote server
+layout: default
+parent: How Tos
+nav_order: 4
+---
+
+# Backup to FTP Remote Server
+
+To store your backups on an FTP remote server, you can configure the backup process to use the `--storage ftp` option. 
+
+This section explains how to set up and configure FTP-based backups.
+
+---
+
+## 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, 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=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## FTP Configuration
+      - FTP_HOST="hostname"
+      - FTP_PORT=21
+      - FTP_USER=user
+      - FTP_PASSWORD=password
+      - REMOTE_PATH=/home/jkaninda/backups
+
+    # 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

@@ -0,0 +1,126 @@
+---
+title: Backup to AWS S3
+layout: default
+parent: How Tos
+nav_order: 2
+---
+# Backup to AWS S3
+
+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.
+
+---
+
+## Configuration Steps
+
+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, 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=5432
+      - DB_HOST=postgres
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS Configuration
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION=us-west-2
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## 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 mysql-bkup container is connected to the same network as your database
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## Recurring Backups to S3
+
+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, 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 database --cron-expression "0 1 * * *"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS Configuration
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION=us-west-2
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## 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
+      ## 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
+
+- **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

@@ -0,0 +1,129 @@
+---
+title: Backup to SSH or SFTP
+layout: default
+parent: How Tos
+nav_order: 3
+---
+# 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.
+
+---
+
+## Configuration Steps
+
+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, 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
+
+networks:
+   web:
+```
+
+---
+
+## Recurring Backups to SSH Remote Server
+
+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.
+
+### Example: Recurring Backup Configuration
+
+```yaml
+services:
+   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 "@daily"
+    volumes:
+      - ./id_ed25519:/tmp/id_ed25519
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - 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: Delete old backups after a specified number of days
+      #- BACKUP_RETENTION_DAYS=7
+      ## 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
+
+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

@@ -0,0 +1,117 @@
+---
+title: Backup
+layout: default
+parent: How Tos
+nav_order: 1
+---
+
+# Backup Database
+
+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 backup process supports recurring backups on Docker or Docker Swarm. On Kubernetes, it can be deployed as a CronJob.
+
+---
+
+## Example: Basic Backup Configuration
+
+Below is an example `docker-compose.yml` configuration for backing up a database:
+
+```yaml
+services:
+  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
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## 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
+```
+
+---
+
+## 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, 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 @midnight
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## 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
+     
+    # 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

@@ -0,0 +1,369 @@
+---
+title: Deploy on Kubernetes
+layout: default
+parent: How Tos
+nav_order: 9
+---
+
+# Deploy on Kubernetes
+
+To deploy MySQL Backup on Kubernetes, you can use a `Job` for one-time backups or restores, and a `CronJob` for recurring backups. 
+
+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
+kind: Job
+metadata:
+  name: backup
+spec:
+  template:
+    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
+        - 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
+
+This example demonstrates how to configure a Kubernetes `Job` to back up a MySQL database to an SSH remote server.
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    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
+        - 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: "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 you want to encrypt your backup
+          - name: GPG_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
+metadata:
+  name: restore-job
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    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
+        - 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: "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 with CronJob
+
+This example demonstrates how to configure a Kubernetes `CronJob` for recurring backups to an SSH remote server.
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: backup-job
+spec:
+  schedule: "* * * * *"
+  jobTemplate:
+    spec:
+      template:
+        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
+            - 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: Never
+```
+
+---
+
+## 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
+kind: CronJob
+metadata:
+  name: backup-job
+spec:
+  schedule: "* * * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          securityContext:
+            runAsUser: 1000
+            runAsGroup: 3000
+            fsGroup: 2000
+          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
+            - 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
+
+This example demonstrates how to configure a Kubernetes `Job` to migrate a MySQL database from one server to another.
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: migrate-db
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    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
+        - migrate
+        resources:
+          limits:
+            memory: "128Mi"
+            cpu: "500m"
+        env:
+          ## Source Database
+          - name: DB_HOST
+            value: "postgres"
+          - name: DB_PORT
+            value: "3306"
+          - name: DB_NAME
+            value: "dbname"
+          - name: DB_USERNAME
+            value: "username"
+          - name: DB_PASSWORD
+            value: "password"
+          ## Target Database
+          - name: TARGET_DB_HOST
+            value: "target-postgres"
+          - name: TARGET_DB_PORT
+            value: "3306"
+          - name: TARGET_DB_NAME
+            value: "dbname"
+          - name: TARGET_DB_USERNAME
+            value: "username"
+          - 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/deprecated-configs.md

@@ -0,0 +1,6 @@
+---
+title: Update deprecated configurations
+layout: default
+parent: How Tos
+nav_order: 11
+---

docs/how-tos/encrypt-backup.md

@@ -0,0 +1,120 @@
+---
+title: Encrypt backups using GPG
+layout: default
+parent: How Tos
+nav_order: 8
+---
+# Encrypt Backup
+
+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 must provide the same GPG passphrase or private key used during the backup process.
+
+---
+
+## Key Features
+
+- **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.
+
+---
+
+## Using GPG Passphrase
+
+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, 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
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## Required to encrypt backup
+      - GPG_PASSPHRASE=my-secure-passphrase
+    # Ensure the pg-bkup container is connected to the same network as your database
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## Using GPG Public Key
+
+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, 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
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## Required to encrypt backup
+      - GPG_PUBLIC_KEY=/config/public_key.asc
+    # 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/index.md

@@ -0,0 +1,8 @@
+---
+title: How Tos
+layout: default
+nav_order: 3
+has_children: true
+---
+
+## How Tos

docs/how-tos/migrate.md

@@ -0,0 +1,106 @@
+---
+title: Migrate database
+layout: default
+parent: How Tos
+nav_order: 10
+---
+
+# Migrate Database
+
+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 `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**. Always back up your target database before performing this action.
+
+---
+
+## 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, 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
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+
+      ## Target Database
+      - TARGET_DB_HOST=target-postgres
+      - TARGET_DB_PORT=3306
+      - TARGET_DB_NAME=dbname
+      - TARGET_DB_USERNAME=username
+      - TARGET_DB_PASSWORD=password
+
+    # Ensure the mysql-bkup container is connected to the same network as your database
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## Migrate Database Using Docker CLI
+
+You can also run the migration directly using the Docker CLI. Below is an example:
+
+### 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
+
+## Target Database
+TARGET_DB_HOST=target-postgres
+TARGET_DB_PORT=3306
+TARGET_DB_NAME=dbname
+TARGET_DB_USERNAME=username
+TARGET_DB_PASSWORD=password
+```
+
+### 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

@@ -0,0 +1,103 @@
+---
+title: Run multiple database backup schedules in the same container
+layout: default
+parent: How Tos
+nav_order: 11
+---
+
+
+# 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 prefix or suffix in the variable name (e.g., `DB_HOST_DATABASENAME` or `DATABASENAME_DB_HOST`).
+- **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
+# 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       # 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 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, 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 #--config /backup/config.yaml # config file
+    volumes:
+      - ./backup:/backup  # Mount the backup directory
+      - ./config.yaml:/backup/config.yaml  # Mount the configuration file
+    environment:
+      ## Specify the path to the configuration file
+      - BACKUP_CONFIG_FILE=/backup/config.yaml
+    # Ensure the mysql-bkup container is connected to the same network as your database
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+
+

docs/how-tos/receive-notification.md

@@ -0,0 +1,197 @@
+---
+title: Receive notifications
+layout: default
+parent: How Tos
+nav_order: 13
+---
+
+# 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:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## SMTP Configuration
+      - MAIL_HOST=smtp.example.com
+      - MAIL_PORT=587
+      - 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 notifications
+      - TIME_FORMAT=2006-01-02 at 15:04:05
+      ## Backup reference (e.g., database/cluster name or server name)
+      - BACKUP_REFERENCE=database/Paris cluster
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## 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:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## Telegram Configuration
+      - TG_TOKEN=[BOT ID]:[BOT TOKEN]
+      - TG_CHAT_ID=your-chat-id
+      ## Time format for notifications
+      - TIME_FORMAT=2006-01-02 at 15:04:05
+      ## Backup reference (e.g., database/cluster name or server name)
+      - BACKUP_REFERENCE=database/Paris cluster
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+## Customize Notifications
+
+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:
+
+- `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.
+
+### Template Data
+
+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>
+<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>
+```
+
+#### `telegram.tmpl` (Successful Backup)
+
+```html
+✅ 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 End Time: {{.EndTime}}
+- Backup Storage: {{.Storage}}
+- Backup Location: {{.BackupLocation}}
+- Backup Size: {{.BackupSize}} bytes
+- Backup Reference: {{.BackupReference}}
+```
+
+#### `email-error.tmpl` (Failed Backup)
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>🔴 Urgent: Database Backup Failure Notification</title>
+</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>
+</body>
+</html>
+```
+
+#### `telegram-error.tmpl` (Failed Backup)
+
+```html
+🔴 Urgent: Database Backup Failure Notification
+
+An error occurred during database backup.
+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

@@ -0,0 +1,75 @@
+---
+title: Restore database from AWS S3
+layout: default
+parent: How Tos
+nav_order: 6
+---
+
+# Restore Database from S3 Storage
+
+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:
+
+- `.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. **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, 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  # 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 S3 Configuration
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION=us-west-2
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## 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

@@ -0,0 +1,74 @@
+---
+title: Restore database from SSH
+layout: default
+parent: How Tos
+nav_order: 7
+---
+
+# Restore Database from SSH Remote Server
+
+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:
+
+- `.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. **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, 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  # 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=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## SSH Configuration
+      - SSH_HOST_NAME=hostname
+      - SSH_PORT=22
+      - SSH_USER=user
+      - SSH_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
+
+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

@@ -0,0 +1,64 @@
+---
+title: Restore database
+layout: default
+parent: How Tos
+nav_order: 5
+---
+
+
+# Restore Database
+
+To restore a MySQL database, use the `restore` command and specify the backup file to restore with the `--file` flag. 
+
+The system supports the following file formats:
+
+- `.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, 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  # Mount the directory containing the backup file
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+    # 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

@@ -0,0 +1,97 @@
+---
+title: Overview
+layout: home
+nav_order: 1
+---
+
+# About mysql-bkup
+{:.no_toc}
+
+**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.
+
+**MYSQL-BKUP** is designed for seamless deployment on **Docker** and **Kubernetes**, simplifying MySQL backup, restoration, and migration across environments.
+It is a lightweight, multi-architecture solution compatible with **Docker**, **Docker Swarm**, **Kubernetes**, and other container orchestration platforms.
+---
+
+## Key Features
+
+### Storage Options
+- **Local storage**
+- **AWS S3** or any S3-compatible object storage
+- **FTP**
+- **SFTP**
+- **SSH-compatible storage**
+- **Azure Blob storage**
+
+### Data Security
+- Backups can be encrypted using **GPG** to ensure data confidentiality.
+
+### 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
+
+- **Scheduled Backups**: Automate recurring backups using Docker or Kubernetes.
+- **Disaster Recovery:** Quickly restore backups to a clean MySQL instance.
+- **Database Migration**: Seamlessly move data across environments using the built-in `migrate` feature.
+- **Secure Archiving:** Keep backups encrypted and safely stored in the cloud or remote servers.
+
+
+## ✅ Verified Platforms:
+MYSQL-BKUP has been tested and runs successfully on:
+
+- Docker
+- Docker Swarm
+- Kubernetes
+- OpenShift
+
+---
+
+## 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 the `v1` version are available on [this branch][v1-branch].
+
+[v1-branch]: https://github.com/jkaninda/mysql-bkup
+
+---
+
+## Available Image Registries
+
+The Docker image is published to both **Docker Hub** and the **GitHub Container Registry**. You can use either of the following:
+
+```bash
+docker pull jkaninda/mysql-bkup
+docker pull ghcr.io/jkaninda/mysql-bkup
+```
+
+While the documentation references Docker Hub, all examples work seamlessly with `ghcr.io`.
+
+---
+
+## References
+
+We created this image as a simpler and more lightweight alternative to existing solutions. Here’s why:
+
+- **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/old-version/index.md

@@ -0,0 +1,358 @@
+---
+layout: page
+title: Old version
+permalink: /old-version/
+---
+
+This is the documentation of mysql-backup for all old versions bellow `v1.0`.
+In the old version, S3 storage was mounted using s3fs, so we decided to migrate to the official AWS SDK.
+
+## Storage:
+- local
+- s3
+- Object storage
+
+## Volumes:
+
+- /s3mnt => S3 mounting path
+- /backup => local storage mounting path
+
+### Usage
+
+| Options               | Shorts | Usage                                                                  |
+|-----------------------|--------|------------------------------------------------------------------------|
+| mysql-bkup            | bkup   | CLI utility                                                            |
+| backup                |        | Backup database operation                                              |
+| restore               |        | Restore database operation                                             |
+| history               |        | Show the history of backup                                             |
+| --storage             | -s     | Storage. local or s3 (default: local)                                  |
+| --file                | -f     | File name to restore                                                   |
+| --path                |        | S3 path without file name. eg: /custom_path                            |
+| --dbname              | -d     | Database name                                                          |
+| --port                | -p     | Database port (default: 3306)                                          |
+| --mode                | -m     | Execution mode. default or scheduled (default: default)                |
+| --disable-compression |        | Disable database backup compression                                    |
+| --prune               |        | Delete old backup, default disabled                                    |
+| --keep-last           |        | Delete old backup created more than specified days ago, default 7 days |
+| --period              |        | Crontab period for scheduled mode only. (default: "0 1 * * *")         |
+| --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                                    |
+| ACCESS_KEY  | Optional, required for S3 storage                | AWS S3 Access Key                                    |
+| SECRET_KEY  | Optional, required for S3 storage                | AWS S3 Secret Key                                    |
+| BUCKET_NAME | Optional, required for S3 storage                | AWS S3 Bucket Name                                   |
+| S3_ENDPOINT | Optional, required for S3 storage                | AWS S3 Endpoint                                      |
+| FILE_NAME   | Optional if it was provided from the --file flag | Database file to restore (extensions: .sql, .sql.gz) |
+
+
+## Note:
+
+Creating a user for backup tasks who has read-only access is recommended!
+
+> create read-only user
+
+
+## Backup database :
+
+Simple backup usage
+
+```sh
+bkup backup
+```
+
+### S3
+
+```sh
+mysql-bkup backup --storage s3
+```
+## Docker run:
+
+```sh
+docker run --rm --network your_network_name \
+--name mysql-bkup -v $PWD/backup:/backup/ \
+-e "DB_HOST=database_host_name" \
+-e "DB_USERNAME=username" \
+-e "DB_PASSWORD=password" jkaninda/mysql-bkup:v0.7  mysql-bkup backup -d database_name
+```
+
+## Docker compose file:
+```yaml
+version: '3'
+services:
+  postgres:
+    image: postgres:14.5
+    container_name: postgres
+    restart: unless-stopped
+    volumes:
+      - ./postgres:/var/lib/postgresql/data
+    environment:
+      POSTGRES_DB: bkup
+      POSTGRES_PASSWORD: password
+      POSTGRES_USER: bkup
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    depends_on:
+      - postgres
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup backup -d bkup
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - DB_NAME=bkup
+      - DB_USERNAME=bkup
+      - DB_PASSWORD=password
+```
+## Restore database :
+
+Simple database restore operation usage
+
+```sh
+mysql-bkup restore --file database_20231217_115621.sql  --dbname database_name
+```
+
+```sh
+mysql-bkup restore -f database_20231217_115621.sql -d database_name
+```
+### S3
+
+```sh
+mysql-bkup restore --storage s3 --file database_20231217_115621.sql --dbname database_name
+```
+
+## Docker run:
+
+```sh
+docker run --rm --network your_network_name \
+--name mysql-bkup \
+-v $PWD/backup:/backup/ \
+-e "DB_HOST=database_host_name" \
+-e "DB_USERNAME=username" \
+-e "DB_PASSWORD=password" \
+jkaninda/mysql-bkup:v0.7   mysql-bkup restore -d database_name -f store_20231219_022941.sql.gz
+```
+
+## Docker compose file:
+
+```yaml
+version: '3'
+services:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup restore --file database_20231217_115621.sql -d database_name
+    volumes:
+      - ./backup:/backup
+    environment:
+      #- FILE_NAME=database_20231217_040238.sql.gz # Optional if file name is set from command
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - DB_USERNAME=user_name
+      - DB_PASSWORD=password
+```
+## Run
+
+```sh
+docker-compose up -d
+```
+## Backup to S3
+
+```sh
+docker run --rm --privileged \
+--device /dev/fuse --name mysql-bkup \
+-e "DB_HOST=db_hostname" \
+-e "DB_USERNAME=username" \
+-e "DB_PASSWORD=password" \
+-e "ACCESS_KEY=your_access_key" \
+-e "SECRET_KEY=your_secret_key" \
+-e "BUCKETNAME=your_bucket_name" \
+-e "S3_ENDPOINT=https://s3.us-west-2.amazonaws.com" \
+jkaninda/mysql-bkup:v0.7  mysql-bkup backup -s s3 -d database_name
+```
+> To change s3 backup path add this flag : --path /my_customPath . default path is /mysql-bkup
+
+Simple S3 backup usage
+
+```sh
+mysql-bkup backup --storage s3 --dbname mydatabase 
+```
+```yaml
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    privileged: true
+    devices:
+    - "/dev/fuse"
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup restore --storage s3 -f database_20231217_115621.sql.gz --dbname database_name
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgress
+      - DB_USERNAME=user_name
+      - DB_PASSWORD=password
+      - ACCESS_KEY=${ACCESS_KEY}
+      - SECRET_KEY=${SECRET_KEY}
+      - BUCKET_NAME=${BUCKET_NAME}
+      - S3_ENDPOINT=${S3_ENDPOINT}
+
+```
+## Run in Scheduled mode
+
+This tool 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 `--mode scheduled` flag and specify the periodical backup time by adding `--period "0 1 * * *"` flag.
+
+Make an automated backup on Docker
+
+## Syntax of crontab (field description)
+
+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])
+
+Easy to remember format:
+
+```conf
+* * * * * command to be executed
+```
+
+```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 * * *
+```
+
+## Example of scheduled mode
+
+> Docker run :
+
+```sh
+docker run --rm --name mysql-bkup \
+-v $BACKUP_DIR:/backup/ \
+-e "DB_HOST=$DB_HOST" \
+-e "DB_USERNAME=$DB_USERNAME" \
+-e "DB_PASSWORD=$DB_PASSWORD" jkaninda/mysql-bkup:v0.7  mysql-bkup backup --dbname $DB_NAME --mode scheduled --period "0 1 * * *"
+```
+
+> With Docker compose
+
+```yaml
+version: "3"
+services:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    privileged: true
+    devices:
+    - "/dev/fuse"
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup backup --storage s3 --path /mys3_custom_path --dbname database_name --mode scheduled --period "*/30 * * * *"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgreshost
+      - DB_USERNAME=userName
+      - DB_PASSWORD=${DB_PASSWORD}
+      - ACCESS_KEY=${ACCESS_KEY}
+      - SECRET_KEY=${SECRET_KEY}
+      - BUCKET_NAME=${BUCKET_NAME}
+      - S3_ENDPOINT=${S3_ENDPOINT}
+```
+
+## Kubernetes CronJob
+
+For Kubernetes, you don't need to run it in scheduled mode.
+
+Simple Kubernetes CronJob usage:
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: bkup-job
+spec:
+  schedule: "0 1 * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: mysql-bkup
+            image: jkaninda/mysql-bkup:v0.7
+            securityContext:
+              privileged: true
+            command:
+            - /bin/sh
+            - -c
+            - mysql-bkup backup -s s3 --path /custom_path
+            env:
+              - name: DB_PORT
+                value: "3306" 
+              - name: DB_HOST
+                value: ""
+              - name: DB_NAME
+                value: ""
+              - name: DB_USERNAME
+                value: ""
+              # Please use secret!
+              - name: DB_PASSWORD
+                value: ""
+              - name: ACCESS_KEY
+                value: ""
+              - name: SECRET_KEY
+                value: ""
+              - name: BUCKET_NAME
+                value: ""
+              - name: S3_ENDPOINT
+                value: "https://s3.us-west-2.amazonaws.com"
+          restartPolicy: Never
+```
+
+## Authors
+
+**Jonas Kaninda**
+- <https://github.com/jkaninda>
+

docs/quickstart/index.md

@@ -0,0 +1,212 @@
+---
+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 perform 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_PORT=3306" \
+  -e "DB_USERNAME=username" \
+  -e "DB_PASSWORD=password" \
+  jkaninda/mysql-bkup backup -d database_name
+```
+
+Alternatively, use an environment file (`--env-file`) for configuration:
+
+```shell
+docker run --rm --network your_network_name \
+  --env-file your-env-file \
+  -v $PWD/backup:/backup/ \
+  jkaninda/mysql-bkup backup -d database_name
+```
+
+### Backup All Databases
+
+To back up all databases on the server, use the `--all-databases` or `-a` flag. By default, this creates individual backup files for each database.
+
+```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 backup --all-databases --disable-compression
+```
+
+> **Note:** Use the `--all-in-one` or `-A` flag to combine backups into a single file.
+
+---
+
+### Simple Restore Using Docker CLI
+
+To restore a database, bind your local volume to `/backup` 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
+```
+
+---
+
+### Backup with Docker Compose
+
+Below is an example of a `docker-compose.yml` file for running a one-time backup:
+
+```yaml
+services:
+  pg-bkup:
+    # In production, pin your image tag to a specific release version instead of `latest`.
+    # See available releases: https://github.com/jkaninda/mysql-bkup/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
+    networks:
+      - web
+
+networks:
+  web:
+```
+
+---
+
+### Recurring Backups with Docker
+
+You can schedule recurring backups using the `--cron-expression` or `-e` flag:
+
+```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"
+```
+
+For predefined schedules, refer to the [documentation](https://jkaninda.github.io/mysql-bkup/reference/#predefined-schedules).
+
+---
+
+## Deploy on Kubernetes
+
+For Kubernetes, you can deploy `mysql-bkup` as a Job or CronJob. Below are examples for both.
+
+### Kubernetes Backup Job
+
+This example defines a one-time backup job:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup-job
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          # Pin the image tag to a specific release version in production.
+          # See available releases: https://github.com/jkaninda/mysql-bkup/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 the host
+            type: Directory # Optional field
+      restartPolicy: Never
+```
+
+### Kubernetes CronJob for Scheduled Backups
+
+For scheduled backups, use a `CronJob`:
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: pg-bkup-cronjob
+spec:
+  schedule: "0 2 * * *" # Runs daily at 2 AM
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+            - name: pg-bkup
+              image: jkaninda/mysql-bkup
+              command:
+                - /bin/sh
+                - -c
+                - backup -d dbname
+              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
+                type: Directory
+          restartPolicy: OnFailure
+```
+
+---
+
+## 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

@@ -0,0 +1,132 @@
+---
+title: Configuration Reference
+layout: default
+nav_order: 3
+---
+
+# Configuration Reference
+
+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.
+
+| 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.                                                    |
+
+---
+
+## Environment Variables
+
+| 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.                                                 |
+
+---
+
+## Scheduled Backups
+
+### 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
+```
+
+| 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
+@every <duration>
+```
+
+- Example: `@every 1h30m10s` runs the backup every 1 hour, 30 minutes, and 10 seconds.

examples/docker-compose.s3.yaml

@@ -1,21 +1,29 @@
-version: "3"
 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
-    privileged: true
-    devices:
-    - "/dev/fuse"
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup --storage s3 --path /mys3_custom_path --dbname database_name
+    command: backup --storage s3 -d my-database"
     environment:
       - DB_PORT=3306
-      - DB_HOST=mysqlhost
-      - DB_USERNAME=userName
-      - DB_PASSWORD=${DB_PASSWORD}
-      - ACCESS_KEY=${ACCESS_KEY}
-      - SECRET_KEY=${SECRET_KEY}
-      - BUCKETNAME=${BUCKETNAME}
-      - S3_ENDPOINT=https://s3.us-west-2.amazonaws.com
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - 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=true # true for S3 alternative such as Minio
+      # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:

examples/docker-compose.scheduled.local.yaml

@@ -1,16 +1,17 @@
 version: "3"
 services:
   mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup --dbname database_name --mode scheduled --period "0 1 * * *"
+    command: backup --dbname database_name
     volumes:
       - ./backup:/backup
     environment:
       - DB_PORT=3306
-      - DB_HOST=mysqlhost
+      - DB_HOST=mysql
       - DB_USERNAME=userName
       - DB_PASSWORD=${DB_PASSWORD}
+      # See: https://jkaninda.github.io/mysql-bkup/reference/#predefined-schedules
+      - BACKUP_CRON_EXPRESSION=@daily #@every 5m|@weekly | @monthly |0 1 * * *

examples/docker-compose.scheduled.s3.yaml

@@ -1,21 +1,31 @@
-version: "3"
 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
-    privileged: true
-    devices:
-    - "/dev/fuse"
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup --storage s3 --path /mys3_custom_path --dbname database_name --mode scheduled --period "0 1 * * *"
+    command: backup --storage s3 -d my-database
     environment:
       - DB_PORT=3306
-      - DB_HOST=mysqlhost
-      - DB_USERNAME=userName
-      - DB_PASSWORD=${DB_PASSWORD}
-      - ACCESS_KEY=${ACCESS_KEY}
-      - SECRET_KEY=${SECRET_KEY}
-      - BUCKETNAME=${BUCKETNAME}
-      - S3_ENDPOINT=https://s3.us-west-2.amazonaws.com
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - 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=true # true for S3 alternative such as Minio
+      # See: https://jkaninda.github.io/mysql-bkup/reference/#predefined-schedules
+      - BACKUP_CRON_EXPRESSION=@daily #@every 5m|@weekly | @monthly |0 1 * * *
+      # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:

examples/docker-compose.yaml

@@ -3,14 +3,11 @@ services:
   mysql-bkup:
     image: jkaninda/mysql-bkup
     container_name: mysql-bkup
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup --dbname database_name
+    command: backup --dbname database_name
     volumes:
       - ./backup:/backup
     environment:
       - DB_PORT=3306
-      - DB_HOST=mysqlhost
+      - DB_HOST=mysql
       - DB_USERNAME=userName
       - DB_PASSWORD=${DB_PASSWORD}

examples/k8s-job.yaml

@@ -1,40 +1,49 @@
 apiVersion: batch/v1
-kind: CronJob
+kind: Job
 metadata:
-  name: db-bkup-job
+  name: backup
 spec:
-  schedule: "0 1 * * *"
-  jobTemplate:
+  template:
     spec:
-      template:
-        spec:
-          containers:
-          - name: mysql-bkup
-            image: jkaninda/mysql-bkup
-            securityContext:
-              privileged: true
-            command:
+      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
-            - bkup --operation backup --storage s3 --path /custom_path
-            env:
-              - name: DB_PORT
-                value: "3306" 
-              - name: DB_HOST
-                value: ""
-              - name: DB_NAME
-                value: ""
-              - name: DB_USERNAME
-                value: ""
-              # Please use secret!
-              - name: DB_PASSWORD
-                value: "password"
-              - name: ACCESS_KEY
-                value: ""
-              - name: SECRET_KEY
-                value: ""
-              - name: BUCKETNAME
-                value: ""
-              - name: S3_ENDPOINT
-                value: "https://s3.us-west-2.amazonaws.com"
-          restartPolicy: Never
+            - 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: "true"
+      restartPolicy: Never

go.mod

@@ -1,10 +1,39 @@
 module github.com/jkaninda/mysql-bkup
 
-go 1.21.0
+go 1.23.2
 
-require github.com/spf13/pflag v1.0.5
+require github.com/spf13/pflag v1.0.6 // indirect
 
 require (
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/spf13/cobra v1.8.0 // indirect
+	github.com/go-mail/mail v2.3.1+incompatible
+	github.com/jkaninda/encryptor v0.0.0-20241111100652-926393c9437e
+	github.com/jkaninda/go-storage v0.1.3
+	github.com/jkaninda/go-utils v0.1.1
+	github.com/robfig/cron/v3 v3.0.1
+	github.com/spf13/cobra v1.9.1
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+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 v1.1.0 // indirect
+	github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f // 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.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
+	github.com/jlaffaye/ftp v0.2.0 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	golang.org/x/crypto v0.28.0 // indirect
+	golang.org/x/net v0.29.0 // indirect
+	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
+	gopkg.in/mail.v2 v2.3.1 // indirect
 )

go.sum

@@ -1,10 +1,129 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+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/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.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/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=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+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-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.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
-github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
-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.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.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=
+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.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+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=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+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.5.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.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+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.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=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+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/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.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -1,222 +1,33 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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
 
-/*****
-*   MySQL Backup & Restore
-* @author    Jonas Kaninda
-* @license   MIT License <https://opensource.org/licenses/MIT>
-* @link      https://github.com/jkaninda/mysql-bkup
-**/
-import (
-	"fmt"
-	"github.com/jkaninda/mysql-bkup/pkg"
-	"github.com/jkaninda/mysql-bkup/utils"
-	flag "github.com/spf13/pflag"
-	"os"
-	"os/exec"
-)
+import "github.com/jkaninda/mysql-bkup/cmd"
 
-var appVersion string = os.Getenv("VERSION")
-
-const s3MountPath string = "/s3mnt"
-
-var (
-	operation          string = "backup"
-	storage            string = "local"
-	file               string = ""
-	s3Path             string = "/mysql-bkup"
-	dbName             string = ""
-	dbHost             string = ""
-	dbPort             string = ""
-	dbPassword         string = ""
-	dbUserName         string = ""
-	executionMode      string = "default"
-	storagePath        string = "/backup"
-	accessKey          string = ""
-	secretKey          string = ""
-	bucketName         string = ""
-	s3Endpoint         string = ""
-	s3fsPasswdFile     string = "/etc/passwd-s3fs"
-	disableCompression bool   = false
-	startBackup        bool   = true
-
-	timeout int    = 30
-	period  string = "0 1 * * *"
-)
-
-func init() {
-	var (
-		operationFlag          = flag.StringP("operation", "o", "backup", "Operation")
-		storageFlag            = flag.StringP("storage", "s", "local", "Storage, local or s3")
-		fileFlag               = flag.StringP("file", "f", "", "File name")
-		pathFlag               = flag.StringP("path", "P", "/mysql-bkup", "S3 path, without file name")
-		dbnameFlag             = flag.StringP("dbname", "d", "", "Database name")
-		modeFlag               = flag.StringP("mode", "m", "default", "Execution mode. default or scheduled")
-		periodFlag             = flag.StringP("period", "", "0 1 * * *", "Schedule period time")
-		timeoutFlag            = flag.IntP("timeout", "t", 30, "Timeout (in seconds) to stop database connexion")
-		disableCompressionFlag = flag.BoolP("disable-compression", "", false, "Disable backup compression")
-		portFlag               = flag.IntP("port", "p", 3306, "Database port")
-		helpFlag               = flag.BoolP("help", "h", false, "Print this help message")
-		versionFlag            = flag.BoolP("version", "v", false, "Version information")
-	)
-	flag.Parse()
-
-	operation = *operationFlag
-	storage = *storageFlag
-	file = *fileFlag
-	s3Path = *pathFlag
-	dbName = *dbnameFlag
-	executionMode = *modeFlag
-	dbPort = fmt.Sprint(*portFlag)
-	timeout = *timeoutFlag
-	period = *periodFlag
-	disableCompression = *disableCompressionFlag
-
-	flag.Usage = func() {
-		fmt.Print("MySQL BackupDatabase and Restoration tool. BackupDatabase database to AWS S3 storage or any S3 Alternatives for Object Storage.\n\n")
-		fmt.Print("Usage: bkup --operation backup -storage s3 --dbname databasename --path /my_path ...\n")
-		fmt.Print("       bkup -o backup -d databasename --disable-compression ...\n")
-		fmt.Print("       RestoreDatabase: bkup -o restore -d databasename -f db_20231217_051339.sql.gz ...\n\n")
-		flag.PrintDefaults()
-	}
-
-	if *helpFlag {
-		startBackup = false
-		flag.Usage()
-		os.Exit(0)
-	}
-	if *versionFlag {
-		startBackup = false
-		version()
-		os.Exit(0)
-	}
-	if *dbnameFlag != "" {
-		err := os.Setenv("DB_NAME", dbName)
-		if err != nil {
-			return
-		}
-	}
-	if *pathFlag != "" {
-		s3Path = *pathFlag
-		err := os.Setenv("S3_PATH", fmt.Sprint(*pathFlag))
-		if err != nil {
-			return
-		}
-
-	}
-	if *fileFlag != "" {
-		file = *fileFlag
-		err := os.Setenv("FILE_NAME", fmt.Sprint(*fileFlag))
-		if err != nil {
-			return
-		}
-
-	}
-	if *portFlag != 3306 {
-		err := os.Setenv("DB_PORT", fmt.Sprint(*portFlag))
-		if err != nil {
-			return
-		}
-	}
-	if *periodFlag != "" {
-		err := os.Setenv("SCHEDULE_PERIOD", fmt.Sprint(*periodFlag))
-		if err != nil {
-			return
-		}
-	}
-	if *storageFlag != "" {
-		err := os.Setenv("STORAGE", fmt.Sprint(*storageFlag))
-		if err != nil {
-			return
-		}
-	}
-	storage = os.Getenv("STORAGE")
-	err := os.Setenv("STORAGE_PATH", storagePath)
-	if err != nil {
-		return
-	}
-
-}
-
-func version() {
-	fmt.Printf("Version: %s \n", appVersion)
-	fmt.Print()
-}
 func main() {
-	//cmd.Execute()
 
-	err := os.Setenv("STORAGE_PATH", storagePath)
-	if err != nil {
-		return
-	}
-
-	if startBackup {
-		start()
-	}
+	cmd.Execute()
 
 }
-func start() {
-
-	if executionMode == "default" {
-		if operation != "backup" {
-			if storage != "s3" {
-				utils.Info("RestoreDatabase from local")
-				pkg.RestoreDatabase(file)
-			} else {
-				utils.Info("RestoreDatabase from s3")
-				s3Restore()
-			}
-		} else {
-			if storage != "s3" {
-				utils.Info("BackupDatabase to local storage")
-				pkg.BackupDatabase(disableCompression)
-			} else {
-				utils.Info("BackupDatabase to s3 storage")
-				s3Backup()
-			}
-		}
-	} else if executionMode == "scheduled" {
-		scheduledMode()
-	} else {
-		utils.Fatal("Error, unknown execution mode!")
-	}
-}
-
-func s3Backup() {
-	// Backup Database to S3 storage
-	pkg.MountS3Storage(s3Path)
-	pkg.BackupDatabase(disableCompression)
-}
-
-// Run in scheduled mode
-func scheduledMode() {
-	// Verify operation
-	if operation == "backup" {
-
-		fmt.Println()
-		fmt.Println("**********************************")
-		fmt.Println("     Starting MySQL Bkup...       ")
-		fmt.Println("***********************************")
-		utils.Info("Running in Scheduled mode")
-		utils.Info("Log file in /var/log/mysql-bkup.log")
-		utils.Info("Execution period ", os.Getenv("SCHEDULE_PERIOD"))
-
-		//Test database connexion
-		utils.TestDatabaseConnection()
-
-		utils.Info("Creating backup job...")
-		pkg.CreateCrontabScript(disableCompression, storage)
-
-		supervisordCmd := exec.Command("supervisord", "-c", "/etc/supervisor/supervisord.conf")
-		if err := supervisordCmd.Run(); err != nil {
-			utils.Fatalf("Error starting supervisord: %v\n", err)
-		}
-	} else {
-		utils.Fatal("Scheduled mode supports only backup operation")
-	}
-}
-
-func s3Restore() {
-	// Restore database from S3
-	pkg.MountS3Storage(s3Path)
-	pkg.RestoreDatabase(file)
-}

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

@@ -0,0 +1,128 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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/go-storage/pkg/azure"
+	goutils "github.com/jkaninda/go-utils"
+	"github.com/jkaninda/mysql-bkup/utils"
+
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func azureBackup(db *dbConfig, config *BackupConfig) {
+	utils.Info("Backup database to Azure Blob Storage")
+
+	// 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 Azure Blob storage ...")
+	utils.Info("Backup name is %s", finalFileName)
+	azureConfig := loadAzureConfig()
+	azureStorage, err := azure.NewStorage(azure.Config{
+		ContainerName: azureConfig.containerName,
+		AccountName:   azureConfig.accountName,
+		AccountKey:    azureConfig.accountKey,
+		RemotePath:    config.remotePath,
+		LocalPath:     tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating Azure storage: %s", err)
+	}
+	err = azureStorage.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 := azureStorage.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 Azure Blob storage ... 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)
+}
+func azureRestore(db *dbConfig, conf *RestoreConfig) {
+	utils.Info("Restore database from Azure Blob storage")
+	azureConfig := loadAzureConfig()
+	azureStorage, err := azure.NewStorage(azure.Config{
+		ContainerName: azureConfig.containerName,
+		AccountName:   azureConfig.accountName,
+		AccountKey:    azureConfig.accountKey,
+		RemotePath:    conf.remotePath,
+		LocalPath:     tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating SSH storage: %s", err)
+	}
+
+	err = azureStorage.CopyFrom(conf.file)
+	if err != nil {
+		utils.Fatal("Error downloading backup file: %s", err)
+	}
+	RestoreDatabase(db, conf)
+}

pkg/backup.go

@@ -1,102 +1,437 @@
-// Package pkg /*
+// Package internal /
 /*
-Copyright © 2024 Jonas Kaninda  <jonaskaninda.gmail.com>
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
-	"log"
+	"github.com/robfig/cron/v3"
+	"github.com/spf13/cobra"
 	"os"
 	"os/exec"
+	"path/filepath"
+	"strings"
 	"time"
 )
 
-var (
-	dbName      = ""
-	dbHost      = ""
-	dbPort      = ""
-	dbPassword  = ""
-	dbUserName  = ""
-	storagePath = "/backup"
-)
-
-// BackupDatabase backup database
-func BackupDatabase(disableCompression bool) {
-	dbHost = os.Getenv("DB_HOST")
-	dbPassword = os.Getenv("DB_PASSWORD")
-	dbUserName = os.Getenv("DB_USERNAME")
-	dbName = os.Getenv("DB_NAME")
-	dbPort = os.Getenv("DB_PORT")
-	storagePath = os.Getenv("STORAGE_PATH")
-
-	if os.Getenv("DB_HOST") == "" || os.Getenv("DB_NAME") == "" || os.Getenv("DB_USERNAME") == "" || os.Getenv("DB_PASSWORD") == "" {
-		utils.Fatal("Please make sure all required environment variables for database are set")
+func StartBackup(cmd *cobra.Command) {
+	intro()
+	// Initialize backup configs
+	config := initBackupConfig(cmd)
+	// Load backup configuration file
+	configFile, err := loadConfigFile()
+	if err != nil {
+		dbConf = initDbConfig(cmd)
+		if config.cronExpression == "" {
+			config.allowCustomName = true
+			createBackupTask(dbConf, config)
+		} else {
+			if utils.IsValidCronExpression(config.cronExpression) {
+				scheduledMode(dbConf, config)
+			} else {
+				utils.Fatal("Cron expression is not valid: %s", config.cronExpression)
+			}
+		}
 	} else {
-		utils.TestDatabaseConnection()
-		// Backup Database database
-		utils.Info("Backing up database...")
-		bkFileName := fmt.Sprintf("%s_%s.sql.gz", dbName, time.Now().Format("20060102_150405"))
+		startMultiBackup(config, configFile)
+	}
 
-		if disableCompression {
-			bkFileName = fmt.Sprintf("%s_%s.sql", dbName, time.Now().Format("20060102_150405"))
-			cmd := exec.Command("mysqldump",
-				"-h", dbHost,
-				"-P", dbPort,
-				"-u", dbUserName,
-				"--password="+dbPassword,
-				dbName,
-			)
-			output, err := cmd.Output()
-			if err != nil {
-				log.Fatal(err)
-			}
+}
 
-			file, err := os.Create(fmt.Sprintf("%s/%s", storagePath, bkFileName))
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer file.Close()
+// scheduledMode Runs backup in scheduled mode
+func scheduledMode(db *dbConfig, config *BackupConfig) {
+	utils.Info("Running in Scheduled mode")
+	utils.Info("Backup cron expression:  %s", config.cronExpression)
+	utils.Info("The next scheduled time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
+	utils.Info("Storage type %s ", config.storage)
 
-			_, err = file.Write(output)
-			if err != nil {
-				log.Fatal(err)
+	// Test backup
+	utils.Info("Testing backup configurations...")
+	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() {
+		createBackupTask(db, config)
+		utils.Info("Next backup time is: %v", utils.CronNextTime(config.cronExpression).Format(timeFormat))
+
+	})
+	if err != nil {
+		return
+	}
+	// Start the cron scheduler
+	c.Start()
+	utils.Info("Creating backup job...done")
+	utils.Info("Backup job started")
+	defer c.Stop()
+	select {}
+}
+
+// multiBackupTask backup multi database
+func multiBackupTask(databases []Database, bkConfig *BackupConfig) {
+	for _, db := range databases {
+		// Check if path is defined in config file
+		if db.Path != "" {
+			bkConfig.remotePath = db.Path
+		}
+		createBackupTask(getDatabase(db), bkConfig)
+	}
+}
+
+// createBackupTask backup task
+func createBackupTask(db *dbConfig, config *BackupConfig) {
+	if config.all && !config.allInOne {
+		backupAll(db, config)
+	} else {
+		if db.dbName == "" && !config.all {
+			utils.Fatal("Database name is required, use DB_NAME environment variable or -d flag")
+		}
+		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", prefix, time.Now().Format("20060102_150405"))
+	if config.disableCompression {
+		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
+	s := strings.ToLower(config.storage)
+	switch s {
+	case "local":
+		localBackup(db, config)
+	case "s3":
+		s3Backup(db, config)
+	case "ssh", "remote", "sftp":
+		sshBackup(db, config)
+	case "ftp":
+		ftpBackup(db, config)
+	case "azure":
+		azureBackup(db, config)
+	default:
+		localBackup(db, config)
+	}
+}
+
+// startMultiBackup start multi backup
+func startMultiBackup(bkConfig *BackupConfig, configFile string) {
+	utils.Info("Starting Multi backup task...")
+	conf, err := readConf(configFile)
+	if err != nil {
+		utils.Fatal("Error reading config file: %s", err)
+	}
+	// Check if cronExpression is defined in config file
+	if conf.CronExpression != "" {
+		bkConfig.cronExpression = conf.CronExpression
+	}
+	if len(conf.Databases) == 0 {
+		utils.Fatal("No databases found")
+	}
+	// Check if cronExpression is defined
+	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")
+			utils.Info("Backup cron expression:  %s", bkConfig.cronExpression)
+			utils.Info("The next scheduled time is: %v", utils.CronNextTime(bkConfig.cronExpression).Format(timeFormat))
+			utils.Info("Storage type %s ", bkConfig.storage)
+
+			// Test backup
+			utils.Info("Testing backup configurations...")
+			for _, db := range conf.Databases {
+				err = testDatabaseConnection(getDatabase(db))
+				if err != nil {
+					recoverMode(err, fmt.Sprintf("Error connecting to database: %s", db.Name))
+					continue
+				}
 			}
-			utils.Info("Database has been backed up")
+			utils.Info("Testing backup configurations...done")
+			utils.Info("Creating backup job...")
+			// Create a new cron instance
+			c := cron.New()
+
+			_, err := c.AddFunc(bkConfig.cronExpression, func() {
+				multiBackupTask(conf.Databases, bkConfig)
+				utils.Info("Next backup time is: %v", utils.CronNextTime(bkConfig.cronExpression).Format(timeFormat))
+
+			})
+			if err != nil {
+				return
+			}
+			// Start the cron scheduler
+			c.Start()
+			utils.Info("Creating backup job...done")
+			utils.Info("Backup job started")
+			defer c.Stop()
+			select {}
 
 		} else {
-			cmd := exec.Command("mysqldump", "-h", dbHost, "-P", dbPort, "-u", dbUserName, "--password="+dbPassword, dbName)
-			stdout, err := cmd.StdoutPipe()
-			if err != nil {
-				utils.Info("Mysql")
-
-				log.Fatal(err)
-			}
-			gzipCmd := exec.Command("gzip")
-			gzipCmd.Stdin = stdout
-			gzipCmd.Stdout, err = os.Create(fmt.Sprintf("%s/%s", storagePath, bkFileName))
-			gzipCmd.Start()
-			if err != nil {
-				log.Fatal(err)
-			}
-			if err := cmd.Run(); err != nil {
-				log.Fatal(err)
-			}
-			if err := gzipCmd.Wait(); err != nil {
-				log.Fatal(err)
-			}
-			utils.Info("Database has been backed up")
-
-		}
-
-		historyFile, err := os.OpenFile(fmt.Sprintf("%s/history.txt", storagePath), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer historyFile.Close()
-		if _, err := historyFile.WriteString(bkFileName + "\n"); err != nil {
-			log.Fatal(err)
+			utils.Fatal("Cron expression is not valid: %s", bkConfig.cronExpression)
+		}
+	}
+
+}
+
+// BackupDatabase backup database
+func BackupDatabase(db *dbConfig, backupFileName string, disableCompression, all, singleFile bool) error {
+	storagePath = os.Getenv("STORAGE_PATH")
+	utils.Info("Starting database backup...")
+
+	if err := testDatabaseConnection(db); err != nil {
+		return fmt.Errorf("database connection failed: %w", err)
+	}
+
+	dumpArgs := []string{fmt.Sprintf("--defaults-file=%s", mysqlClientConfig)}
+	if all && singleFile {
+		utils.Info("Backing up all databases...")
+		dumpArgs = append(dumpArgs, "--all-databases", "--single-transaction", "--routines", "--triggers")
+	} else {
+		utils.Info("Backing up %s database...", db.dbName)
+		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")
+	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, gpgExtension)
+	}
+	fileInfo, err := os.Stat(filepath.Join(tmpPath, finalFileName))
+	if err != nil {
+		utils.Error("Error: %s", err)
+	}
+	backupSize = fileInfo.Size()
+	localStorage := local.NewStorage(local.Config{
+		LocalPath:  tmpPath,
+		RemotePath: storagePath,
+	})
+	err = localStorage.Copy(finalFileName)
+	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:     utils.ConvertBytes(uint64(backupSize)),
+		Database:       db.dbName,
+		Storage:        config.storage,
+		BackupLocation: filepath.Join(storagePath, finalFileName),
+		Duration:       duration,
+	})
+	// Delete old backup
+	if config.prune {
+		err = localStorage.Prune(config.backupRetention)
+		if err != nil {
+			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+		}
+
+	}
+	// Delete temp
+	deleteTemp()
+	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)
+	if err != nil {
+		utils.Fatal("Error reading backup file: %s ", err)
+	}
+	if config.usingKey {
+		utils.Info("Encrypting backup using public key...")
+		pubKey, err := os.ReadFile(config.publicKey)
+		if err != nil {
+			utils.Fatal("Error reading public key: %s ", err)
+		}
+		err = encryptor.EncryptWithPublicKey(backupFile, fmt.Sprintf("%s.%s", filepath.Join(tmpPath, config.backupFileName), gpgExtension), pubKey)
+		if err != nil {
+			utils.Fatal("Error encrypting backup file: %v ", err)
+		}
+		utils.Info("Encrypting backup using public key...done")
+
+	} else if config.passphrase != "" {
+		utils.Info("Encrypting backup using passphrase...")
+		err := encryptor.Encrypt(backupFile, outputFile, config.passphrase)
+		if err != nil {
+			utils.Fatal("error during encrypting backup %v", err)
+		}
+		utils.Info("Encrypting backup using passphrase...done")
+
+	}
+
+}
+
+// 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

@@ -0,0 +1,363 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type Database struct {
+	Host     string `yaml:"host"`
+	Port     string `yaml:"port"`
+	Name     string `yaml:"name"`
+	User     string `yaml:"user"`
+	Password string `yaml:"password"`
+	Path     string `yaml:"path"`
+}
+type Config struct {
+	CronExpression   string     `yaml:"cronExpression"`
+	BackupRescueMode bool       `yaml:"backupRescueMode"`
+	Databases        []Database `yaml:"databases"`
+}
+
+type dbConfig struct {
+	dbHost     string
+	dbPort     string
+	dbName     string
+	dbUserName string
+	dbPassword string
+}
+type targetDbConfig struct {
+	targetDbHost     string
+	targetDbPort     string
+	targetDbUserName string
+	targetDbPassword string
+	targetDbName     string
+}
+type TgConfig struct {
+	Token  string
+	ChatId string
+}
+type BackupConfig struct {
+	backupFileName     string
+	backupRetention    int
+	disableCompression bool
+	prune              bool
+	remotePath         string
+	encryption         bool
+	usingKey           bool
+	passphrase         string
+	publicKey          string
+	storage            string
+	cronExpression     string
+	all                bool
+	allInOne           bool
+	customName         string
+	allowCustomName    bool
+}
+type FTPConfig struct {
+	host       string
+	user       string
+	password   string
+	port       int
+	remotePath string
+}
+type AzureConfig struct {
+	accountName   string
+	accountKey    string
+	containerName string
+}
+
+// SSHConfig holds the SSH connection details
+type SSHConfig struct {
+	user         string
+	password     string
+	hostName     string
+	port         int
+	identifyFile string
+}
+type AWSConfig struct {
+	endpoint       string
+	bucket         string
+	accessKey      string
+	secretKey      string
+	region         string
+	remotePath     string
+	disableSsl     bool
+	forcePathStyle bool
+}
+
+func initDbConfig(cmd *cobra.Command) *dbConfig {
+	// Set env
+	utils.GetEnv(cmd, "dbname", "DB_NAME")
+	dConf := dbConfig{}
+	dConf.dbHost = os.Getenv("DB_HOST")
+	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")
+
+	err := utils.CheckEnvVars(dbHVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for database are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
+	return &dConf
+}
+
+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,
+		dbName:     database.Name,
+		dbUserName: database.User,
+		dbPassword: database.Password,
+	}
+}
+
+// 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")
+	sshVars := []string{"SSH_USER", "SSH_HOST", "SSH_PORT", "REMOTE_PATH"}
+	err := utils.CheckEnvVars(sshVars)
+	if err != nil {
+		return nil, fmt.Errorf("error missing environment variables: %w", err)
+	}
+
+	return &SSHConfig{
+		user:         os.Getenv("SSH_USER"),
+		password:     os.Getenv("SSH_PASSWORD"),
+		hostName:     os.Getenv("SSH_HOST"),
+		port:         utils.GetIntEnv("SSH_PORT"),
+		identifyFile: os.Getenv("SSH_IDENTIFY_FILE"),
+	}, nil
+}
+func loadFtpConfig() *FTPConfig {
+	// Initialize data configs
+	fConfig := FTPConfig{}
+	fConfig.host = utils.GetEnvVariable("FTP_HOST", "FTP_HOST_NAME")
+	fConfig.user = os.Getenv("FTP_USER")
+	fConfig.password = os.Getenv("FTP_PASSWORD")
+	fConfig.port = utils.GetIntEnv("FTP_PORT")
+	fConfig.remotePath = os.Getenv("REMOTE_PATH")
+	err := utils.CheckEnvVars(ftpVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for FTP are set")
+		utils.Fatal("Error missing environment variables: %s", err)
+	}
+	return &fConfig
+}
+func loadAzureConfig() *AzureConfig {
+	// Initialize data configs
+	aConfig := AzureConfig{}
+	aConfig.containerName = os.Getenv("AZURE_STORAGE_CONTAINER_NAME")
+	aConfig.accountName = os.Getenv("AZURE_STORAGE_ACCOUNT_NAME")
+	aConfig.accountKey = os.Getenv("AZURE_STORAGE_ACCOUNT_KEY")
+
+	err := utils.CheckEnvVars(azureVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for Azure Blob storage are set")
+		utils.Fatal("Error missing environment variables: %s", err)
+	}
+	return &aConfig
+}
+
+func initAWSConfig() *AWSConfig {
+	// Initialize AWS configs
+	aConfig := AWSConfig{}
+	aConfig.endpoint = utils.GetEnvVariable("AWS_S3_ENDPOINT", "S3_ENDPOINT")
+	aConfig.accessKey = utils.GetEnvVariable("AWS_ACCESS_KEY", "ACCESS_KEY")
+	aConfig.secretKey = utils.GetEnvVariable("AWS_SECRET_KEY", "SECRET_KEY")
+	aConfig.bucket = utils.GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+	aConfig.remotePath = utils.GetEnvVariable("AWS_S3_PATH", "S3_PATH")
+
+	aConfig.region = os.Getenv("AWS_REGION")
+	disableSsl, err := strconv.ParseBool(os.Getenv("AWS_DISABLE_SSL"))
+	if err != nil {
+		disableSsl = false
+	}
+	forcePathStyle, err := strconv.ParseBool(os.Getenv("AWS_FORCE_PATH_STYLE"))
+	if err != nil {
+		forcePathStyle = false
+	}
+	aConfig.disableSsl = disableSsl
+	aConfig.forcePathStyle = forcePathStyle
+	err = utils.CheckEnvVars(awsVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for AWS S3 are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
+	return &aConfig
+}
+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")
+	// Get flag value and set env
+	remotePath := utils.GetEnvVariable("REMOTE_PATH", "SSH_REMOTE_PATH")
+	storage = utils.GetEnv(cmd, "storage", "STORAGE")
+	prune := false
+	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")
+	cronExpression := os.Getenv("BACKUP_CRON_EXPRESSION")
+
+	publicKeyFile, err := checkPubKeyFile(os.Getenv("GPG_PUBLIC_KEY"))
+	if err == nil {
+		encryption = true
+		usingKey = true
+	} else if passphrase != "" {
+		encryption = true
+		usingKey = false
+	}
+	// Initialize backup configs
+	config := BackupConfig{}
+	config.backupRetention = backupRetention
+	config.disableCompression = disableCompression
+	config.prune = prune
+	config.storage = storage
+	config.encryption = encryption
+	config.remotePath = remotePath
+	config.passphrase = passphrase
+	config.publicKey = publicKeyFile
+	config.usingKey = usingKey
+	config.cronExpression = cronExpression
+	config.all = all
+	config.allInOne = allInOne
+	config.customName = customName
+	return &config
+}
+
+type RestoreConfig struct {
+	s3Path     string
+	remotePath string
+	storage    string
+	file       string
+	bucket     string
+	usingKey   bool
+	passphrase string
+	privateKey string
+}
+
+func initRestoreConfig(cmd *cobra.Command) *RestoreConfig {
+	utils.SetEnv("STORAGE_PATH", storagePath)
+	utils.GetEnv(cmd, "path", "REMOTE_PATH")
+
+	// Get flag value and set env
+	s3Path := utils.GetEnv(cmd, "path", "AWS_S3_PATH")
+	remotePath := utils.GetEnvVariable("REMOTE_PATH", "SSH_REMOTE_PATH")
+	storage = utils.GetEnv(cmd, "storage", "STORAGE")
+	file = utils.GetEnv(cmd, "file", "FILE_NAME")
+	bucket := utils.GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+	passphrase := os.Getenv("GPG_PASSPHRASE")
+	privateKeyFile, err := checkPrKeyFile(os.Getenv("GPG_PRIVATE_KEY"))
+	if err == nil {
+		usingKey = true
+	} else if passphrase != "" {
+		usingKey = false
+	}
+
+	// Initialize restore configs
+	rConfig := RestoreConfig{}
+	rConfig.s3Path = s3Path
+	rConfig.remotePath = remotePath
+	rConfig.storage = storage
+	rConfig.bucket = bucket
+	rConfig.file = file
+	rConfig.storage = storage
+	rConfig.passphrase = passphrase
+	rConfig.usingKey = usingKey
+	rConfig.privateKey = privateKeyFile
+	return &rConfig
+}
+func initTargetDbConfig() *targetDbConfig {
+	tdbConfig := targetDbConfig{}
+	tdbConfig.targetDbHost = os.Getenv("TARGET_DB_HOST")
+	tdbConfig.targetDbPort = utils.EnvWithDefault("TARGET_DB_PORT", "3306")
+	tdbConfig.targetDbName = os.Getenv("TARGET_DB_NAME")
+	tdbConfig.targetDbUserName = os.Getenv("TARGET_DB_USERNAME")
+	tdbConfig.targetDbPassword = os.Getenv("TARGET_DB_PASSWORD")
+
+	err := utils.CheckEnvVars(tdbRVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for the target database are set")
+		utils.Fatal("Error checking target database environment variables: %s", err)
+	}
+	return &tdbConfig
+}
+func loadConfigFile() (string, error) {
+	backupConfigFile, err := checkConfigFile(os.Getenv("BACKUP_CONFIG_FILE"))
+	if err == nil {
+		return backupConfigFile, nil
+	}
+	return "", fmt.Errorf("backup config file not found")
+}

pkg/helper.go

@@ -0,0 +1,203 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func intro() {
+	fmt.Println("Starting MYSQL-BKUP...")
+	fmt.Printf("Version: %s\n", utils.Version)
+	fmt.Println("Copyright (c) 2024 Jonas Kaninda")
+}
+
+// copyToTmp copy file to temporary directory
+func deleteTemp() {
+	utils.Info("Deleting %s ...", tmpPath)
+	err := filepath.Walk(tmpPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// Check if the current item is a file
+		if !info.IsDir() {
+			// Delete the file
+			err = os.Remove(path)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		utils.Error("Error deleting files: %v", err)
+	} else {
+		utils.Info("Deleting %s ... done", tmpPath)
+	}
+}
+
+// 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)
+	// 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
+
+	// 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)
+	return nil
+}
+
+// checkPubKeyFile checks gpg public key
+func checkPubKeyFile(pubKey string) (string, error) {
+	// Define possible key file names
+	keyFiles := []string{filepath.Join(gpgHome, "public_key.asc"), filepath.Join(gpgHome, "public_key.gpg"), pubKey}
+
+	// Loop through key file names and check if they exist
+	for _, keyFile := range keyFiles {
+		if _, err := os.Stat(keyFile); err == nil {
+			// File exists
+			return keyFile, nil
+		} else if os.IsNotExist(err) {
+			// File does not exist, continue to the next one
+			continue
+		} else {
+			// An unexpected error occurred
+			return "", err
+		}
+	}
+
+	// Return an error if neither file exists
+	return "", fmt.Errorf("no public key file found")
+}
+
+// checkPrKeyFile checks private key
+func checkPrKeyFile(prKey string) (string, error) {
+	// Define possible key file names
+	keyFiles := []string{filepath.Join(gpgHome, "private_key.asc"), filepath.Join(gpgHome, "private_key.gpg"), prKey}
+
+	// Loop through key file names and check if they exist
+	for _, keyFile := range keyFiles {
+		if _, err := os.Stat(keyFile); err == nil {
+			// File exists
+			return keyFile, nil
+		} else if os.IsNotExist(err) {
+			// File does not exist, continue to the next one
+			continue
+		} else {
+			// An unexpected error occurred
+			return "", err
+		}
+	}
+
+	// Return an error if neither file exists
+	return "", fmt.Errorf("no public key file found")
+}
+
+// readConf reads config file and returns Config
+func readConf(configFile string) (*Config, error) {
+	if utils.FileExists(configFile) {
+		buf, err := os.ReadFile(configFile)
+		if err != nil {
+			return nil, err
+		}
+
+		c := &Config{}
+		err = yaml.Unmarshal(buf, c)
+		if err != nil {
+			return nil, fmt.Errorf("in file %q: %w", configFile, err)
+		}
+
+		return c, err
+	}
+	return nil, fmt.Errorf("config file %q not found", configFile)
+}
+
+// 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}
+
+	// Loop through config file names and check if they exist
+	for _, configFile := range configFiles {
+		if _, err := os.Stat(configFile); err == nil {
+			// File exists
+			return configFile, nil
+		} else if os.IsNotExist(err) {
+			// File does not exist, continue to the next one
+			continue
+		} else {
+			// An unexpected error occurred
+			return "", err
+		}
+	}
+
+	// Return an error if neither file exists
+	return "", fmt.Errorf("no config file found")
+}
+func RemoveLastExtension(filename string) string {
+	if idx := strings.LastIndex(filename, "."); idx != -1 {
+		return filename[:idx]
+	}
+	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

@@ -0,0 +1,63 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"time"
+)
+
+func StartMigration(cmd *cobra.Command) {
+	intro()
+	utils.Info("Starting database migration...")
+	// Get DB config
+	dbConf = initDbConfig(cmd)
+	targetDbConf = initTargetDbConfig()
+
+	// Defining the target database variables
+	newDbConfig := dbConfig{}
+	newDbConfig.dbHost = targetDbConf.targetDbHost
+	newDbConfig.dbPort = targetDbConf.targetDbPort
+	newDbConfig.dbName = targetDbConf.targetDbName
+	newDbConfig.dbUserName = targetDbConf.targetDbUserName
+	newDbConfig.dbPassword = targetDbConf.targetDbPassword
+
+	// Generate file name
+	backupFileName := fmt.Sprintf("%s_%s.sql", dbConf.dbName, time.Now().Format("20060102_150405"))
+	conf := &RestoreConfig{}
+	conf.file = backupFileName
+	// Backup source Database
+	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)
+	utils.Info("[%s] database has been restored into [%s] database", dbConf.dbName, targetDbConf.targetDbName)
+	utils.Info("Database migration completed.")
+}

pkg/remote.go

@@ -0,0 +1,228 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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/go-storage/pkg/ftp"
+	"github.com/jkaninda/go-storage/pkg/ssh"
+	goutils "github.com/jkaninda/go-utils"
+	"github.com/jkaninda/mysql-bkup/utils"
+
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func sshBackup(db *dbConfig, config *BackupConfig) {
+	utils.Info("Backup database to Remote 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 remote storage ... ")
+	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,
+		IdentifyFile: sshConfig.identifyFile,
+		RemotePath:   config.remotePath,
+		LocalPath:    tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating SSH storage: %s", err)
+	}
+	err = sshStorage.Copy(finalFileName)
+	if err != nil {
+		utils.Fatal("Error copying backup file: %s", err)
+	}
+	// Get backup info
+	fileInfo, err := os.Stat(filepath.Join(tmpPath, finalFileName))
+	if err != nil {
+		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
+	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
+	if err != nil {
+		utils.Error("Error deleting file: %v", err)
+
+	}
+	if config.prune {
+		err := sshStorage.Prune(config.backupRetention)
+		if err != nil {
+			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+		}
+
+	}
+	utils.Info("Uploading backup archive to remote storage ... 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)
+
+}
+func remoteRestore(db *dbConfig, conf *RestoreConfig) {
+	utils.Info("Restore database from remote server")
+	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,
+		IdentifyFile: sshConfig.identifyFile,
+		RemotePath:   conf.remotePath,
+		LocalPath:    tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating SSH storage: %s", err)
+	}
+	err = sshStorage.CopyFrom(conf.file)
+	if err != nil {
+		utils.Fatal("Error copying backup file: %s", err)
+	}
+	RestoreDatabase(db, conf)
+}
+func ftpRestore(db *dbConfig, conf *RestoreConfig) {
+	utils.Info("Restore database from FTP server")
+	ftpConfig := loadFtpConfig()
+	ftpStorage, err := ftp.NewStorage(ftp.Config{
+		Host:       ftpConfig.host,
+		Port:       ftpConfig.port,
+		User:       ftpConfig.user,
+		Password:   ftpConfig.password,
+		RemotePath: conf.remotePath,
+		LocalPath:  tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating SSH storage: %s", err)
+	}
+	err = ftpStorage.CopyFrom(conf.file)
+	if err != nil {
+		utils.Fatal("Error copying backup file: %s", err)
+	}
+	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,56 +1,153 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
+	"github.com/spf13/cobra"
 	"os"
 	"os/exec"
 	"path/filepath"
 )
 
-// RestoreDatabase restore database
-func RestoreDatabase(file string) {
-	dbHost = os.Getenv("DB_HOST")
-	dbPassword = os.Getenv("DB_PASSWORD")
-	dbUserName = os.Getenv("DB_USERNAME")
-	dbName = os.Getenv("DB_NAME")
-	dbPort = os.Getenv("DB_PORT")
-	storagePath = os.Getenv("STORAGE_PATH")
-
-	if os.Getenv("DB_HOST") == "" || os.Getenv("DB_NAME") == "" || os.Getenv("DB_USERNAME") == "" || os.Getenv("DB_PASSWORD") == "" || file == "" {
-		utils.Fatal("Please make sure all required environment variables are set")
-	} else {
-
-		if utils.FileExists(fmt.Sprintf("%s/%s", storagePath, file)) {
-			utils.TestDatabaseConnection()
-
-			extension := filepath.Ext(fmt.Sprintf("%s/%s", storagePath, file))
-			// GZ compressed file
-			if extension == ".gz" {
-				str := "zcat " + fmt.Sprintf("%s/%s", storagePath, file) + " | mysql -h " + os.Getenv("DB_HOST") + " -P " + os.Getenv("DB_PORT") + " -u " + os.Getenv("DB_USERNAME") + " --password=" + os.Getenv("DB_PASSWORD") + " " + os.Getenv("DB_NAME")
-				_, err := exec.Command("bash", "-c", str).Output()
-				if err != nil {
-					utils.Fatal("Error, in restoring the database")
-				}
-
-				utils.Info("Database has been restored")
-
-			} else if extension == ".sql" {
-				//SQL file
-				str := "cat " + fmt.Sprintf("%s/%s", storagePath, file) + " | mysql -h " + os.Getenv("DB_HOST") + " -P " + os.Getenv("DB_PORT") + " -u " + os.Getenv("DB_USERNAME") + " --password=" + os.Getenv("DB_PASSWORD") + " " + os.Getenv("DB_NAME")
-				_, err := exec.Command("bash", "-c", str).Output()
-				if err != nil {
-					utils.Fatal("Error, in restoring the database", err)
-				}
-
-				utils.Info("Database has been restored")
-			} else {
-				utils.Fatal("Unknown file extension ", extension)
-			}
-
-		} else {
-			utils.Fatal("File not found in ", fmt.Sprintf("%s/%s", storagePath, file))
-		}
+func StartRestore(cmd *cobra.Command) {
+	intro()
+	dbConf = initDbConfig(cmd)
+	restoreConf := initRestoreConfig(cmd)
 
+	switch restoreConf.storage {
+	case "local":
+		localRestore(dbConf, restoreConf)
+	case "s3", "S3":
+		s3Restore(dbConf, restoreConf)
+	case "ssh", "SSH", "remote":
+		remoteRestore(dbConf, restoreConf)
+	case "ftp", "FTP":
+		ftpRestore(dbConf, restoreConf)
+	case "azure":
+		azureRestore(dbConf, restoreConf)
+	default:
+		localRestore(dbConf, restoreConf)
 	}
 }
+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: basePath,
+		LocalPath:  tmpPath,
+	})
+	err := localStorage.CopyFrom(fileName)
+	if err != nil {
+		utils.Fatal("Error copying backup file: %s", err)
+	}
+	RestoreDatabase(dbConf, restoreConf)
+
+}
+
+// RestoreDatabase restores the database from a backup file
+func RestoreDatabase(db *dbConfig, conf *RestoreConfig) {
+	if conf.file == "" {
+		utils.Fatal("Error, file required")
+	}
+
+	filePath := filepath.Join(tmpPath, conf.file)
+	rFile, err := os.ReadFile(filePath)
+	if err != nil {
+		utils.Fatal("Error reading backup file: %v", err)
+	}
+
+	extension := filepath.Ext(filePath)
+	outputFile := RemoveLastExtension(filePath)
+
+	if extension == ".gpg" {
+		decryptBackup(conf, rFile, outputFile)
+	}
+
+	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 {
+			utils.Fatal("Error reading private key: %v", err)
+		}
+		if err := encryptor.DecryptWithPrivateKey(rFile, outputFile, prKey, conf.passphrase); err != nil {
+			utils.Fatal("Error decrypting backup: %v", err)
+		}
+	} else {
+		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

@@ -0,0 +1,138 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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/go-storage/pkg/s3"
+	goutils "github.com/jkaninda/go-utils"
+	"github.com/jkaninda/mysql-bkup/utils"
+
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func s3Backup(db *dbConfig, config *BackupConfig) {
+
+	utils.Info("Backup database to s3 storage")
+	// 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 remote storage S3 ... ")
+	awsConfig := initAWSConfig()
+	if config.remotePath == "" {
+		config.remotePath = awsConfig.remotePath
+	}
+	utils.Info("Backup name is %s", finalFileName)
+	s3Storage, err := s3.NewStorage(s3.Config{
+		Endpoint:       awsConfig.endpoint,
+		Bucket:         awsConfig.bucket,
+		AccessKey:      awsConfig.accessKey,
+		SecretKey:      awsConfig.secretKey,
+		Region:         awsConfig.region,
+		DisableSsl:     awsConfig.disableSsl,
+		ForcePathStyle: awsConfig.forcePathStyle,
+		RemotePath:     config.remotePath,
+		LocalPath:      tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating s3 storage: %s", err)
+	}
+	err = s3Storage.Copy(finalFileName)
+	if err != nil {
+		utils.Fatal("Error copying backup file: %s", err)
+	}
+	// 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, config.backupFileName))
+	if err != nil {
+		fmt.Println("Error deleting file: ", err)
+
+	}
+	// Delete old backup
+	if config.prune {
+		err := s3Storage.Prune(config.backupRetention)
+		if err != nil {
+			utils.Fatal("Error deleting old backup from %s storage: %s ", config.storage, err)
+		}
+	}
+	utils.Info("Backup saved in %s", filepath.Join(config.remotePath, finalFileName))
+	utils.Info("Uploading backup archive to remote storage S3 ... done ")
+	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)
+
+}
+func s3Restore(db *dbConfig, conf *RestoreConfig) {
+	utils.Info("Restore database from s3")
+	awsConfig := initAWSConfig()
+	if conf.remotePath == "" {
+		conf.remotePath = awsConfig.remotePath
+	}
+	s3Storage, err := s3.NewStorage(s3.Config{
+		Endpoint:       awsConfig.endpoint,
+		Bucket:         awsConfig.bucket,
+		AccessKey:      awsConfig.accessKey,
+		SecretKey:      awsConfig.secretKey,
+		Region:         awsConfig.region,
+		DisableSsl:     awsConfig.disableSsl,
+		ForcePathStyle: awsConfig.forcePathStyle,
+		RemotePath:     conf.remotePath,
+		LocalPath:      tmpPath,
+	})
+	if err != nil {
+		utils.Fatal("Error creating s3 storage: %s", err)
+	}
+	err = s3Storage.CopyFrom(conf.file)
+	if err != nil {
+		utils.Fatal("Error download file from S3 storage: %s", err)
+	}
+	RestoreDatabase(db, conf)
+}

pkg/s3fs.go

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

pkg/scripts.go

@@ -1,76 +0,0 @@
-package pkg
-
-// Package pkg /*
-/*
-Copyright © 2024 Jonas Kaninda  <jonaskaninda.gmail.com>
-*/
-import (
-	"fmt"
-	"github.com/jkaninda/mysql-bkup/utils"
-	"os"
-	"os/exec"
-)
-
-const cronLogFile = "/var/log/mysql-bkup.log"
-const backupCronFile = "/usr/local/bin/backup_cron.sh"
-
-func CreateCrontabScript(disableCompression bool, storage string) {
-	//task := "/usr/local/bin/backup_cron.sh"
-	touchCmd := exec.Command("touch", backupCronFile)
-	if err := touchCmd.Run(); err != nil {
-		utils.Fatalf("Error creating file %s: %v\n", backupCronFile, err)
-	}
-	var disableC = ""
-	if disableCompression {
-		disableC = "--disable-compression"
-	}
-
-	var scriptContent string
-
-	if storage == "s3" {
-		scriptContent = fmt.Sprintf(`#!/usr/bin/env bash
-set -e
-bkup --operation backup --dbname %s --port %s --storage s3 --path %s %v
-`, os.Getenv("DB_NAME"), os.Getenv("DB_PORT"), os.Getenv("S3_PATH"), disableC)
-	} else {
-		scriptContent = fmt.Sprintf(`#!/usr/bin/env bash
-set -e
-bkup --operation backup --dbname %s --port %s %v
-`, os.Getenv("DB_NAME"), os.Getenv("DB_PORT"), disableC)
-	}
-
-	if err := utils.WriteToFile(backupCronFile, scriptContent); err != nil {
-		utils.Fatalf("Error writing to %s: %v\n", backupCronFile, err)
-	}
-
-	chmodCmd := exec.Command("chmod", "+x", "/usr/local/bin/backup_cron.sh")
-	if err := chmodCmd.Run(); err != nil {
-		utils.Fatalf("Error changing permissions of %s: %v\n", backupCronFile, err)
-	}
-
-	lnCmd := exec.Command("ln", "-s", "/usr/local/bin/backup_cron.sh", "/usr/local/bin/backup_cron")
-	if err := lnCmd.Run(); err != nil {
-		utils.Fatalf("Error creating symbolic link: %v\n", err)
-
-	}
-
-	cronJob := "/etc/cron.d/backup_cron"
-	touchCronCmd := exec.Command("touch", cronJob)
-	if err := touchCronCmd.Run(); err != nil {
-		utils.Fatalf("Error creating file %s: %v\n", cronJob, err)
-	}
-
-	cronContent := fmt.Sprintf(`%s root exec /bin/bash -c ". /run/supervisord.env; /usr/local/bin/backup_cron.sh >> %s"
-`, os.Getenv("SCHEDULE_PERIOD"), cronLogFile)
-
-	if err := utils.WriteToFile(cronJob, cronContent); err != nil {
-		utils.Fatalf("Error writing to %s: %v\n", cronJob, err)
-	}
-	utils.ChangePermission("/etc/cron.d/backup_cron", 0644)
-
-	crontabCmd := exec.Command("crontab", "/etc/cron.d/backup_cron")
-	if err := crontabCmd.Run(); err != nil {
-		utils.Fatal("Error updating crontab: ", err)
-	}
-	utils.Info("Starting backup in scheduled mode")
-}

pkg/var.go

@@ -0,0 +1,87 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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"
+const timeFormat = "2006-01-02 at 15:04:05"
+
+var (
+	storage = "local"
+	file    = ""
+
+	storagePath              = "/backup"
+	workingDir               = "/config"
+	disableCompression       = false
+	encryption               = false
+	usingKey                 = false
+	backupSize         int64 = 0
+	startTime                = time.Now()
+	backupRescueMode         = false
+	mysqlClientConfig        = filepath.Join(tmpPath, "my.cnf")
+)
+
+// dbHVars Required environment variables for database
+var dbHVars = []string{
+	"DB_HOST",
+	"DB_PASSWORD",
+	"DB_USERNAME",
+}
+var tdbRVars = []string{
+	"TARGET_DB_HOST",
+	"TARGET_DB_NAME",
+	"TARGET_DB_USERNAME",
+	"TARGET_DB_PASSWORD",
+}
+
+var dbConf *dbConfig
+var targetDbConf *targetDbConfig
+
+var ftpVars = []string{
+	"FTP_HOST_NAME",
+	"FTP_USER",
+	"FTP_PASSWORD",
+	"FTP_PORT",
+}
+var azureVars = []string{
+	"AZURE_STORAGE_CONTAINER_NAME",
+	"AZURE_STORAGE_ACCOUNT_NAME",
+	"AZURE_STORAGE_ACCOUNT_KEY",
+}
+
+// AwsVars Required environment variables for AWS S3 storage
+var awsVars = []string{
+	"AWS_S3_ENDPOINT",
+	"AWS_S3_BUCKET_NAME",
+	"AWS_ACCESS_KEY",
+	"AWS_SECRET_KEY",
+	"AWS_REGION",
+}

scripts/backup_script.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-DB_USERNAME='db_username'
-DB_PASSWORD='password'
-DB_HOST='db_hostname'
-DB_NAME='db_name'
-BACKUP_DIR="$PWD/backup"
-
-docker run --rm --name mysql-bkup -v $BACKUP_DIR:/backup/ -e "DB_HOST=$DB_HOST" -e "DB_USERNAME=$DB_USERNAME" -e "DB_PASSWORD=$DB_PASSWORD" jkaninda/mysql-bkup:latest  bkup -o backup -d $DB_NAME

templates/email-error.tmpl

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <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>🔴 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>

templates/email.tmpl

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <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>✅ 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>

templates/telegram-error.tmpl

@@ -0,0 +1,11 @@
+🔴 Urgent: Database Backup Failure Notification
+
+Hi,
+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

@@ -0,0 +1,15 @@
+✅ Database Backup Successful
+
+Hi,
+The backup process for the {{.Database}} database was successfully completed.
+Please find the details below:
+
+Backup Details:
+- Database Name: {{.Database}}
+- Backup Duration: {{.Duration}}
+- Backup Storage: {{.Storage}}
+- Backup Location: {{.BackupLocation}}
+- Backup Size: {{.BackupSize}}
+- Backup Reference: {{.BackupReference}}
+
+You can access the backup at the specified location if needed.

utils/config.go

@@ -0,0 +1,95 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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 {
+	MailHost     string
+	MailPort     int
+	MailUserName string
+	MailPassword string
+	MailTo       string
+	MailFrom     string
+	SkipTls      bool
+}
+type NotificationData struct {
+	File            string
+	BackupSize      string
+	Database        string
+	Duration        string
+	Storage         string
+	BackupLocation  string
+	BackupReference string
+}
+type ErrorMessage struct {
+	Database        string
+	EndTime         string
+	Error           string
+	BackupReference string
+	DatabaseName    string
+}
+
+// loadMailConfig gets mail environment variables and returns MailConfig
+func loadMailConfig() *MailConfig {
+	return &MailConfig{
+		MailHost:     os.Getenv("MAIL_HOST"),
+		MailPort:     GetIntEnv("MAIL_PORT"),
+		MailUserName: os.Getenv("MAIL_USERNAME"),
+		MailPassword: os.Getenv("MAIL_PASSWORD"),
+		MailTo:       os.Getenv("MAIL_TO"),
+		MailFrom:     os.Getenv("MAIL_FROM"),
+		SkipTls:      os.Getenv("MAIL_SKIP_TLS") == "false",
+	}
+
+}
+
+// TimeFormat returns the format of the time
+func TimeFormat() string {
+	format := os.Getenv("TIME_FORMAT")
+	if format == "" {
+		return "2006-01-02 at 15:04:05"
+
+	}
+	return format
+}
+
+func backupReference() string {
+	return os.Getenv("BACKUP_REFERENCE")
+}
+
+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

@@ -0,0 +1,35 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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" +
+	"restore --dbname database --storage s3 --path /custom-path --file db_20231219_022941.sql.gz"
+const BackupExample = "backup --dbname database --disable-compression\n" +
+	"backup --dbname database --storage s3 --path /custom-path --disable-compression"
+
+const MainExample = "mysql-bkup backup --dbname database --disable-compression\n" +
+	"backup --dbname database --storage s3 --path /custom-path\n" +
+	"restore --dbname database --file db_20231219_022941.sql.gz"
+const traceLog = "trace"

utils/logger.go

@@ -0,0 +1,103 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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 (
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+	"strings"
+)
+
+// Info returns info log
+func Info(msg string, args ...interface{}) {
+	log.SetOutput(getStd("/dev/stdout"))
+	logWithCaller("INFO", msg, args...)
+
+}
+
+// Warn returns warning log
+func Warn(msg string, args ...interface{}) {
+	log.SetOutput(getStd("/dev/stdout"))
+	logWithCaller("WARN", msg, args...)
+
+}
+
+// Error logs error messages
+func Error(msg string, args ...interface{}) {
+	log.SetOutput(getStd("/dev/stderr"))
+	logWithCaller("ERROR", msg, args...)
+}
+
+func Fatal(msg string, args ...interface{}) {
+	log.SetOutput(os.Stdout)
+	// Format message if there are additional arguments
+	formattedMessage := msg
+	if len(args) > 0 {
+		formattedMessage = fmt.Sprintf(msg, args...)
+	}
+	logWithCaller("ERROR", msg, args...)
+	NotifyError(formattedMessage)
+	os.Exit(1)
+}
+
+// Helper function to format and log messages with file and line number
+func logWithCaller(level, msg string, args ...interface{}) {
+	// Format message if there are additional arguments
+	formattedMessage := msg
+	if len(args) > 0 {
+		formattedMessage = fmt.Sprintf(msg, args...)
+	}
+
+	// Get the caller's file and line number (skip 2 frames)
+	_, file, line, ok := runtime.Caller(2)
+	if !ok {
+		file = "unknown"
+		line = 0
+	}
+	// Log message with caller information if GOMA_LOG_LEVEL is trace
+	if strings.ToLower(level) != "off" {
+		if strings.ToLower(level) == traceLog {
+			log.Printf("%s: %s (File: %s, Line: %d)\n", level, formattedMessage, file, line)
+		} else {
+			log.Printf("%s: %s\n", level, formattedMessage)
+		}
+	}
+}
+
+func getStd(out string) *os.File {
+	switch out {
+	case "/dev/stdout":
+		return os.Stdout
+	case "/dev/stderr":
+		return os.Stderr
+	case "/dev/stdin":
+		return os.Stdin
+	default:
+		return os.Stdout
+
+	}
+}

utils/notification.go

@@ -0,0 +1,179 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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 (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"github.com/go-mail/mail"
+	"html/template"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func parseTemplate[T any](data T, fileName string) (string, error) {
+	// Open the file
+	tmpl, err := template.ParseFiles(filepath.Join(templatePath, fileName))
+	if err != nil {
+		return "", err
+	}
+
+	var buf bytes.Buffer
+	if err = tmpl.Execute(&buf, data); err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
+func SendEmail(subject, body string) error {
+	Info("Start sending email notification....")
+	config := loadMailConfig()
+	emails := strings.Split(config.MailTo, ",")
+	m := mail.NewMessage()
+	m.SetHeader("From", config.MailFrom)
+	m.SetHeader("To", emails...)
+	m.SetHeader("Subject", subject)
+	m.SetBody("text/html", body)
+	d := mail.NewDialer(config.MailHost, config.MailPort, config.MailUserName, config.MailPassword)
+	d.TLSConfig = &tls.Config{InsecureSkipVerify: config.SkipTls}
+
+	if err := d.DialAndSend(m); err != nil {
+		Error("Error could not send email : %v", err)
+		return err
+	}
+	Info("Email notification has been sent")
+	return nil
+
+}
+func sendMessage(msg string) error {
+
+	Info("Sending Telegram notification... ")
+	chatId := os.Getenv("TG_CHAT_ID")
+	body, _ := json.Marshal(map[string]string{
+		"chat_id": chatId,
+		"text":    msg,
+	})
+	url := fmt.Sprintf("%s/sendMessage", getTgUrl())
+	// Create an HTTP post request
+	request, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		panic(err)
+	}
+	request.Header.Add("Content-Type", "application/json")
+	client := &http.Client{}
+	response, err := client.Do(request)
+	if err != nil {
+		return err
+	}
+	code := response.StatusCode
+	if code == 200 {
+		Info("Telegram notification has been sent")
+		return nil
+	} else {
+		body, _ := io.ReadAll(response.Body)
+		Error("Error could not send message, error: %s", string(body))
+		return fmt.Errorf("error could not send message %s", string(body))
+	}
+
+}
+func NotifySuccess(notificationData *NotificationData) {
+	notificationData.BackupReference = backupReference()
+	// Email notification
+	err := CheckEnvVars(mailVars)
+	if err == nil {
+		body, err := parseTemplate(*notificationData, "email.tmpl")
+		if err != nil {
+			Error("Could not parse email template: %v", err)
+		}
+		err = SendEmail(fmt.Sprintf("✅  Database Backup Notification – %s", notificationData.Database), body)
+		if err != nil {
+			Error("Could not send email: %v", err)
+		}
+	}
+	// Telegram notification
+	err = CheckEnvVars(vars)
+	if err == nil {
+		message, err := parseTemplate(*notificationData, "telegram.tmpl")
+		if err != nil {
+			Error("Could not parse telegram template: %v", err)
+		}
+
+		err = sendMessage(message)
+		if err != nil {
+			Error("Could not send Telegram message: %v", err)
+		}
+	}
+}
+func NotifyError(error string) {
+
+	// Email notification
+	err := CheckEnvVars(mailVars)
+	if err == nil {
+		body, err := parseTemplate(ErrorMessage{
+			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)
+		}
+		err = SendEmail("🔴 Urgent: Database Backup Failure Notification", body)
+		if err != nil {
+			Error("Could not send email: %v", err)
+		}
+	}
+	// Telegram notification
+	err = CheckEnvVars(vars)
+	if err == nil {
+		message, err := parseTemplate(ErrorMessage{
+			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)
+
+		}
+
+		err = sendMessage(message)
+		if err != nil {
+			Error("Could not send telegram message: %v", err)
+		}
+	}
+}
+
+func getTgUrl() string {
+	return fmt.Sprintf("https://api.telegram.org/bot%s", os.Getenv("TG_TOKEN"))
+
+}

utils/utils.go

@@ -1,39 +1,43 @@
+/*
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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
 
-/*****
-*   MySQL Backup & Restore
-* @author    Jonas Kaninda
-* @license   MIT License <https://opensource.org/licenses/MIT>
-* @link      https://github.com/jkaninda/mysql-bkup
-**/
 import (
 	"fmt"
+	"github.com/robfig/cron/v3"
+	"github.com/spf13/cobra"
+	"io"
 	"io/fs"
 	"os"
-	"os/exec"
+	"strconv"
+	"time"
 )
 
-func Info(v ...any) {
-	fmt.Println("[INFO] ", fmt.Sprint(v...))
-}
-func Infof(msg string, v ...any) {
-	fmt.Printf("[INFO] "+msg, v...)
-}
-func Warning(message string) {
-	fmt.Println("[WARNING]", message)
-}
-func Warningf(msg string, v ...any) {
-	fmt.Printf("[WARNING] "+msg, v...)
-}
-func Fatal(v ...any) {
-	fmt.Println("[ERROR] ", fmt.Sprint(v...))
-	os.Exit(1)
-}
-func Fatalf(msg string, v ...any) {
-	fmt.Printf("[ERROR] "+msg, v...)
-	os.Exit(1)
-}
+var Version = ""
 
+// FileExists checks if the file does exist
 func FileExists(filename string) bool {
 	info, err := os.Stat(filename)
 	if os.IsNotExist(err) {
@@ -47,14 +51,67 @@ func WriteToFile(filePath, content string) error {
 	if err != nil {
 		return err
 	}
-	defer file.Close()
+	defer func(file *os.File) {
+		err := file.Close()
+		if err != nil {
+			return
+
+		}
+	}(file)
 
 	_, err = file.WriteString(content)
 	return err
 }
+func DeleteFile(filePath string) error {
+	err := os.Remove(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to delete file: %v", err)
+	}
+	return nil
+}
+func CopyFile(src, dst string) error {
+	// Open the source file for reading
+	sourceFile, err := os.Open(src)
+	if err != nil {
+		return fmt.Errorf("failed to open source file: %v", err)
+	}
+	defer func(sourceFile *os.File) {
+		err := sourceFile.Close()
+		if err != nil {
+			return
+		}
+	}(sourceFile)
+
+	// Create the destination file
+	destinationFile, err := os.Create(dst)
+	if err != nil {
+		return fmt.Errorf("failed to create destination file: %v", err)
+	}
+	defer func(destinationFile *os.File) {
+		err := destinationFile.Close()
+		if err != nil {
+			return
+
+		}
+	}(destinationFile)
+
+	// Copy the content from source to destination
+	_, err = io.Copy(destinationFile, sourceFile)
+	if err != nil {
+		return fmt.Errorf("failed to copy file: %v", err)
+	}
+
+	// Flush the buffer to ensure all data is written
+	err = destinationFile.Sync()
+	if err != nil {
+		return fmt.Errorf("failed to sync destination file: %v", err)
+	}
+
+	return nil
+}
 func ChangePermission(filePath string, mod int) {
 	if err := os.Chmod(filePath, fs.FileMode(mod)); err != nil {
-		Fatalf("Error changing permissions of %s: %v\n", filePath, err)
+		Fatal("Error changing permissions of %s: %v\n", filePath, err)
 	}
 
 }
@@ -63,7 +120,12 @@ func IsDirEmpty(name string) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	defer f.Close()
+	defer func(f *os.File) {
+		err := f.Close()
+		if err != nil {
+			return
+		}
+	}(f)
 
 	_, err = f.Readdirnames(1)
 	if err == nil {
@@ -72,15 +134,139 @@ func IsDirEmpty(name string) (bool, error) {
 	return true, nil
 }
 
-// TestDatabaseConnection  tests the database connection
-func TestDatabaseConnection() {
-	Info("Testing database connection...")
-	// Test database connection
-	cmd := exec.Command("mysql", "-h", os.Getenv("DB_HOST"), "-P", os.Getenv("DB_PORT"), "-u", os.Getenv("DB_USERNAME"), "--password="+os.Getenv("DB_PASSWORD"), os.Getenv("DB_NAME"), "-e", "quit")
-	err := cmd.Run()
-	if err != nil {
-		Fatal("Error testing database connection:", err)
+func GetEnv(cmd *cobra.Command, flagName, envName string) string {
+	value, _ := cmd.Flags().GetString(flagName)
+	if value != "" {
+		err := os.Setenv(envName, value)
+		if err != nil {
+			return value
+		}
+	}
+	return os.Getenv(envName)
+}
+func FlagGetString(cmd *cobra.Command, flagName string) string {
+	value, _ := cmd.Flags().GetString(flagName)
+	if value != "" {
+		return value
 
 	}
-
+	return ""
+}
+func FlagGetBool(cmd *cobra.Command, flagName string) bool {
+	value, _ := cmd.Flags().GetBool(flagName)
+	return value
+}
+
+func SetEnv(key, value string) {
+
+	err := os.Setenv(key, value)
+	if err != nil {
+		return
+	}
+}
+func GetEnvVariable(envName, oldEnvName string) string {
+	value := os.Getenv(envName)
+	if value == "" {
+		value = os.Getenv(oldEnvName)
+		if value != "" {
+			err := os.Setenv(envName, value)
+			if err != nil {
+				return value
+			}
+			Warn("%s is deprecated, please use %s instead! ", oldEnvName, envName)
+		}
+	}
+	return value
+}
+
+// CheckEnvVars checks if all the specified environment variables are set
+func CheckEnvVars(vars []string) error {
+	missingVars := []string{}
+
+	for _, v := range vars {
+		if os.Getenv(v) == "" {
+			missingVars = append(missingVars, v)
+		}
+	}
+
+	if len(missingVars) > 0 {
+		return fmt.Errorf("missing environment variables: %v", missingVars)
+	}
+
+	return nil
+}
+
+// MakeDir create directory
+func MakeDir(dirPath string) error {
+	err := os.Mkdir(dirPath, 0700)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// MakeDirAll create directory
+func MakeDirAll(dirPath string) error {
+	err := os.MkdirAll(dirPath, 0700)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+func GetIntEnv(envName string) int {
+	val := os.Getenv(envName)
+	if val == "" {
+		return 0
+	}
+	ret, err := strconv.Atoi(val)
+	if err != nil {
+		Error("Error: %v", err)
+	}
+	return ret
+}
+
+func EnvWithDefault(envName string, defaultValue string) string {
+	value := os.Getenv(envName)
+	if value == "" {
+		return defaultValue
+	}
+	return value
+}
+
+// IsValidCronExpression verify cronExpression and returns boolean
+func IsValidCronExpression(cronExpr string) bool {
+	// Parse the cron expression
+	_, err := cron.ParseStandard(cronExpr)
+	return err == nil
+}
+
+// CronNextTime returns cronExpression next time
+func CronNextTime(cronExpr string) time.Time {
+	// Parse the cron expression
+	schedule, err := cron.ParseStandard(cronExpr)
+	if err != nil {
+		Error("Error parsing cron expression: %s", err)
+		return time.Time{}
+	}
+	// Get the current time
+	now := time.Now()
+	// Get the next scheduled 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)
+	}
 }