chore: release 1.8.0

* feat: separate mysql and mariadb

* feat: separate mysql and mariadb

.github/workflows/codecov.yml

@@ -0,0 +1,172 @@
+#name: Codecov Rust
+#
+#on:
+#  push:
+#    branches: ["main"]
+#  pull_request:
+#    branches: ["main"]
+#
+#env:
+#  CARGO_TERM_COLOR: always
+#
+#jobs:
+#  coverage:
+#    runs-on: ubuntu-latest
+#    steps:
+#      - uses: actions/checkout@v4
+#
+#      - name: Install Rust toolchain
+#        uses: dtolnay/rust-toolchain@stable
+#        with:
+#          components: llvm-tools-preview
+#
+#      - name: Build test image (with grcov included)
+#        run: docker compose -f docker-compose.test.yml build agent-test
+#
+#      - name: Run tests in container
+#        env:
+#          CARGO_TARGET_DIR: /app/target
+#          CARGO_INCREMENTAL: 0
+#          RUSTFLAGS: "-C instrument-coverage -C link-dead-code"
+#          LLVM_PROFILE_FILE: "/app/coverage/cargo-test-%p-%m.profraw"
+#        run: |
+#          docker compose -f docker-compose.test.yml run \
+#            -e CARGO_TARGET_DIR \
+#            -e CARGO_INCREMENTAL \
+#            -e RUSTFLAGS \
+#            -e LLVM_PROFILE_FILE \
+#            agent-test bash -c "cargo clean && cargo test --verbose && sync"
+#
+#      - name: Verify profraw files exist
+#        run: |
+#          docker compose -f docker-compose.test.yml run agent-test \
+#            find /app/coverage -type f -name "*.profraw" | wc -l || true
+#
+#      - name: Generate coverage report inside container
+#        run: |
+#          docker compose -f docker-compose.test.yml run agent-test bash -c "
+#            rustup component add llvm-tools &&
+#            grcov /app/coverage \
+#              --binary-path /app/target/debug \
+#              -s /app \
+#              --llvm \
+#              -t lcov \
+#              --branch \
+#              --ignore-not-existing \
+#              --ignore '/app/target/*' \
+#              --ignore '/*' \
+#              -o /app/lcov.info
+#          "
+#
+#      - name: Copy lcov.info from container to host
+#        run: |
+#          docker compose -f docker-compose.test.yml cp agent-test:/app/lcov.info ./lcov.info
+#
+#      - name: Remove container
+#        run: |
+#          docker rm agent-test-run
+#
+#      - name: Show basic coverage report info (debug)
+#        run: |
+#          echo "lcov.info size:" $(wc -c ./lcov.info | awk '{print $1}')
+#          head -n 30 ./lcov.info || true
+#
+#      - name: Upload coverage to Codecov
+#        uses: codecov/codecov-action@v5
+#        with:
+#          files: ./lcov.info
+#          flags: unittests
+#          name: rust-unit-coverage
+#          verbose: true
+#          fail_ci_if_error: true
+#        env:
+#          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+name: Codecov Rust
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_TARGET_DIR: /app/target
+  CARGO_INCREMENTAL: 0
+  RUSTFLAGS: "-C instrument-coverage -C link-dead-code"
+  LLVM_PROFILE_FILE: "/app/coverage/cargo-test-%p-%m.profraw"
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: llvm-tools-preview
+
+      - name: Build test image (with grcov included)
+        run: docker compose -f docker-compose.test.yml build agent-test
+
+      - name: Start agent-test container
+        run: docker compose -f docker-compose.test.yml up -d agent-test
+
+      - name: Run tests inside container
+        run: |
+          docker compose -f docker-compose.test.yml exec \
+            -e CARGO_TARGET_DIR \
+            -e CARGO_INCREMENTAL \
+            -e RUSTFLAGS \
+            -e LLVM_PROFILE_FILE \
+            agent-test bash -c "
+              cargo clean &&
+              cargo test --verbose &&
+              sync
+            "
+
+      - name: Verify profraw files exist
+        run: |
+          docker compose -f docker-compose.test.yml exec \
+            -e LLVM_PROFILE_FILE \
+            agent-test find /app/coverage -type f -name "*.profraw" | wc -l || true
+
+      - name: Generate coverage report inside container
+        run: |
+          docker compose -f docker-compose.test.yml exec \
+            agent-test bash -c "
+              rustup component add llvm-tools &&
+              grcov /app/coverage \
+                --binary-path /app/target/debug \
+                -s /app \
+                --llvm \
+                -t lcov \
+                --branch \
+                --ignore-not-existing \
+                --ignore '/app/target/*' \
+                --ignore '/*' \
+                -o /app/lcov.info
+            "
+
+      - name: Copy lcov.info from container to host
+        run: docker compose -f docker-compose.test.yml cp agent-test:/app/lcov.info ./lcov.info
+
+      - name: Show basic coverage report info (debug)
+        run: |
+          echo "lcov.info size:" $(wc -c ./lcov.info | awk '{print $1}')
+          head -n 30 ./lcov.info || true
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          files: ./lcov.info
+          flags: unittests
+          name: rust-unit-coverage
+          verbose: true
+          fail_ci_if_error: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Stop and remove container
+        run: docker compose -f docker-compose.test.yml down

.github/workflows/docker.yml

@@ -6,6 +6,9 @@ on:
       version:
         required: true
         type: string
+      ref:
+        required: true
+        type: string
       image_name:
         required: false
         type: string
@@ -21,7 +24,7 @@ on:
       dockerfile:
         required: false
         type: string
-        default: "./docker/dockerfile/Dockerfile"
+        default: "./docker/Dockerfile"
     secrets:
       DOCKER_USERNAME:
         required: true
@@ -37,8 +40,10 @@ jobs:
       matrix:
         platform: [ linux/amd64, linux/arm64 ]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+          fetch-depth: 0
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
@@ -66,8 +71,6 @@ jobs:
           push: true
           tags: ${{ steps.prep.outputs.image }}
           target: ${{ inputs.target }}
-          cache-from: type=gha,scope=build-${{ matrix.platform }}
-          cache-to: type=gha,mode=max,scope=build-${{ matrix.platform }}
 
       - name: Save image name for manifest
         run: echo "${{ steps.prep.outputs.image }}" > image.txt

.github/workflows/helm.yml

@@ -0,0 +1,37 @@
+name: Publish Helm Chart
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+    secrets:
+      GH_TOKEN:
+        required: true
+
+jobs:
+  publish-helm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v4
+
+      - name: Package Helm chart
+        run: |
+          mkdir -p ./helm-packages
+          helm package helm \
+            --version ${{ inputs.version }} \
+            --app-version ${{ inputs.version }} \
+            --destination ./helm-packages
+
+      - name: Authenticate to GitHub Packages
+        run: |
+          echo "${{ secrets.GH_TOKEN }}" | helm registry login ghcr.io -u ${{ github.actor }} --password-stdin
+
+      - name: Push Helm chart to GitHub Packages (OCI)
+        run: |
+          helm push ./helm-packages/portabase-agent-${{ inputs.version }}.tgz oci://ghcr.io/portabase/charts

.github/workflows/release.yml

@@ -50,6 +50,12 @@ jobs:
           token: ${{ steps.app-token.outputs.token }}
           ref: main
 
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install cargo-edit
+        run: cargo install cargo-edit
+
       - uses: actions/setup-node@v4
         with:
           node-version: "lts/*"
@@ -64,59 +70,50 @@ jobs:
           git config --global user.name 'github-actions[bot]'
           git config --global user.email 'github-actions[bot]@users.noreply.github.com'
 
-#      - name: Run release-it
-#        id: release_step
-#        run: |
-#          git pull origin main
-#
-#          VERSION=$(release-it --ci --release-version)
-#          echo $VERSION
-#          echo "version=$VERSION" >> $GITHUB_OUTPUT
-#
-#          OUTPUT=$(release-it --ci)
-#          echo "$OUTPUT"
-#
-#          DRAFT_TAG=$(echo "$OUTPUT" | grep -oE 'untagged-[a-z0-9]+')
-#          echo $DRAFT_TAG
-#          echo "draft_tag=$DRAFT_TAG" >> $GITHUB_OUTPUT
-#        env:
-#          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
       - name: Run release-it
         id: release_step
         run: |
           git pull origin main
-          
-          # Run release-it in CI mode (bump version, commit, tag, changelog, GitHub release)
+
+          VERSION=$(release-it --ci --release-version)
+          echo $VERSION
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
           OUTPUT=$(release-it --ci)
           echo "$OUTPUT"
-          
-          # Extract the new version
-          VERSION=$(echo "$OUTPUT" | grep -oP '(?<=Bumping version: ).*')
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          
-          # Extract draft tag if any
+
           DRAFT_TAG=$(echo "$OUTPUT" | grep -oE 'untagged-[a-z0-9]+')
+          echo $DRAFT_TAG
           echo "draft_tag=$DRAFT_TAG" >> $GITHUB_OUTPUT
         env:
           GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
 
-
   publish-docker:
     needs: create-release
     if: ${{ needs.create-release.result == 'success' }}
     uses: ./.github/workflows/docker.yml
     with:
       version: ${{ needs.create-release.outputs.version }}
+      ref: ${{ needs.create-release.outputs.version }}
       add_latest: true
     secrets:
       DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
       DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
 
+  publish-helm:
+    needs: create-release
+    if: ${{ needs.create-release.result == 'success' }}
+    uses: ./.github/workflows/helm.yml
+    with:
+      version: ${{ needs.create-release.outputs.version }}
+    secrets:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   finalize-release:
     needs:
       - create-release
       - publish-docker
+      - publish-helm
     runs-on: ubuntu-latest
     outputs:
       release_tag: ${{ steps.publish_release_step.outputs.release_tag }}
@@ -138,6 +135,7 @@ jobs:
   notify-discord:
     needs:
       - publish-docker
+      - publish-helm
       - create-release
       - finalize-release
     uses: ./.github/workflows/discord.yml

.release-it.json

@@ -12,6 +12,9 @@
     "tagName": "${version}",
     "push": true
   },
+  "hooks": {
+    "before:bump": "cargo set-version ${version}"
+  },
   "plugins": {
     "@release-it/conventional-changelog": {
       "preset": {
@@ -48,11 +51,6 @@
     },
     "@release-it/bumper": {
       "out": [
-        {
-          "file": "Cargo.toml",
-          "path": "package.version",
-          "type": "toml"
-        },
         {
           "file": "CITATION.cff",
           "path": "version",

CITATION.cff

@@ -27,5 +27,5 @@ keywords:
   - self-hosted
   - portabase
 license: Apache-2.0
-version: 1.2.0
+version: 1.8.0
 date-released: '2026-02-24'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.2.0"
+version = "1.8.0"
 edition = "2024"
 
 [dependencies]
@@ -30,7 +30,7 @@ tokio-postgres = "0.7.15"
 futures = "0.3.31"
 tracing-appender = "0.2.4"
 time = { version = "0.3.44", features = ["macros"] }
-mongodb = "3.5.0"
+mongodb = "3.5.1"
 rand = "0.9.2"
 bytes = "1.11.0"
 async-stream = "0.3.6"
@@ -42,14 +42,28 @@ async-compression = { version = "0.4.37", features = ["tokio", "gzip"] }
 tokio-tar = "0.3.1"
 oauth2 = "5.0.0"
 hyper = "1.8.1"
-async-http-client = "0.2.0"
 aes-gcm = "0.11.0-rc.3"
 generic-array = "0.14.7"
 futures-util = "0.3.31"
 tokio-stream = "0.1.18"
 aes = "0.9.0-rc.4"
 typenum = "1.19.0"
+testcontainers = "0.27.1"
+testcontainers-modules = { version = "0.15.0", features = ["postgres", "redis", "valkey", "mysql", "mariadb", "mongo"] }
+postgres = "0.19.12"
+url = "2.5.8"
 
+[dev-dependencies]
+tokio = { version = "1", features = ["full"] }
+mockall = "0.13"
+testcontainers = "0.27.1"
+testcontainers-modules = { version = "0.15.0", features = ["postgres", "redis", "mysql", "mariadb", "mongo"] }
+wiremock = "0.6"
+
+[profile.release]
+lto = true
+codegen-units = 1
+strip = "debuginfo"
 
 [[bin]]
 name = "app"

Makefile

@@ -1,8 +1,12 @@
 include .env
 export $(shell sed 's/=.*//' .env)
+CLUSTER_SCRIPT=docker/entrypoints/app-dev-entrypoint.sh
 
 .PHONY: seed-mongo seed-mysql seed-postgres
 
+up:
+	@bash $(CLUSTER_SCRIPT)
+
 seed-mongo:
 	@echo "Seeding MongoDB..."
 	bash ./scripts/mongo/seed-mongo.sh

README.md

@@ -16,10 +16,11 @@
 [![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/Portabase/portabase)
 [![Support Portabase](https://img.shields.io/badge/Support-Portabase-orange)](https://www.buymeacoffee.com/portabase)
 
-[![PostgreSQL](https://img.shields.io/badge/python-3.13-blue.svg)](https://www.python.org/downloads/release/python-3120/)
 [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-336791?logo=postgresql&logoColor=white)](https://www.postgresql.org/)
 [![MySQL](https://img.shields.io/badge/MySQL-4479A1?logo=mysql&logoColor=white)](https://www.mysql.com/)
 [![SQLite](https://img.shields.io/badge/-SQLite-blue?logo=sqlite&logoColor=white)](https://sqlite.org/)
+[![Redis](https://img.shields.io/badge/Redis-DC382D?style=flat&logo=Redis&logoColor=white)](https://redis.io/)
+[![Valkey](https://img.shields.io/badge/Valkey-6284fc?style=flat&logo=Valkey&logoColor=white)](https://valkey.io/)
 [![MariaDB](https://img.shields.io/badge/MariaDB-003545?logo=mariadb&logoColor=white)](https://mariadb.org/)
 [![MongoDB](https://img.shields.io/badge/-MongoDB-13aa52?logo=mongodb&logoColor=white)](https://www.mongodb.com/)
 [![Self Hosted](https://img.shields.io/badge/self--hosted-yes-brightgreen)](https://github.com/Portabase/portabase)

databases.json

@@ -13,7 +13,7 @@
     {
       "name": "Test database 2 - MariaDB",
       "database": "mariadb",
-      "type": "mysql",
+      "type": "mariadb",
       "username": "mariadb",
       "password": "changeme",
       "port": 3306,
@@ -49,6 +49,48 @@
       "type": "sqlite",
       "path": "/sqlite-data-2/workspace/data/app.db",
       "generated_id": "16678179-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 8 - Redis",
+      "type": "redis",
+      "port": 6379,
+      "host": "db-redis",
+      "generated_id": "16678166-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 9 - Redis Auth",
+      "type": "redis",
+      "password": "supersecurepassword",
+      "port": 6379,
+      "username": "default",
+      "host": "db-redis-auth",
+      "generated_id": "16678160-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 10 - Valkey",
+      "type": "valkey",
+      "port": 6379,
+      "host": "db-valkey",
+      "generated_id": "16678560-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 11 - Valkey Auth",
+      "type": "valkey",
+      "password": "supersecurepassword",
+      "port": 6379,
+      "username": "default",
+      "host": "db-valkey-auth",
+      "generated_id": "16678561-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 12 - Mysql",
+      "database": "mysqldb",
+      "type": "mysql",
+      "username": "mysqldb",
+      "password": "changeme",
+      "port": 3306,
+      "host": "db-mysql",
+      "generated_id": "16656124-ff7e-4c97-8c83-0adeff214681"
     }
   ]
 }

docker-compose.prod.yml

@@ -5,23 +5,20 @@ services:
 #      dockerfile: docker/Dockerfile
 #      target: prod
     image: portabase/agent:latest
-#    platform: linux/arm64
     container_name: rust-prod
     volumes:
       - ./databases.json:/config/config.json
     environment:
-      #      APP_ENV: production
       LOG: info
       TZ: "Europe/Paris"
-      #      DATABASES_CONFIG_FILE: "config.toml"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiOGZmMDE4NTQtYjJhMS00ZTE0LTkwMjctZTJiOWIxZjQ1YzdlIiwicHVibGljS2V5IjoiLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tXG5NSUlCQ2dLQ0FRRUE5TWV4M2pmdnVLdFB5YU1ERnh2Ulp2dmd3YkRJQ2JzQi81Wll5NDNSVVRBaXZRYjJiSDdYXG5qRHBQd1lJeCs4UFBrbHlRbDVMQzV1UWZEaCs4SVd4OG1LZ3FvMXpWMkdiZXdGbEdEWFYxVEdyU1ZEU25aSWR4XG52bWdYc29EeXhVMlJvWUFUMS9YMWxuc2YxenZKdkFMTkhXdEhRdk42SjVDZTFSMmFsendVRGFEVXlJNzRmSldQXG5tNTh0SDMrYklXL0VVTXdjaWNxM0oySWw3Vm9KNkZNUHJQL1ZSOWEvdFF1SU1qa200MXpFY2NscExPa2luRkxuXG54NmVUWkFSZUpya2UrbnRvZ2t4TGEyRWV5a1lUNzB4V3hKNWp5ZExBVnRvNkkyQlVLVVJoTkowTUFaU29NYUtvXG5iMGJRcnY1UzExZWllMnMrT2I3aTYzSFpkVUx0UmV1MVJ3SURBUUFCXG4tLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tXG4ifQ"
+      #DATABASES_CONFIG_FILE: "config.toml"
+      EDGE_KEY: "<to complete>"
     extra_hosts:
       - "localhost:host-gateway"
     networks:
       - portabase
 
 
-
   db-mongodb-auth:
     container_name: db-mongodb-auth
     image: mongo:latest
@@ -63,7 +60,6 @@ volumes:
   mongodb-data:
   mongodb-data-auth:
 
-
 networks:
   portabase:
     name: portabase_network

docker-compose.test.yml

@@ -0,0 +1,22 @@
+services:
+  agent-test:
+    build:
+      context: .
+      dockerfile: docker/Dockerfile
+      target: dev
+    working_dir: /app
+    container_name: agent-test
+    volumes:
+      - .:/app
+      - cargo-registry:/usr/local/cargo/registry
+      - cargo-git:/usr/local/cargo/git
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      APP_ENV: test
+      LOG: debug
+      TZ: Europe/Paris
+      EDGE_KEY: ""
+
+volumes:
+  cargo-registry:
+  cargo-git:

docker-compose.yml

@@ -11,14 +11,15 @@ services:
       #      - ./databases.toml:/config/config.toml
       - cargo-registry:/usr/local/cargo/registry
       - cargo-git:/usr/local/cargo/git
-      #      - cargo-target:/app/target
-#      - sqlite-data:/sqlite-data/workspace/data
-#      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
+#      - /var/run/docker.sock:/var/run/docker.sock
+    #      - cargo-target:/app/target
+    #      - sqlite-data:/sqlite-data/workspace/data
+    #      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
     environment:
       APP_ENV: development
       LOG: debug
       TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNjI1MDQzY2YtN2MwMC00M2M4LWJjYzktZDM1MTk5ODk2ZGNkIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNGI1OTM2MGItNTNkMi00ZTZmLWE1ODctODcyMmQ1NDc1MTNmIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
       #POOLING: 1
       #DATABASES_CONFIG_FILE: "config.toml"
     extra_hosts:
@@ -26,98 +27,163 @@ services:
     networks:
       - portabase
 
-  db-postgres:
-    container_name: db-postgres
-    image: postgres:17-alpine
+#  db-postgres:
+#    container_name: db-postgres
+#    image: postgres:17-alpine
+#    ports:
+#      - "5436:5432"
+#    volumes:
+#      - postgres-data:/var/lib/postgresql/data
+#    environment:
+#      - POSTGRES_DB=devdb
+#      - POSTGRES_USER=devuser
+#      - POSTGRES_PASSWORD=changeme
+#    networks:
+#      - portabase
+
+  db-mariadb:
+    container_name: db-mariadb
+    image: mariadb:latest
     ports:
-      - "5436:5432"
-    volumes:
-      - postgres-data:/var/lib/postgresql/data
+      - "3311:3306"
     environment:
-      - POSTGRES_DB=devdb
-      - POSTGRES_USER=devuser
-      - POSTGRES_PASSWORD=changeme
+      - MYSQL_DATABASE=mariadb
+      - MYSQL_USER=mariadb
+      - MYSQL_PASSWORD=changeme
+      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+    volumes:
+      - mariadb-data:/var/lib/mysql
     networks:
       - portabase
-#
-#  db-mariadb:
-#    container_name: db-mariadb
-#    image: mariadb:latest
-#    ports:
-#      - "3311:3306"
-#    environment:
-#      - MYSQL_DATABASE=mariadb
-#      - MYSQL_USER=mariadb
-#      - MYSQL_PASSWORD=changeme
-#      - MYSQL_RANDOM_ROOT_PASSWORD=yes
-#    volumes:
-#      - mariadb-data:/var/lib/mysql
-#    networks:
-#      - portabase
-#
-#
-#  db-mongodb-auth:
-#    container_name: db-mongodb-auth
-#    image: mongo:latest
-#    ports:
-#      - "27082:27017"
-#    environment:
-#      MONGO_INITDB_ROOT_USERNAME: root
-#      MONGO_INITDB_ROOT_PASSWORD: rootpassword
-#      MONGO_INITDB_DATABASE: testdbauth
-#    command: mongod --auth
-#    networks:
-#      - portabase
-#    volumes:
-#      - mongodb-data-auth:/data/db
-#    healthcheck:
-#      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
-#      interval: 5s
-#      timeout: 5s
-#      retries: 10
-#
-#  db-mongodb:
-#    container_name: db-mongodb
-#    image: mongo:latest
-#    ports:
-#      - "27083:27017"
-#    volumes:
-#      - mongodb-data:/data/db
-#    healthcheck:
-#      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
-#      interval: 5s
-#      timeout: 5s
-#      retries: 10
-#    environment:
-#      MONGO_INITDB_DATABASE: testdb
-#    networks:
-#      - portabase
 
-#  sqlite:
-#    container_name: db-sqlite
-#    image: keinos/sqlite3
-#    volumes:
-#      - sqlite-data:/workspace/data
-#    working_dir: /workspace
-#    command: tail -f /dev/null
-#    stdin_open: true
-#    tty: true
+  db-mysql:
+    container_name: db-mysql
+    image: mysql:9.5
+    ports:
+      - "3312:3306"
+    environment:
+      - MYSQL_DATABASE=mysqldb
+      - MYSQL_USER=mysqldb
+      - MYSQL_PASSWORD=changeme
+      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+    volumes:
+      - mysql-data:/var/lib/mysql
+    networks:
+      - portabase
+  #
+  #
+  #  db-mongodb-auth:
+  #    container_name: db-mongodb-auth
+  #    image: mongo:latest
+  #    ports:
+  #      - "27082:27017"
+  #    environment:
+  #      MONGO_INITDB_ROOT_USERNAME: root
+  #      MONGO_INITDB_ROOT_PASSWORD: rootpassword
+  #      MONGO_INITDB_DATABASE: testdbauth
+  #    command: mongod --auth
+  #    networks:
+  #      - portabase
+  #    volumes:
+  #      - mongodb-data-auth:/data/db
+  #    healthcheck:
+  #      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
+  #      interval: 5s
+  #      timeout: 5s
+  #      retries: 10
+  #
+  #  db-mongodb:
+  #    container_name: db-mongodb
+  #    image: mongo:latest
+  #    ports:
+  #      - "27083:27017"
+  #    volumes:
+  #      - mongodb-data:/data/db
+  #    healthcheck:
+  #      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
+  #      interval: 5s
+  #      timeout: 5s
+  #      retries: 10
+  #    environment:
+  #      MONGO_INITDB_DATABASE: testdb
+  #    networks:
+  #      - portabase
 
+  #  sqlite:
+  #    container_name: db-sqlite
+  #    image: keinos/sqlite3
+  #    volumes:
+  #      - sqlite-data:/workspace/data
+  #    working_dir: /workspace
+  #    command: tail -f /dev/null
+  #    stdin_open: true
+  #    tty: true
+
+#  db-redis:
+#    image: redis:latest
+#    container_name: db-redis
+#    ports:
+#      - "6379:6379"
+#    volumes:
+#      - redis-data:/data
+#    command: [ "redis-server", "--appendonly", "yes" ]
+#    networks:
+#      - portabase
+#
+#  db-redis-auth:
+#    image: redis:latest
+#    container_name: db-redis-auth
+#    ports:
+#      - "6380:6379"
+#    volumes:
+#      - redis-data-auth:/data
+#    environment:
+#      - REDIS_PASSWORD=supersecurepassword
+#    command: [ "redis-server", "--requirepass", "supersecurepassword", "--appendonly", "yes" ]
+#    networks:
+#      - portabase
+#
+#  db-valkey:
+#    image: valkey/valkey
+#    container_name: db-valkey
+#    environment:
+#      - ALLOW_EMPTY_PASSWORD=yes
+#    ports:
+#      - '6381:6379'
+#    volumes:
+#      - valkey-data:/data
+#    networks:
+#      - portabase
+#
+#  db-valkey-auth:
+#    image: valkey/valkey
+#    container_name: db-valkey-auth
+#    command: >
+#      --requirepass "supersecurepassword"
+#    ports:
+#      - '6382:6379'
+#    volumes:
+#      - valkey-data-auth:/data
+#    networks:
+#      - portabase
 
 volumes:
   cargo-registry:
   cargo-git:
-  #  cargo-target:
-
-  postgres-data:
-#  mariadb-data:
+#  cargo-target:
+#  postgres-data:
+  mariadb-data:
+  mysql-data:
 #  mongodb-data:
 #  mongodb-data-auth:
 #  sqlite-data:
+#  redis-data:
+#  redis-data-auth:
+#  valkey-data:
+#  valkey-data-auth:
 
 networks:
   portabase:
     name: portabase_network
     external: true
 
-# docker network create portabase_network

docker/Dockerfile

@@ -1,7 +1,7 @@
 # =========================
 # Base image (shared)
 # =========================
-FROM rust:1.92.0 AS base
+FROM rust:1.94.0 AS base
 
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     pkg-config \
@@ -16,6 +16,8 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     curl \
     mariadb-client \
     sqlite3 \
+    redis-tools \
+    valkey \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
@@ -44,6 +46,7 @@ RUN if [ "$TARGETARCH" = "amd64" ]; then \
     rm -rf /tmp/pg-x64 /tmp/pg-arm && \
     chmod +x /usr/lib/postgresql/*/bin/*
 
+
 # =========================
 # MongoDB client binaries
 # =========================
@@ -58,6 +61,7 @@ WORKDIR /app
 FROM base AS dev
 
 RUN cargo install cargo-watch
+RUN cargo install grcov --locked
 
 COPY Cargo.toml Cargo.lock ./
 RUN mkdir src && echo "fn main() {}" > src/main.rs
@@ -94,6 +98,8 @@ RUN apt-get update && apt-get install -y \
     zlib1g \
     mariadb-client \
     sqlite3 \
+    redis-tools \
+    valkey \
     && rm -rf /var/lib/apt/lists/*
 
 

docker/entrypoints/app-dev-entrypoint.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+set -euo pipefail
+
+check_docker() {
+    if ! docker info > /dev/null 2>&1; then
+        echo "Docker is not running. Attempting to start Docker..."
+        if [[ "$OSTYPE" == "darwin"* ]]; then
+            open -a Docker
+            echo "Waiting for Docker to start..."
+            until docker info > /dev/null 2>&1; do
+                sleep 2
+            done
+        elif command -v systemctl >/dev/null 2>&1; then
+            sudo systemctl start docker
+        else
+            echo "Cannot start Docker automatically. Please start Docker manually."
+            exit 1
+        fi
+    else
+        echo "Docker is running."
+    fi
+}
+
+check_network() {
+    local network_name="portabase_network"
+    if ! docker network ls --format '{{.Name}}' | grep -q "^${network_name}$"; then
+        echo "Docker network '${network_name}' not found. Creating..."
+        docker network create "${network_name}"
+    else
+        echo "Docker network '${network_name}' already exists."
+    fi
+}
+
+check_docker
+check_network
+
+echo "Starting docker-compose..."
+docker compose -f ./docker-compose.yml up
+echo "Docker-compose started successfully."

entrypoint.sh

@@ -34,16 +34,23 @@ if [ -n "$TZ" ]; then
     fi
 fi
 
+REDIS_PORT=65515
 echo "[entrypoint] APP_ENV=$APP_ENV"
 echo "[entrypoint] Starting Redis..."
-redis-server --daemonize yes
+redis-server --port $REDIS_PORT --daemonize yes
 
 echo "[entrypoint] Waiting for Redis to be ready..."
-until redis-cli ping >/dev/null 2>&1; do
+MAX_RETRIES=20
+COUNT=0
+until redis-cli -h localhost -p "$REDIS_PORT" ping >/dev/null 2>&1 ; do
+    COUNT=$((COUNT+1))
+    if [ $COUNT -ge $MAX_RETRIES ]; then
+        echo "[ERROR] Redis did not start after $MAX_RETRIES attempts"
+        exit 1
+    fi
     echo "[entrypoint] Redis not ready, sleeping 1s..."
     sleep 1
 done
-
 echo "[entrypoint] Redis is ready"
 
 

helm/.helmignore

@@ -0,0 +1,17 @@
+.DS_Store
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+*.swp
+*.bak
+*.tmp
+*.orig
+*~
+.project
+.idea/
+*.tmproj
+.vscode/

helm/Chart.yaml

@@ -0,0 +1,29 @@
+apiVersion: v2
+name: portabase-agent
+description: Helm chart for Portabase Agent
+type: application
+version: 0.0.0
+appVersion: "latest"
+keywords:
+  - postgresql
+  - mariadb
+  - mongodb
+  - mysql
+  - sqlite
+  - backup
+  - database
+  - restore
+  - agent
+home: https://github.com/Portabase/agent
+
+sources:
+  - https://github.com/Portabase/agent
+  - https://github.com/Portabase/agent/tree/main/helm
+
+maintainers:
+  - name: Charles Gauthereau
+    url: https://github.com/RambokDev
+  - name: Killian Larcher
+    url: https://github.com/KillianLarcher
+
+icon: https://raw.githubusercontent.com/Portabase/agent/main/.github/assets/logo.png

helm/README.md

@@ -0,0 +1,59 @@
+# Development Notes
+
+## Check that Kubernetes is reachable locally
+
+```bash
+kubectl get nodes
+```
+
+## Install the local Portabase Agent Helm chart
+
+```bash
+helm install portabase-agent . \ 
+--set env.EDGE_KEY=<your-edge-key>
+```
+
+## Check the pods
+
+```bash
+kubectl get pods
+```
+
+## Check the services
+
+```bash
+kubectl get svc
+```
+
+## To update .env variables or JSON config:
+```bash
+kubectl rollout restart deployment portabase-agent
+```
+
+## Install or upgrade the Helm chart
+```bash
+helm upgrade portabase-agent . \
+--reuse-values \
+--set env.EDGE_KEY="NEW_EDGE_KEY"
+```
+
+## Rollout  to restart
+```bash 
+kubectl rollout restart deployment portabase-agent
+```
+
+## List pods to get the pod name 
+
+```bash
+kubectl get pods -l app=portabase-agent
+```
+
+## Get logs for the pod
+```bash
+kubectl logs portabase-agent-6f7d4f5c6b-abc12
+```
+
+## Uninstall Agent
+``` bash
+helm uninstall portabase-agent
+```

helm/templates/configmap.yaml

@@ -0,0 +1,7 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: portabase-agent-config
+data:
+  config.json: |
+{{ .Values.volume.configFile.content | nindent 4 }}

helm/templates/deployment.yaml

@@ -0,0 +1,62 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: portabase-agent
+  labels:
+    app: portabase-agent
+spec:
+  replicas: {{ .Values.replicaCount }}
+  selector:
+    matchLabels:
+      app: portabase-agent
+  template:
+    metadata:
+      labels:
+        app: portabase-agent
+    spec:
+      hostAliases:
+      {{- range .Values.network.hostAliases }}
+        - ip: {{ .ip }}
+          hostnames:
+        {{- range .hostnames }}
+            - {{ . }}
+        {{- end }}
+      {{- end }}
+      containers:
+        - name: portabase-agent
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          envFrom:
+            - configMapRef:
+                name: portabase-agent-env
+          volumeMounts:
+            {{- if .Values.volume.configFile.enabled }}
+              {{- if .Values.volume.configFile.hostPath }}
+            - name: config
+              mountPath: /config/config.json
+              subPath: config.json
+              readOnly: true
+              # uses hostPath
+              {{- else }}
+            - name: config
+              mountPath: /config/config.json
+              subPath: config.json
+              # uses ConfigMap content
+              {{- end }}
+            {{- end }}
+      volumes:
+        {{- if .Values.volume.configFile.enabled }}
+          {{- if .Values.volume.configFile.hostPath }}
+        - name: config
+          hostPath:
+            path: {{ .Values.volume.configFile.hostPath }}
+            type: File
+          {{- else }}
+        - name: config
+          configMap:
+            name: portabase-agent-config
+            items:
+              - key: config.json
+                path: config.json
+          {{- end }}
+        {{- end }}

helm/templates/env-configmap.yaml

@@ -0,0 +1,10 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: portabase-agent-env
+data:
+  EDGE_KEY: {{ .Values.env.EDGE_KEY | quote }}
+  TZ: {{ .Values.env.TZ | quote }}
+  POLLING: {{ .Values.env.POLLING | quote }}
+  APP_ENV: {{ .Values.env.APP_ENV | quote }}
+  LOG: {{ .Values.env.LOG | quote }}

helm/values.yaml

@@ -0,0 +1,48 @@
+replicaCount: 1
+
+image:
+  repository: portabase/agent
+  tag: latest
+  pullPolicy: IfNotPresent
+
+env:
+  EDGE_KEY: "your_edge_key_here"
+  TZ: "UTC"
+  POLLING: "5"
+  APP_ENV: "production"
+  LOG: "info"
+
+resources:
+  limits:
+    cpu: 500m
+    memory: 512Mi
+  requests:
+    cpu: 250m
+    memory: 256Mi
+
+volume:
+  configFile:
+    enabled: true
+    hostPath: ""         # Use host file if set, otherwise use `content`
+    content: |           # JSON content for config.json if no hostPath
+      {
+        "databases": [
+          {
+            "name": "my-site-prod (readable name)",
+            "database": "devdb",
+            "type": "postgresql",
+            "host": "localhost",
+            "port": 5432,
+            "username": "admin_prod",
+            "password": "super_secure_password",
+            "generated_id": "550e8400-e29b-41d4-a716-446655440000"
+          }
+        ]
+      }
+
+
+network:
+  hostAliases:
+    - ip: "127.0.0.1"
+      hostnames:
+        - "localhost"

scripts/README.md

@@ -24,3 +24,7 @@ docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT * FROM users LI
 ```bash
 docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT name FROM sqlite_master WHERE type='table';"
 ```
+
+```bash
+docker compose -f docker-compose.test.yml run agent-test bash -c "cargo clean && cargo test" 
+```

src/core/agent.rs

@@ -4,11 +4,11 @@ use crate::core::context::Context;
 use crate::services::backup::BackupService;
 use crate::services::config::ConfigService;
 use crate::services::cron::CronService;
+use crate::services::restore::RestoreService;
 use crate::services::status::StatusService;
 use crate::utils::common::BackupMethod;
 use std::sync::Arc;
 use tracing::info;
-use crate::services::restore::RestoreService;
 
 pub struct Agent {
     ctx: Arc<Context>,
@@ -43,22 +43,30 @@ impl Agent {
         let ping_result = self.status_service.ping(&config.databases).await?;
 
         for db in ping_result.databases.iter() {
+            let database = config
+                .databases
+                .iter()
+                .find(|cfg_db| cfg_db.generated_id == db.generated_id)
+                .unwrap();
             info!(
-                "Generated Id: {} | backup action: {} | restore action: {}",
-                db.generated_id, db.data.backup.action, db.data.restore.action
+                "Generated Id: {} | backup action: {} | restore action: {} | Database Name: {}",
+                db.generated_id, db.data.backup.action, db.data.restore.action, database.name,
             );
             let _ = self.cron_service.sync(db).await;
 
             if db.data.backup.action {
                 let _ = self
                     .backup_service
-                    .dispatch(&db.generated_id, &config, method.clone(), &db.storages, db.encrypt)
+                    .dispatch(
+                        &db.generated_id,
+                        &config,
+                        method.clone(),
+                        &db.storages,
+                        db.encrypt,
+                    )
                     .await;
             } else if db.data.restore.action {
-                let _ = self
-                    .restore_service
-                    .dispatch(db, &config)
-                    .await;
+                let _ = self.restore_service.dispatch(db, &config).await;
             }
         }
 

src/core/context.rs

@@ -35,7 +35,7 @@ impl Context {
                 panic!("Cannot initialize AgentContext due to invalid EDGE_KEY");
             }
         };
-        
+
         let server_url = format!("{}/api", edge_key.server_url);
         let api_client = ApiClient::new(server_url);
 

src/core/mod.rs

@@ -1,2 +1,2 @@
-pub mod context;
 pub mod agent;
+pub mod context;

src/domain/factory.rs

@@ -2,11 +2,14 @@ use crate::domain::mongodb::database::MongoDatabase;
 use crate::domain::mysql::database::MySQLDatabase;
 use crate::domain::postgres::database::PostgresDatabase;
 use crate::domain::postgres::{detect_format_from_file, detect_format_from_size};
+use crate::domain::redis::database::RedisDatabase;
+use crate::domain::sqlite::database::SqliteDatabase;
+use crate::domain::valkey::database::ValkeyDatabase;
 use crate::services::config::{DatabaseConfig, DbType};
 use anyhow::Result;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use crate::domain::sqlite::database::SqliteDatabase;
+use crate::domain::mariadb::database::MariaDBDatabase;
 
 #[async_trait::async_trait]
 pub trait Database: Send + Sync {
@@ -26,9 +29,11 @@ impl DatabaseFactory {
                 Arc::new(PostgresDatabase::new(cfg, format))
             }
             DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
-            DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
+            DbType::Mariadb => Arc::new(MariaDBDatabase::new(cfg)),
             DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
             DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
+            DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
+            DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
         }
     }
 
@@ -39,9 +44,11 @@ impl DatabaseFactory {
                 Arc::new(PostgresDatabase::new(cfg, format))
             }
             DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
-            DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
+            DbType::Mariadb => Arc::new(MariaDBDatabase::new(cfg)),
             DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
             DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
+            DbType::Redis => Arc::new(RedisDatabase::new(cfg)),
+            DbType::Valkey => Arc::new(ValkeyDatabase::new(cfg)),
         }
     }
 }

src/domain/mariadb/backup.rs

@@ -0,0 +1,66 @@
+use crate::domain::mariadb::connection::{select_mariadb_path, server_version};
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    env: HashMap<String, String>,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting backup for database {}", cfg.name);
+
+        let version = match futures::executor::block_on(server_version(&cfg)) {
+            Ok(v) => {
+                debug!("Mariadb version detected: {}", v);
+                v
+            }
+            Err(e) => {
+                error!("Failed to get server version for {}: {:?}", cfg.name, e);
+                return Err(e.into());
+            }
+        };
+
+        info!("Mariadb version found: {}", version);
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+
+        let mariadb_dump = select_mariadb_path(&version).join("mariadb-dump");
+        info!("Mariadb dump found: {}", mariadb_dump.display());
+
+        let output = Command::new("mariadb-dump")
+            .arg("--host").arg(&cfg.host)
+            .arg("--port").arg(cfg.port.to_string())
+            .arg("--user").arg(&cfg.username)
+            .arg("--routines")
+            .arg("--events")
+            .arg("--triggers")
+            .arg("--single-transaction")
+            .arg("--quick")
+            .arg("--skip-lock-tables")
+            .arg("--add-drop-database")
+            .arg("--databases").arg(&cfg.database)
+            .arg("--compress")
+            .arg("--max-allowed-packet=512M")
+            .arg("--net-buffer-length=16K")
+            .arg("--default-character-set=utf8mb4")
+            .arg("-r").arg(&file_path)
+            .envs(env)
+            .output()
+            .with_context(|| format!("Failed to run mariadb-dump for {}", cfg.name))?;
+
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            anyhow::bail!("Mariadb backup failed for {}: {}", cfg.name, stderr);
+        }
+
+        Ok(file_path)
+    })
+    .await?
+}

src/domain/mariadb/connection.rs

@@ -0,0 +1,45 @@
+use std::path::PathBuf;
+use crate::services::config::DatabaseConfig;
+use anyhow::Result;
+use std::process::Command;
+
+pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
+    let output = Command::new("mariadb")
+        .arg("--host")
+        .arg(&cfg.host)
+        .arg("--port")
+        .arg(cfg.port.to_string())
+        .arg("--user")
+        .arg(&cfg.username)
+        .arg("-e")
+        .arg("SELECT VERSION();")
+        .env("MYSQL_PWD", &cfg.password)
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        anyhow::bail!("Version query failed: {}", stderr);
+    }
+
+    let version = String::from_utf8_lossy(&output.stdout)
+        .lines()
+        .nth(1)
+        .unwrap_or_default()
+        .trim()
+        .to_string();
+
+    Ok(version)
+}
+
+
+pub fn select_mariadb_path(version: &str) -> PathBuf {
+    let mut parts = version.split('.');
+    let major = parts.next().and_then(|v| v.parse::<u32>().ok()).unwrap_or(10);
+    let minor = parts.next().and_then(|v| v.parse::<u32>().ok()).unwrap_or(0);
+
+    if major < 10 || (major == 10 && minor <= 6) {
+        "/usr/local/mariadb-10.6/bin".into()
+    } else {
+        "/usr/local/mariadb-12.1/bin".into()
+    }
+}

src/domain/mariadb/database.rs

@@ -0,0 +1,55 @@
+use super::{backup, ping, restore};
+use crate::domain::factory::Database;
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+use anyhow::Result;
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+pub struct MariaDBDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl MariaDBDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+
+    fn build_env(&self) -> HashMap<String, String> {
+        let mut envs = std::env::vars().collect::<HashMap<_, _>>();
+        envs.insert("MYSQL_PWD".to_string(), self.cfg.password.to_string());
+        envs
+    }
+}
+
+#[async_trait]
+impl Database for MariaDBDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".sql"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone(), self.build_env().clone()).await
+    }
+
+    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        let res = backup::run(
+            self.cfg.clone(),
+            dir.to_path_buf(),
+            self.build_env().clone(),
+            self.file_extension(),
+        )
+        .await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, file: &Path) -> Result<()> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+}

src/domain/mariadb/mod.rs

@@ -0,0 +1,5 @@
+pub mod backup;
+mod connection;
+pub mod database;
+mod ping;
+mod restore;

src/domain/mariadb/ping.rs

@@ -0,0 +1,28 @@
+use crate::services::config::DatabaseConfig;
+use std::collections::HashMap;
+use tokio::process::Command;
+use tokio::time::{Duration, timeout};
+
+pub async fn run(cfg: DatabaseConfig, env: HashMap<String, String>) -> anyhow::Result<bool> {
+    let mut cmd = Command::new("mysqladmin");
+    cmd.arg("--host")
+        .arg(cfg.host)
+        .arg("--port")
+        .arg(cfg.port.to_string())
+        .arg("--user")
+        .arg(cfg.username)
+        .arg("ping")
+        .envs(env);
+
+    let result = timeout(Duration::from_secs(10), cmd.output()).await;
+
+    match result {
+        Ok(output) => {
+            let output = output?;
+            Ok(output.status.success())
+        }
+        Err(_) => Ok(false),
+    }
+}
+
+

src/domain/mariadb/restore.rs

@@ -0,0 +1,80 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
+    let handle = tokio::task::spawn_blocking(move || -> Result<()> {
+        debug!("Starting restore for database {}", cfg.name);
+
+        let mut sql_content = String::new();
+        let mut file = File::open(&restore_file)
+            .with_context(|| format!("Failed to open restore file {}", restore_file.display()))?;
+        file.read_to_string(&mut sql_content)
+            .with_context(|| format!("Failed to read restore file {}", restore_file.display()))?;
+
+        let drop_create_cmd = format!(
+            "DROP DATABASE IF EXISTS {0}; CREATE DATABASE {0};",
+            cfg.database
+        );
+
+        let drop_status = Command::new("mariadb")
+            .arg("--host")
+            .arg(&cfg.host)
+            .arg("--port")
+            .arg(cfg.port.to_string())
+            .arg("--user")
+            .arg(&cfg.username)
+            .arg("-e")
+            .arg(&drop_create_cmd)
+            .env("MYSQL_PWD", &cfg.password)
+            .status()
+            .with_context(|| format!("Failed to drop/recreate database {}", cfg.name))?;
+
+        if !drop_status.success() {
+            error!("Drop/create database failed for {}", cfg.name);
+            anyhow::bail!("Failed to drop/recreate database {}", cfg.name);
+        }
+        info!("Database {} dropped and recreated", cfg.name);
+
+        let mut child = Command::new("mariadb")
+            .arg("--host")
+            .arg(&cfg.host)
+            .arg("--port")
+            .arg(cfg.port.to_string())
+            .arg("--user")
+            .arg(&cfg.username)
+            .arg(&cfg.database)
+            .env("MYSQL_PWD", &cfg.password)
+            .stdin(std::process::Stdio::piped())
+            .spawn()
+            .with_context(|| format!("Failed to start MariaDB restore for {}", cfg.name))?;
+
+        let mut stdin = child.stdin.take().context("Failed to open child stdin")?;
+        stdin
+            .write_all(sql_content.as_bytes())
+            .context("Failed to write SQL content to MariaDB stdin")?;
+        stdin.flush()?;
+        drop(stdin);
+
+        let output = child
+            .wait_with_output()
+            .with_context(|| format!("Failed to complete MariaDB restore for {}", cfg.name))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("MariaDB restore failed for {}: {}", cfg.name, stderr);
+            anyhow::bail!("MariaDB restore failed for {}", cfg.name);
+        }
+
+        info!("Restore finished successfully for database {}", cfg.name);
+        Ok(())
+    });
+
+    handle.await??;
+
+    Ok(())
+}

src/domain/mod.rs

@@ -1,6 +1,8 @@
 pub mod factory;
-pub mod postgres;
-pub mod mysql;
 mod mongodb;
+pub mod mysql;
+pub mod postgres;
+mod redis;
 mod sqlite;
-
+mod valkey;
+mod mariadb;

src/domain/mongodb/backup.rs

@@ -15,6 +15,7 @@ pub async fn run(
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
         let mongodump = select_mongo_path().join("mongodump");
+        info!("{:?}", mongodump);
         let uri = get_mongo_uri(cfg.clone())?;
 
         let output = Command::new(mongodump)

src/domain/mongodb/connection.rs

@@ -16,9 +16,11 @@ pub fn select_mongo_path() -> std::path::PathBuf {
 }
 
 pub fn get_mongo_uri(cfg: DatabaseConfig) -> Result<String> {
-
     if cfg.username.is_empty() || cfg.password.is_empty() {
-        Ok(format!("mongodb://{}:{}/{}", cfg.host, cfg.port, cfg.database))
+        Ok(format!(
+            "mongodb://{}:{}/{}",
+            cfg.host, cfg.port, cfg.database
+        ))
     } else {
         Ok(format!(
             "mongodb://{}:{}@{}:{}/{}?authSource=admin",
@@ -26,5 +28,3 @@ pub fn get_mongo_uri(cfg: DatabaseConfig) -> Result<String> {
         ))
     }
 }
-
-

src/domain/mongodb/database.rs

@@ -29,12 +29,7 @@ impl Database for MongoDatabase {
 
     async fn backup(&self, dir: &Path) -> Result<PathBuf> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
-        let res = backup::run(
-            self.cfg.clone(),
-            dir.to_path_buf(),
-            self.file_extension(),
-        )
-            .await;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/mongodb/mod.rs

@@ -1,5 +1,5 @@
 mod backup;
-mod restore;
+mod connection;
 pub mod database;
 mod ping;
-mod connection;
+mod restore;

src/domain/mongodb/ping.rs

@@ -24,7 +24,7 @@ pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
             error!("Full Error: {}", e);
             error!("Check you database network connectivity");
             error!("----------------------------------------");
-            Err(anyhow::anyhow!("Ping failed for {}: {}", cfg.name, e))
+            Ok(false)
         }
     }
 }

src/domain/mysql/backup.rs

@@ -1,4 +1,4 @@
-use crate::domain::mysql::connection::{server_version};
+use crate::domain::mysql::connection::server_version;
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::collections::HashMap;
@@ -30,6 +30,9 @@ pub async fn run(
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
 
+        // let mysql_dump = select_mysql_path(&version).join("mysqldump");
+        // info!("MySQL dump found: {}", mysql_dump.display());
+
         let output = Command::new("mysqldump")
             .arg("--host")
             .arg(cfg.host)
@@ -54,9 +57,12 @@ pub async fn run(
 
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
+            info!("mysqldump stderr: {}", stderr);
             anyhow::bail!("MySQL backup failed for {}: {}", cfg.name, stderr);
         }
 
+        info!("Output {}", String::from_utf8_lossy(&output.stdout));
+
         Ok(file_path)
     })
     .await?

src/domain/mysql/connection.rs

@@ -1,14 +1,17 @@
 use crate::services::config::DatabaseConfig;
-use std::process::Command;
 use anyhow::Result;
+use std::process::Command;
 
 pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
-
     let output = Command::new("mysql")
-        .arg("--host").arg(&cfg.host)
-        .arg("--port").arg(cfg.port.to_string())
-        .arg("--user").arg(&cfg.username)
-        .arg("-e").arg("SELECT VERSION();")
+        .arg("--host")
+        .arg(&cfg.host)
+        .arg("--port")
+        .arg(cfg.port.to_string())
+        .arg("--user")
+        .arg(&cfg.username)
+        .arg("-e")
+        .arg("SELECT VERSION();")
         .env("MYSQL_PWD", &cfg.password)
         .output()?;
 
@@ -19,11 +22,10 @@ pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
 
     let version = String::from_utf8_lossy(&output.stdout)
         .lines()
-        .nth(1) // skip column header
+        .nth(1)
         .unwrap_or_default()
         .trim()
         .to_string();
 
     Ok(version)
 }
-

src/domain/mysql/database.rs

@@ -1,14 +1,11 @@
-use std::collections::HashMap;
-use anyhow::Result;
-use async_trait::async_trait;
-use std::path::{Path, PathBuf};
-use super::{
-    backup,
-    ping, restore,
-};
+use super::{backup, ping, restore};
 use crate::domain::factory::Database;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};
+use anyhow::Result;
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
 
 pub struct MySQLDatabase {
     cfg: DatabaseConfig,
@@ -38,7 +35,13 @@ impl Database for MySQLDatabase {
 
     async fn backup(&self, dir: &Path) -> Result<PathBuf> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
-        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.build_env().clone(), self.file_extension()).await;
+        let res = backup::run(
+            self.cfg.clone(),
+            dir.to_path_buf(),
+            self.build_env().clone(),
+            self.file_extension(),
+        )
+        .await;
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }

src/domain/mysql/mod.rs

@@ -1,5 +1,5 @@
 pub mod backup;
+mod connection;
 pub mod database;
-mod restore;
 mod ping;
-mod connection;
+mod restore;

src/domain/mysql/ping.rs

@@ -4,8 +4,7 @@ use tokio::process::Command;
 use tokio::time::{Duration, timeout};
 
 pub async fn run(cfg: DatabaseConfig, env: HashMap<String, String>) -> anyhow::Result<bool> {
-
-    let mut cmd = Command::new("mysqladmin");
+    let mut cmd = Command::new("mariadb-admin");
     cmd.arg("--host")
         .arg(cfg.host)
         .arg("--port")

src/domain/postgres/backup.rs

@@ -27,6 +27,7 @@ pub async fn run(
         };
 
         let pg_dump = select_pg_path(&version).join("pg_dump");
+
         debug!("Using pg_dump at {:?}", pg_dump);
 
         match format {

src/domain/postgres/database.rs

@@ -2,11 +2,7 @@ use anyhow::Result;
 use async_trait::async_trait;
 use std::path::{Path, PathBuf};
 
-use super::{
-    backup,
-    format::PostgresDumpFormat,
-    ping, restore,
-};
+use super::{backup, format::PostgresDumpFormat, ping, restore};
 use crate::domain::factory::Database;
 use crate::services::config::DatabaseConfig;
 use crate::utils::locks::{DbOpLock, FileLock};

src/domain/postgres/format.rs

@@ -2,4 +2,4 @@
 pub enum PostgresDumpFormat {
     Fc,
     Fd,
-}
+}

src/domain/postgres/mod.rs

@@ -1,8 +1,8 @@
 pub mod backup;
-pub mod database;
-mod restore;
 mod connection;
+pub mod database;
 mod format;
 mod ping;
+mod restore;
 
-pub use connection::{detect_format_from_size, detect_format_from_file};
+pub use connection::{detect_format_from_file, detect_format_from_size};

src/domain/postgres/ping.rs

@@ -1,8 +1,6 @@
 use super::connection::connect;
 use crate::services::config::DatabaseConfig;
 
-pub async fn run(
-    cfg: DatabaseConfig,
-) -> anyhow::Result<bool> {
+pub async fn run(cfg: DatabaseConfig) -> anyhow::Result<bool> {
     Ok(connect(&cfg).await.is_ok())
-}
+}

src/domain/postgres/restore.rs

@@ -27,6 +27,7 @@ pub async fn run(
         };
 
         let pg_restore = select_pg_path(&version).join("pg_restore");
+
         debug!("Using pg_restore at {:?}", pg_restore);
 
         if let Err(e) = futures::executor::block_on(terminate_connections(&cfg)) {

src/domain/redis/backup.rs

@@ -0,0 +1,65 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting Redis backup for database {}", cfg.name);
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+
+        let mut cmd = Command::new("redis-cli");
+
+        cmd.arg("-h")
+            .arg(&cfg.host)
+            .arg("-p")
+            .arg(cfg.port.to_string());
+
+        if !cfg.username.is_empty() {
+            cmd.arg("--user").arg(&cfg.username);
+        }
+
+        if !cfg.password.is_empty() {
+            cmd.arg("-a").arg(&cfg.password);
+        }
+
+        cmd.arg("--rdb").arg(&file_path);
+
+        debug!("Command Backup: {:?}", cmd);
+
+        let output = cmd.output().context("Redis backup command failed")?;
+
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+
+        if !output.status.success() {
+            if stderr.contains("NOAUTH") {
+                error!(
+                    "Redis backup failed for {}: Authentication required (NOAUTH)",
+                    cfg.name
+                );
+                anyhow::bail!(
+                    "Redis backup failed for {}: Authentication required",
+                    cfg.name
+                );
+            } else {
+                error!("Redis backup failed for {}: {}", cfg.name, stderr);
+                anyhow::bail!("Redis backup failed for {}: {}", cfg.name, stderr);
+            }
+        }
+
+        info!(
+            "Redis backup completed for {}. Output: {}",
+            cfg.name, stdout
+        );
+
+        Ok(file_path)
+    })
+    .await?
+}

src/domain/redis/database.rs

@@ -0,0 +1,40 @@
+use anyhow::{Result, bail};
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+
+use crate::domain::factory::Database;
+use crate::domain::redis::{backup, ping};
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+
+pub struct RedisDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl RedisDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for RedisDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".rdb"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, _file: &Path) -> Result<()> {
+        bail!("Restore not supported for Redis databases")
+    }
+}

src/domain/redis/mod.rs

@@ -0,0 +1,3 @@
+mod backup;
+pub mod database;
+mod ping;

src/domain/redis/ping.rs

@@ -0,0 +1,55 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use tokio::process::Command;
+use tokio::time::{Duration, timeout};
+use tracing::{debug, error, info};
+
+pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
+    let mut cmd = Command::new("redis-cli");
+    cmd.arg("-h")
+        .arg(&cfg.host)
+        .arg("-p")
+        .arg(cfg.port.to_string());
+
+    if !cfg.username.is_empty() {
+        cmd.arg("--user").arg(&cfg.username);
+    }
+
+    if !cfg.password.is_empty() {
+        cmd.arg("-a").arg(&cfg.password);
+    }
+
+    cmd.arg("PING");
+
+    debug!("Command Ping Redis: {:?}", cmd);
+
+    let result = timeout(Duration::from_secs(10), cmd.output()).await;
+
+    match result {
+        Ok(output) => {
+            let output = output.context("Failed to execute redis-cli")?;
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            let stderr = String::from_utf8_lossy(&output.stderr);
+
+            if !stdout.is_empty() {
+                error!("Redis stderr: {}", stderr);
+            }
+
+            if stderr.contains("NOAUTH") {
+                error!("Redis authentication failed (NOAUTH required)");
+                return Ok(false);
+            }
+
+            if !output.status.success() {
+                error!("Redis command failed with status: {:?}", output.status);
+                return Ok(false);
+            }
+
+            Ok(stdout.contains("PONG"))
+        }
+        Err(_) => {
+            info!("Timeout connecting to Redis at {}:{}", cfg.host, cfg.port);
+            Ok(false)
+        }
+    }
+}

src/domain/sqlite/backup.rs

@@ -41,5 +41,5 @@ pub async fn run(
         info!("SQLite backup completed for {}", cfg.name);
         Ok(file_path)
     })
-        .await?
-}
+    .await?
+}

src/domain/sqlite/database.rs

@@ -33,7 +33,6 @@ impl Database for SqliteDatabase {
         FileLock::release(&self.cfg.generated_id).await?;
         res
     }
-
     async fn restore(&self, file: &Path) -> Result<()> {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
         let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;

src/domain/sqlite/mod.rs

@@ -1,4 +1,4 @@
 mod backup;
-mod restore;
+pub mod database;
 mod ping;
-pub mod database;
+mod restore;

src/domain/valkey/backup.rs

@@ -0,0 +1,65 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting Valkey backup for database {}", cfg.name);
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+
+        let mut cmd = Command::new("valkey-cli");
+
+        cmd.arg("-h")
+            .arg(&cfg.host)
+            .arg("-p")
+            .arg(cfg.port.to_string());
+
+        if !cfg.username.is_empty() {
+            cmd.arg("--user").arg(&cfg.username);
+        }
+
+        if !cfg.password.is_empty() {
+            cmd.arg("-a").arg(&cfg.password);
+        }
+
+        cmd.arg("--rdb").arg(&file_path);
+
+        debug!("Command Backup: {:?}", cmd);
+
+        let output = cmd.output().context("Valkey backup command failed")?;
+
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+
+        if !output.status.success() {
+            if stderr.contains("NOAUTH") {
+                error!(
+                    "Valkey backup failed for {}: Authentication required (NOAUTH)",
+                    cfg.name
+                );
+                anyhow::bail!(
+                    "Valkey backup failed for {}: Authentication required",
+                    cfg.name
+                );
+            } else {
+                error!("Valkey backup failed for {}: {}", cfg.name, stderr);
+                anyhow::bail!("Valkey backup failed for {}: {}", cfg.name, stderr);
+            }
+        }
+
+        info!(
+            "Valkey backup completed for {}. Output: {}",
+            cfg.name, stdout
+        );
+
+        Ok(file_path)
+    })
+    .await?
+}

src/domain/valkey/database.rs

@@ -0,0 +1,40 @@
+use anyhow::{Result, bail};
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+
+use crate::domain::factory::Database;
+use crate::domain::valkey::{backup, ping};
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+
+pub struct ValkeyDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl ValkeyDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for ValkeyDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".rdb"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, _file: &Path) -> Result<()> {
+        bail!("Restore not supported for Valkey databases")
+    }
+}

src/domain/valkey/mod.rs

@@ -0,0 +1,3 @@
+mod backup;
+pub mod database;
+mod ping;

src/domain/valkey/ping.rs

@@ -0,0 +1,55 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use tokio::process::Command;
+use tokio::time::{Duration, timeout};
+use tracing::{debug, info, error};
+
+pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
+    let mut cmd = Command::new("valkey-cli");
+    cmd.arg("-h")
+        .arg(&cfg.host)
+        .arg("-p")
+        .arg(cfg.port.to_string());
+
+    if !cfg.username.is_empty() {
+        cmd.arg("--user").arg(&cfg.username);
+    }
+
+    if !cfg.password.is_empty() {
+        cmd.arg("-a").arg(&cfg.password);
+    }
+
+    cmd.arg("PING");
+
+    debug!("Command Ping Valkey: {:?}", cmd);
+
+    let result = timeout(Duration::from_secs(10), cmd.output()).await;
+
+    match result {
+        Ok(output) => {
+            let output = output.context("Failed to execute valkey-cli")?;
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            let stderr = String::from_utf8_lossy(&output.stderr);
+
+            if !stdout.is_empty() {
+                error!("Valkey stderr: {}", stderr);
+            }
+
+            if stderr.contains("NOAUTH") {
+                error!("Valkey authentication failed (NOAUTH required)");
+                return Ok(false);
+            }
+
+            if !output.status.success() {
+                error!("Valkey command failed with status: {:?}", output.status);
+                return Ok(false);
+            }
+
+            Ok(stdout.contains("PONG"))
+        }
+        Err(_) => {
+            info!("Timeout connecting to Valkey at {}:{}", cfg.host, cfg.port);
+            Ok(false)
+        }
+    }
+}

src/main.rs

@@ -3,17 +3,18 @@ mod domain;
 mod services;
 mod settings;
 mod tasks;
+#[cfg(test)]
+mod tests;
 mod utils;
 
 use crate::tasks::ping::ping_server;
 use crate::utils::locks::FileLock;
+use crate::utils::logging;
 use utils::redis_client;
 use utils::task_manager::scheduler;
-use crate::utils::logging;
 
 #[tokio::main]
 async fn main() {
-
     logging::init_logger();
 
     // Remove all locks on startup

src/services/api/client.rs

@@ -1,9 +1,9 @@
 #![allow(dead_code)]
 
+use crate::services::api::ApiError;
 use reqwest::{Client, Method};
 use serde::de::DeserializeOwned;
 use std::time::Duration;
-use crate::services::api::ApiError;
 
 #[derive(Clone, Debug)]
 pub struct ApiClient {
@@ -57,12 +57,7 @@ impl ApiClient {
     {
         let url = format!("{}{}", self.base_url, path);
 
-        let res = self
-            .http
-            .request(method, &url)
-            .json(body)
-            .send()
-            .await?;
+        let res = self.http.request(method, &url).json(body).send().await?;
 
         let status = res.status();
         let body_text = res.text().await.unwrap_or_default();

src/services/api/endpoints/agent/backup/mod.rs

@@ -23,7 +23,6 @@ pub struct BackupUpdateRequest {
     pub generated_id: String,
 }
 
-
 impl ApiClient {
     pub async fn backup_create(
         &self,

src/services/api/endpoints/agent/backup/upload/init.rs

@@ -1,8 +1,8 @@
+use crate::services::api::models::agent::backup::BackupUploadResponse;
 use crate::services::api::{ApiClient, ApiError};
 use anyhow::Result;
 use reqwest::Method;
 use serde::Serialize;
-use crate::services::api::models::agent::backup::BackupUploadResponse;
 
 #[derive(Serialize)]
 pub struct InitUploadRequest {

src/services/api/endpoints/agent/backup/upload/mod.rs

@@ -1,2 +1,2 @@
 pub mod init;
-pub mod status;
+pub mod status;

src/services/api/endpoints/agent/mod.rs

@@ -1,3 +1,3 @@
-pub mod status;
 pub mod backup;
-pub mod restore;
+pub mod restore;
+pub mod status;

src/services/api/endpoints/agent/status.rs

@@ -11,6 +11,8 @@ pub struct DatabasePayload<'a> {
     pub dbms: &'a str,
     #[serde(rename = "generatedId")]
     pub generated_id: &'a str,
+    #[serde(rename = "pingStatus")]
+    pub ping_status: bool
 }
 
 #[derive(Serialize)]
@@ -31,6 +33,7 @@ impl ApiClient {
         let agent_id = agent_id.into();
         let path = format!("/agent/{}/status", agent_id);
 
-        self.request_with_body(Method::POST, path.as_str(), &body).await
+        self.request_with_body(Method::POST, path.as_str(), &body)
+            .await
     }
-}
+}

src/services/api/endpoints/mod.rs

@@ -1,3 +1,3 @@
 pub mod agent;
 
-pub use agent::status;
+pub use agent::status;

src/services/api/error.rs

@@ -11,10 +11,7 @@ pub enum ApiError {
     Serialization(#[from] serde_json::Error),
 
     #[error("api error: status={status}, body={body}")]
-    HttpResponse {
-        status: StatusCode,
-        body: String,
-    },
+    HttpResponse { status: StatusCode, body: String },
 
     #[error("api returned unexpected response")]
     UnexpectedResponse,

src/services/api/mod.rs

@@ -1,8 +1,7 @@
 pub mod client;
+pub mod endpoints;
 pub mod error;
 pub mod models;
-pub mod endpoints;
 
 pub use client::ApiClient;
 pub use error::ApiError;
-

src/services/api/models/agent/mod.rs

@@ -1,3 +1,3 @@
-pub mod status;
 pub mod backup;
-pub mod restore;
+pub mod restore;
+pub mod status;

src/services/api/models/agent/restore.rs

@@ -4,4 +4,4 @@ use serde::{Deserialize, Serialize};
 pub struct ResultRestoreResponse {
     pub message: String,
     pub status: bool,
-}
+}

src/services/api/models/agent/status.rs

@@ -1,8 +1,8 @@
 #![allow(dead_code)]
 
+use crate::utils::deserializer::deserialize_snake_case;
 use serde::{Deserialize, Serialize};
 use toml::Value;
-use crate::utils::deserializer::deserialize_snake_case;
 
 #[derive(Debug, Deserialize)]
 pub struct PingResult {

src/services/api/models/mod.rs

@@ -1,2 +1 @@
 pub mod agent;
-

src/services/backup/compressor.rs

@@ -1,20 +1,14 @@
 use super::service::BackupService;
 use crate::utils::compress::compress_to_tar_gz_large;
-use std::path::PathBuf;
 use anyhow::Result;
+use std::path::PathBuf;
 
 impl BackupService {
-
-    pub async fn compress_backup(
-        &self,
-        backup_file: Option<PathBuf>,
-    ) -> Result<PathBuf> {
-
-        let file = backup_file
-            .ok_or_else(|| anyhow::anyhow!("No backup file generated"))?;
+    pub async fn compress_backup(&self, backup_file: Option<PathBuf>) -> Result<PathBuf> {
+        let file = backup_file.ok_or_else(|| anyhow::anyhow!("No backup file generated"))?;
 
         let compression = compress_to_tar_gz_large(&file).await?;
 
         Ok(compression.compressed_path)
     }
-}
+}

src/services/backup/dispatcher.rs

@@ -1,11 +1,10 @@
 use super::service::BackupService;
-use crate::services::config::DatabasesConfig;
 use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::config::DatabasesConfig;
 use crate::utils::common::BackupMethod;
 use tracing::error;
 
 impl BackupService {
-
     pub async fn dispatch(
         &self,
         generated_id: &String,
@@ -14,7 +13,6 @@ impl BackupService {
         storages: &Vec<DatabaseStorage>,
         encrypt: bool,
     ) {
-
         let Some(cfg) = config
             .databases
             .iter()
@@ -41,4 +39,4 @@ impl BackupService {
             }
         });
     }
-}
+}

src/services/backup/executor.rs

@@ -1,14 +1,13 @@
 use super::service::BackupService;
-use crate::services::config::DatabaseConfig;
 use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::config::DatabaseConfig;
 use crate::utils::common::BackupMethod;
 use crate::utils::locks::FileLock;
 
-use tempfile::TempDir;
 use anyhow::Result;
+use tempfile::TempDir;
 
 impl BackupService {
-
     pub async fn execute_backup(
         &self,
         generated_id: String,
@@ -17,11 +16,10 @@ impl BackupService {
         storages: Vec<DatabaseStorage>,
         encrypt: bool,
     ) -> Result<()> {
-
         if FileLock::is_locked(&generated_id).await? {
             anyhow::bail!("backup already running");
         }
-        
+
         let backup = self.create_backup_record(&generated_id, &method).await?;
         let backup_id = backup.backup.id;
 
@@ -46,4 +44,4 @@ impl BackupService {
 
         Ok(())
     }
-}
+}

src/services/backup/helpers.rs

@@ -1,16 +1,14 @@
 use super::service::BackupService;
+use crate::services::api::models::agent::backup::BackupResponse;
 use crate::utils::common::BackupMethod;
 use anyhow::{Result, anyhow};
-use crate::services::api::models::agent::backup::BackupResponse;
 
 impl BackupService {
-
     pub async fn create_backup_record(
         &self,
         generated_id: &str,
         method: &BackupMethod,
     ) -> Result<BackupResponse> {
-
         let response = self
             .ctx
             .api
@@ -23,4 +21,4 @@ impl BackupService {
 
         response.ok_or_else(|| anyhow!("backup_create returned empty response"))
     }
-}
+}

src/services/backup/mod.rs

@@ -1,11 +1,11 @@
-pub mod service;
+pub mod compressor;
 pub mod dispatcher;
 pub mod executor;
-pub mod compressor;
-pub mod uploader;
-pub mod result;
-pub mod models;
 pub mod helpers;
+pub mod models;
+pub mod result;
 pub mod runner;
+pub mod service;
+pub mod uploader;
 
-pub use service::BackupService;
+pub use service::BackupService;

src/services/backup/models.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
-use std::path::PathBuf;
 use crate::services::config::DbType;
+use std::path::PathBuf;
 
 #[derive(Debug, Clone)]
 pub struct BackupResult {
@@ -19,4 +19,4 @@ pub struct UploadResult {
     pub error: Option<String>,
     pub remote_file_path: Option<String>,
     pub total_size: Option<u64>,
-}
+}

src/services/backup/runner.rs

@@ -9,12 +9,7 @@ use std::path::Path;
 use tracing::{error, info};
 
 impl BackupService {
-
-    pub async fn run(
-        cfg: DatabaseConfig,
-        tmp_path: &Path,
-    ) -> Result<BackupResult> {
-
+    pub async fn run(cfg: DatabaseConfig, tmp_path: &Path) -> Result<BackupResult> {
         let db = DatabaseFactory::create_for_backup(cfg.clone()).await;
 
         let generated_id = cfg.generated_id.clone();
@@ -41,7 +36,6 @@ impl BackupService {
         }
 
         match db.backup(tmp_path).await {
-
             Ok(file) => Ok(BackupResult {
                 generated_id,
                 db_type,
@@ -67,4 +61,4 @@ impl BackupService {
             }),
         }
     }
-}
+}