Merge branch 'staging' into feat/valkey

.github/workflows/close_old_issues_and_prs.yml

@@ -14,7 +14,7 @@ jobs:
       pull-requests: write
     steps:
       - name: Mark/Close Stale Issues and Pull Requests 🗑️
-        uses: actions/stale@v10.1.1
+        uses: actions/stale@v10.1.0
         with:
           repo-token: ${{ secrets.STALE_ACTION_PAT }}
           days-before-stale: 60

.github/workflows/image_builds.yml

@@ -15,7 +15,7 @@ jobs:
         images:
           - "acme-mailcow"
           - "clamd-mailcow"
-          - "controller-mailcow"
+          - "dockerapi-mailcow"
           - "dovecot-mailcow"
           - "netfilter-mailcow"
           - "olefy-mailcow"
@@ -27,7 +27,7 @@ jobs:
           - "watchdog-mailcow"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - name: Setup Docker
         run: |
           curl -sSL https://get.docker.com/ | CHANNEL=stable sudo sh

.github/workflows/pr_to_nightly.yml

@@ -8,11 +8,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Run the Action
-        uses: devops-infra/action-pull-request@v1.0.2
+        uses: devops-infra/action-pull-request@v0.6.1
         with:
           github_token: ${{ secrets.PRTONIGHTLY_ACTION_PAT }}
           title: Automatic PR to nightly from ${{ github.event.repository.updated_at}}

.github/workflows/rebuild_backup_image.yml

@@ -13,7 +13,7 @@ jobs:
       packages: write
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3

.github/workflows/update_postscreen_access_list.yml

@@ -15,14 +15,14 @@ jobs:
    runs-on: ubuntu-latest
    steps:
     - name: Checkout
-      uses: actions/checkout@v6
+      uses: actions/checkout@v5
 
     - name: Generate postscreen_access.cidr
       run: |
           bash helper-scripts/update_postscreen_whitelist.sh
 
     - name: Create Pull Request
-      uses: peter-evans/create-pull-request@v8
+      uses: peter-evans/create-pull-request@v7
       with:
         token: ${{ secrets.mailcow_action_Update_postscreen_access_cidr_pat }}
         commit-message: update postscreen_access.cidr

CONTRIBUTING.md

@@ -1,11 +1,11 @@
 # Contribution Guidelines
-**_Last modified on 12th November 2025_**
+**_Last modified on 15th August 2024_**
 
 First of all, thank you for wanting to provide a bugfix or a new feature for the mailcow community, it's because of your help that the project can continue to grow!
 
 As we want to keep mailcow's development structured we setup these Guidelines which helps you to create your issue/pull request accordingly.
 
-**PLEASE NOTE, THAT WE WILL CLOSE ISSUES/PULL REQUESTS IF THEY DON'T FULFILL OUR WRITTEN GUIDELINES WRITTEN INSIDE THIS DOCUMENT**. So please check this guidelines before you propose a Issue/Pull Request.
+**PLEASE NOTE, THAT WE MIGHT CLOSE ISSUES/PULL REQUESTS IF THEY DON'T FULLFIL OUR WRITTEN GUIDELINES WRITTEN INSIDE THIS DOCUMENT**. So please check this guidelines before you propose a Issue/Pull Request.
 
 ## Topics
 
@@ -27,18 +27,14 @@ However, please note the following regarding pull requests:
 6. Please **ALWAYS** create the actual pull request against the staging branch and **NEVER** directly against the master branch. *If you forget to do this, our moobot will remind you to switch the branch to staging.*
 7. Wait for a merge commit: It may happen that we do not accept your pull request immediately or sometimes not at all for various reasons. Please do not be disappointed if this is the case. We always endeavor to incorporate any meaningful changes from the community into the mailcow project.
 8. If you are planning larger and therefore more complex pull requests, it would be advisable to first announce this in a separate issue and then start implementing it after the idea has been accepted in order to avoid unnecessary frustration and effort!
-9. If your PR requires a Docker image rebuild (changes to Dockerfiles or files in data/Dockerfiles/), update the image tag in docker-compose.yml. Use the base-image versioning (e.g. ghcr.io/mailcow/sogo:5.12.4 → :5.12.5 for version bumps; append a letter for patch fixes, e.g. :5.12.4a). Follow this scheme.
 
 ---
 
 ## Issue Reporting
-**_Last modified on 12th November 2025_**
+**_Last modified on 15th August 2024_**
 
 If you plan to report a issue within mailcow please read and understand the following rules:
 
-### Security disclosures / Security-related fixes
-- Security vulnerabilities and security fixes must always be reported confidentially first to the contact address specified in SECURITY.md before they are integrated, published, or publicly disclosed in issues/PRs. Please wait for a response from the specified contact to ensure coordinated and responsible disclosure.
-
 ### Issue Reporting Guidelines
 
 1. **ONLY** use the issue tracker for bug reports or improvement requests and NOT for support questions. For support questions you can either contact the [mailcow community on Telegram](https://docs.mailcow.email/#community-support-and-chat) or the mailcow team directly in exchange for a [support fee](https://docs.mailcow.email/#commercial-support).

_modules/scripts/core.sh

@@ -38,45 +38,45 @@ get_docker_version(){
 }
 
 get_compose_type(){
-  if docker compose > /dev/null 2>&1; then
-    if docker compose version --short | grep -e "^[2-9]\." -e "^v[2-9]\." -e "^[1-9][0-9]\." -e "^v[1-9][0-9]\." > /dev/null 2>&1; then
-      COMPOSE_VERSION=native
-      COMPOSE_COMMAND="docker compose"
-      if [[ "$caller" == "update.sh" ]]; then
-        sed -i 's/^DOCKER_COMPOSE_VERSION=.*/DOCKER_COMPOSE_VERSION=native/' "$SCRIPT_DIR/mailcow.conf"
-      fi
-      echo -e "\e[33mFound Docker Compose Plugin (native).\e[0m"
-      echo -e "\e[33mSetting the DOCKER_COMPOSE_VERSION Variable to native\e[0m"
-      sleep 2
-      echo -e "\e[33mNotice: You'll have to update this Compose Version via your Package Manager manually!\e[0m"
-    else
-      echo -e "\e[31mCannot find Docker Compose with a Version Higher than 2.X.X.\e[0m"
-      echo -e "\e[31mPlease update/install it manually regarding to this doc site: https://docs.mailcow.email/install/\e[0m"
-      exit 1
+    if docker compose > /dev/null 2>&1; then
+        if docker compose version --short | grep -e "^2." -e "^v2." > /dev/null 2>&1; then
+            COMPOSE_VERSION=native
+            COMPOSE_COMMAND="docker compose"
+            if [[ "$caller" == "update.sh" ]]; then
+                sed -i 's/^DOCKER_COMPOSE_VERSION=.*/DOCKER_COMPOSE_VERSION=native/' "$SCRIPT_DIR/mailcow.conf"
+            fi
+            echo -e "\e[33mFound Docker Compose Plugin (native).\e[0m"
+            echo -e "\e[33mSetting the DOCKER_COMPOSE_VERSION Variable to native\e[0m"
+            sleep 2
+            echo -e "\e[33mNotice: You'll have to update this Compose Version via your Package Manager manually!\e[0m"
+        else
+            echo -e "\e[31mCannot find Docker Compose with a Version Higher than 2.X.X.\e[0m"
+            echo -e "\e[31mPlease update/install it manually regarding to this doc site: https://docs.mailcow.email/install/\e[0m"
+            exit 1
+        fi
+    elif docker-compose > /dev/null 2>&1; then
+    if ! [[ $(alias docker-compose 2> /dev/null) ]] ; then
+        if docker-compose version --short | grep "^2." > /dev/null 2>&1; then
+            COMPOSE_VERSION=standalone
+            COMPOSE_COMMAND="docker-compose"
+            if [[ "$caller" == "update.sh" ]]; then
+                sed -i 's/^DOCKER_COMPOSE_VERSION=.*/DOCKER_COMPOSE_VERSION=standalone/' "$SCRIPT_DIR/mailcow.conf"
+            fi
+            echo -e "\e[33mFound Docker Compose Standalone.\e[0m"
+            echo -e "\e[33mSetting the DOCKER_COMPOSE_VERSION Variable to standalone\e[0m"
+            sleep 2
+            echo -e "\e[33mNotice: For an automatic update of docker-compose please use the update_compose.sh scripts located at the helper-scripts folder.\e[0m"
+        else
+            echo -e "\e[31mCannot find Docker Compose with a Version Higher than 2.X.X.\e[0m"
+            echo -e "\e[31mPlease update/install manually regarding to this doc site: https://docs.mailcow.email/install/\e[0m"
+            exit 1
+        fi
     fi
-  elif docker-compose > /dev/null 2>&1; then
-  if ! [[ $(alias docker-compose 2> /dev/null) ]] ; then
-    if docker-compose version --short | grep -e "^[2-9]\." -e "^[1-9][0-9]\." > /dev/null 2>&1; then
-      COMPOSE_VERSION=standalone
-      COMPOSE_COMMAND="docker-compose"
-      if [[ "$caller" == "update.sh" ]]; then
-        sed -i 's/^DOCKER_COMPOSE_VERSION=.*/DOCKER_COMPOSE_VERSION=standalone/' "$SCRIPT_DIR/mailcow.conf"
-      fi
-      echo -e "\e[33mFound Docker Compose Standalone.\e[0m"
-      echo -e "\e[33mSetting the DOCKER_COMPOSE_VERSION Variable to standalone\e[0m"
-      sleep 2
-      echo -e "\e[33mNotice: For an automatic update of docker-compose please use the update_compose.sh scripts located at the helper-scripts folder.\e[0m"
     else
-      echo -e "\e[31mCannot find Docker Compose with a Version Higher than 2.X.X.\e[0m"
-      echo -e "\e[31mPlease update/install manually regarding to this doc site: https://docs.mailcow.email/install/\e[0m"
-      exit 1
+        echo -e "\e[31mCannot find Docker Compose.\e[0m"
+        echo -e "\e[31mPlease install it regarding to this doc site: https://docs.mailcow.email/install/\e[0m"
+        exit 1
     fi
-  fi
-  else
-    echo -e "\e[31mCannot find Docker Compose.\e[0m"
-    echo -e "\e[31mPlease install it regarding to this doc site: https://docs.mailcow.email/install/\e[0m"
-    exit 1
-  fi
 }
 
 detect_bad_asn() {

data/Dockerfiles/acme/acme.sh

@@ -3,14 +3,14 @@ set -o pipefail
 exec 5>&1
 
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  export REDIS_CMDLINE="redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning"
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  export VALKEY_CMDLINE="redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning"
 else
-  export REDIS_CMDLINE="redis-cli -h redis -p 6379 -a ${REDISPASS} --no-auth-warning"
+  export VALKEY_CMDLINE="redis-cli -h valkey-mailcow -p 6379 -a ${VALKEYPASS} --no-auth-warning"
 fi
 
-until [[ $(${REDIS_CMDLINE} PING) == "PONG" ]]; do
-  echo "Waiting for Redis..."
+until [[ $(${VALKEY_CMDLINE} PING) == "PONG" ]]; do
+  echo "Waiting for Valkey..."
   sleep 2
 done
 
@@ -48,11 +48,11 @@ if [[ "${SKIP_LETS_ENCRYPT}" =~ ^([yY][eE][sS]|[yY])+$ ]]; then
   exec $(readlink -f "$0")
 fi
 
-log_f "Waiting for Controller .."
-until ping controller -c1 > /dev/null; do
+log_f "Waiting for Docker API..."
+until ping dockerapi -c1 > /dev/null; do
   sleep 1
 done
-log_f "Controller OK"
+log_f "Docker API OK"
 
 log_f "Waiting for Postfix..."
 until ping postfix -c1 > /dev/null; do
@@ -246,25 +246,6 @@ while true; do
     done
     VALIDATED_CONFIG_DOMAINS+=("${VALIDATED_CONFIG_DOMAINS_SUBDOMAINS[*]}")
   done
-
-  # Fetch alias domains where target domain has MTA-STS enabled
-  if [[ ${AUTODISCOVER_SAN} == "y" ]]; then
-    SQL_ALIAS_DOMAINS=$(mariadb --skip-ssl --socket=/var/run/mysqld/mysqld.sock -u ${DBUSER} -p${DBPASS} ${DBNAME} -e "SELECT ad.alias_domain FROM alias_domain ad INNER JOIN mta_sts m ON ad.target_domain = m.domain WHERE ad.active = 1 AND m.active = 1" -Bs)
-    if [[ $? -eq 0 ]]; then
-      while read alias_domain; do
-        if [[ -z "${alias_domain}" ]]; then
-          # ignore empty lines
-          continue
-        fi
-        # Only add mta-sts subdomain for alias domains
-        if [[ "mta-sts.${alias_domain}" != "${MAILCOW_HOSTNAME}" ]]; then
-          if check_domain "mta-sts.${alias_domain}"; then
-            VALIDATED_CONFIG_DOMAINS+=("mta-sts.${alias_domain}")
-          fi
-        fi
-      done <<< "${SQL_ALIAS_DOMAINS}"
-    fi
-  fi
   fi
 
   if check_domain ${MAILCOW_HOSTNAME}; then
@@ -367,7 +348,7 @@ while true; do
   if [[ -z ${VALIDATED_CERTIFICATES[*]} ]]; then
     log_f "Cannot validate any hostnames, skipping Let's Encrypt for 1 hour."
     log_f "Use SKIP_LETS_ENCRYPT=y in mailcow.conf to skip it permanently."
-    ${REDIS_CMDLINE} SET ACME_FAIL_TIME "$(date +%s)"
+    ${VALKEY_CMDLINE} SET ACME_FAIL_TIME "$(date +%s)"
     sleep 1h
     exec $(readlink -f "$0")
   fi
@@ -408,7 +389,7 @@ while true; do
       DOVECOT_CERT_SERIAL_NEW="$(echo | openssl s_client -connect dovecot:143 -starttls imap 2>/dev/null | openssl x509 -inform pem -noout -serial | cut -d "=" -f 2)"
       if [[ ${RELOAD_LOOP_C} -gt 3 ]]; then
         log_f "Some services do return old end dates, something went wrong!"
-        ${REDIS_CMDLINE} SET ACME_FAIL_TIME "$(date +%s)"
+        ${VALKEY_CMDLINE} SET ACME_FAIL_TIME "$(date +%s)"
         break;
       fi
     done
@@ -429,7 +410,7 @@ while true; do
       ;;
     *) # non-zero
       log_f "Some errors occurred, retrying in 30 minutes..."
-      ${REDIS_CMDLINE} SET ACME_FAIL_TIME "$(date +%s)"
+      ${VALKEY_CMDLINE} SET ACME_FAIL_TIME "$(date +%s)"
       sleep 30m
       exec $(readlink -f "$0")
       ;;

data/Dockerfiles/acme/functions.sh

@@ -5,13 +5,13 @@ log_f() {
     echo -n "$(date) - ${1}"
   elif [[ ${2} == "no_date" ]]; then
     echo "${1}"
-  elif [[ ${2} != "redis_only" ]]; then
+  elif [[ ${2} != "valkey_only" ]]; then
     echo "$(date) - ${1}"
   fi
   if [[ ${3} == "b64" ]]; then
-    ${REDIS_CMDLINE} LPUSH ACME_LOG "{\"time\":\"$(date +%s)\",\"message\":\"base64,$(printf '%s' "${MAILCOW_HOSTNAME} - ${1}")\"}" > /dev/null
+    ${VALKEY_CMDLINE} LPUSH ACME_LOG "{\"time\":\"$(date +%s)\",\"message\":\"base64,$(printf '%s' "${MAILCOW_HOSTNAME} - ${1}")\"}" > /dev/null
   else
-    ${REDIS_CMDLINE} LPUSH ACME_LOG "{\"time\":\"$(date +%s)\",\"message\":\"$(printf '%s' "${MAILCOW_HOSTNAME} - ${1}" | \
+    ${VALKEY_CMDLINE} LPUSH ACME_LOG "{\"time\":\"$(date +%s)\",\"message\":\"$(printf '%s' "${MAILCOW_HOSTNAME} - ${1}" | \
       tr '%&;$"[]{}-\r\n' ' ')\"}" > /dev/null
   fi
 }

data/Dockerfiles/acme/obtain-certificate.sh

@@ -101,7 +101,7 @@ ACME_RESPONSE=$(acme-tiny ${DIRECTORY_URL} \
   --acme-dir /var/www/acme/ 2>&1 > /tmp/_cert.pem | tee /dev/fd/5; exit ${PIPESTATUS[0]})
 SUCCESS="$?"
 ACME_RESPONSE_B64=$(echo "${ACME_RESPONSE}" | openssl enc -e -A -base64)
-log_f "${ACME_RESPONSE_B64}" redis_only b64
+log_f "${ACME_RESPONSE_B64}" valkey_only b64
 case "$SUCCESS" in
   0) # cert requested
     log_f "Deploying certificate ${CERT}..."
@@ -124,7 +124,7 @@ case "$SUCCESS" in
     ;;
   *) # non-zero is non-fun
     log_f "Failed to obtain certificate ${CERT} for domains '${CERT_DOMAINS[*]}'"
-    redis-cli -h redis -a ${REDISPASS} --no-auth-warning SET ACME_FAIL_TIME "$(date +%s)"
+    redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning SET ACME_FAIL_TIME "$(date +%s)"
     exit 100${SUCCESS}
     ;;
 esac

data/Dockerfiles/acme/reload-configurations.sh

@@ -2,32 +2,32 @@
 
 # Reading container IDs
 # Wrapping as array to ensure trimmed content when calling $NGINX etc.
-NGINX=($(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"nginx-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" | tr "\n" " "))
-DOVECOT=($(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"dovecot-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" | tr "\n" " "))
-POSTFIX=($(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"postfix-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" | tr "\n" " "))
+NGINX=($(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"nginx-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" | tr "\n" " "))
+DOVECOT=($(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"dovecot-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" | tr "\n" " "))
+POSTFIX=($(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"postfix-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" | tr "\n" " "))
 
 reload_nginx(){
   echo "Reloading Nginx..."
-  NGINX_RELOAD_RET=$(curl -X POST --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${NGINX}/exec -d '{"cmd":"reload", "task":"nginx"}' --silent -H 'Content-type: application/json' | jq -r .type)
+  NGINX_RELOAD_RET=$(curl -X POST --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${NGINX}/exec -d '{"cmd":"reload", "task":"nginx"}' --silent -H 'Content-type: application/json' | jq -r .type)
   [[ ${NGINX_RELOAD_RET} != 'success' ]] && { echo "Could not reload Nginx, restarting container..."; restart_container ${NGINX} ; }
 }
 
 reload_dovecot(){
   echo "Reloading Dovecot..."
-  DOVECOT_RELOAD_RET=$(curl -X POST --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${DOVECOT}/exec -d '{"cmd":"reload", "task":"dovecot"}' --silent -H 'Content-type: application/json' | jq -r .type)
+  DOVECOT_RELOAD_RET=$(curl -X POST --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${DOVECOT}/exec -d '{"cmd":"reload", "task":"dovecot"}' --silent -H 'Content-type: application/json' | jq -r .type)
   [[ ${DOVECOT_RELOAD_RET} != 'success' ]] && { echo "Could not reload Dovecot, restarting container..."; restart_container ${DOVECOT} ; }
 }
 
 reload_postfix(){
   echo "Reloading Postfix..."
-  POSTFIX_RELOAD_RET=$(curl -X POST --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${POSTFIX}/exec -d '{"cmd":"reload", "task":"postfix"}' --silent -H 'Content-type: application/json' | jq -r .type)
+  POSTFIX_RELOAD_RET=$(curl -X POST --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${POSTFIX}/exec -d '{"cmd":"reload", "task":"postfix"}' --silent -H 'Content-type: application/json' | jq -r .type)
   [[ ${POSTFIX_RELOAD_RET} != 'success' ]] && { echo "Could not reload Postfix, restarting container..."; restart_container ${POSTFIX} ; }
 }
 
 restart_container(){
   for container in $*; do
     echo "Restarting ${container}..."
-    C_REST_OUT=$(curl -X POST --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${container}/restart --silent | jq -r '.msg')
+    C_REST_OUT=$(curl -X POST --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${container}/restart --silent | jq -r '.msg')
     echo "${C_REST_OUT}"
   done
 }

data/Dockerfiles/backup/Dockerfile

@@ -1,3 +1,3 @@
-FROM debian:trixie-slim
+FROM debian:bookworm-slim
 
-RUN apt update && apt install pigz zstd -y --no-install-recommends
+RUN apt update && apt install pigz -y --no-install-recommends

data/Dockerfiles/controller/docker-entrypoint.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-`openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes \
-  -keyout /app/controller_key.pem \
-  -out /app/controller_cert.pem \
-  -subj /CN=controller/O=mailcow \
-  -addext subjectAltName=DNS:controller`
-
-exec "$@"

data/Dockerfiles/controller/mailcow-adm/mailcow-adm.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-import argparse
-import sys
-
-from models.AliasModel import AliasModel
-from models.MailboxModel import MailboxModel
-from models.SyncjobModel import SyncjobModel
-from models.CalendarModel import CalendarModel
-from models.MailerModel import MailerModel
-from models.AddressbookModel import AddressbookModel
-from models.MaildirModel import MaildirModel
-from models.DomainModel import DomainModel
-from models.DomainadminModel import DomainadminModel
-from models.StatusModel import StatusModel
-
-from modules.Utils import Utils
-
-
-
-
-def main():
-    utils = Utils()
-
-    model_map = {
-        MailboxModel.parser_command: MailboxModel,
-        AliasModel.parser_command: AliasModel,
-        SyncjobModel.parser_command: SyncjobModel,
-        CalendarModel.parser_command: CalendarModel,
-        AddressbookModel.parser_command: AddressbookModel,
-        MailerModel.parser_command: MailerModel,
-        MaildirModel.parser_command: MaildirModel,
-        DomainModel.parser_command: DomainModel,
-        DomainadminModel.parser_command: DomainadminModel,
-        StatusModel.parser_command: StatusModel
-    }
-
-    parser = argparse.ArgumentParser(description="mailcow Admin Tool")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    for model in model_map.values():
-        model.add_parser(subparsers)
-
-    args = parser.parse_args()
-
-
-    for cmd, model_cls in model_map.items():
-        if args.command == cmd and model_cls.has_required_args(args):
-            instance = model_cls(**vars(args))
-            action = getattr(instance, args.object, None)
-            if callable(action):
-                res = action()
-                utils.pprint(res)
-                sys.exit(0)
-
-    parser.print_help()
-
-
-if __name__ == "__main__":
-    main()

data/Dockerfiles/controller/mailcow-adm/models/AddressbookModel.py

@@ -1,140 +0,0 @@
-from modules.Sogo import Sogo
-from models.BaseModel import BaseModel
-
-class AddressbookModel(BaseModel):
-    parser_command = "addressbook"
-    required_args = {
-        "add": [["username", "name"]],
-        "delete": [["username", "name"]],
-        "get":  [["username", "name"]],
-        "set_acl": [["username", "name", "sharee_email", "acl"]],
-        "get_acl": [["username", "name"]],
-        "delete_acl": [["username", "name", "sharee_email"]],
-        "add_contact": [["username", "name", "contact_name", "contact_email", "type"]],
-        "delete_contact": [["username", "name", "contact_name"]],
-    }
-
-    def __init__(
-        self,
-        username=None,
-        name=None,
-        sharee_email=None,
-        acl=None,
-        subscribe=None,
-        ics=None,
-        contact_name=None,
-        contact_email=None,
-        type=None,
-        **kwargs
-    ):
-        self.sogo = Sogo(username)
-
-        self.name = name
-        self.acl = acl
-        self.sharee_email = sharee_email
-        self.subscribe = subscribe
-        self.ics = ics
-        self.contact_name = contact_name
-        self.contact_email = contact_email
-        self.type = type
-
-    def add(self):
-        """
-        Add a new addressbook.
-        :return: Response from SOGo API.
-        """
-        return self.sogo.addAddressbook(self.name)
-
-    def set_acl(self):
-        """
-        Set ACL for the addressbook.
-        :return: Response from SOGo API.
-        """
-        addressbook_id = self.sogo.getAddressbookIdByName(self.name)
-        if not addressbook_id:
-            print(f"Addressbook '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.setAddressbookACL(addressbook_id, self.sharee_email, self.acl, self.subscribe)
-
-    def delete_acl(self):
-        """
-        Delete the addressbook ACL.
-        :return: Response from SOGo API.
-        """
-        addressbook_id = self.sogo.getAddressbookIdByName(self.name)
-        if not addressbook_id:
-            print(f"Addressbook '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.deleteAddressbookACL(addressbook_id, self.sharee_email)
-
-    def get_acl(self):
-        """
-        Get the ACL for the addressbook.
-        :return: Response from SOGo API.
-        """
-        addressbook_id = self.sogo.getAddressbookIdByName(self.name)
-        if not addressbook_id:
-            print(f"Addressbook '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.getAddressbookACL(addressbook_id)
-
-    def add_contact(self):
-        """
-        Add a new contact to the addressbook.
-        :return: Response from SOGo API.
-        """
-        addressbook_id = self.sogo.getAddressbookIdByName(self.name)
-        if not addressbook_id:
-            print(f"Addressbook '{self.name}' not found for user '{self.username}'.")
-            return None
-        if self.type == "card":
-            return self.sogo.addAddressbookContact(addressbook_id, self.contact_name, self.contact_email)
-        elif self.type == "list":
-            return self.sogo.addAddressbookContactList(addressbook_id, self.contact_name, self.contact_email)
-
-    def delete_contact(self):
-        """
-        Delete a contact or contactlist from the addressbook.
-        :return: Response from SOGo API.
-        """
-        addressbook_id = self.sogo.getAddressbookIdByName(self.name)
-        if not addressbook_id:
-            print(f"Addressbook '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.deleteAddressbookItem(addressbook_id, self.contact_name)
-
-    def get(self):
-        """
-        Retrieve addressbooks list.
-        :return: Response from SOGo API.
-        """
-        return self.sogo.getAddressbookList()
-
-    def delete(self):
-        """
-        Delete the addressbook.
-        :return: Response from SOGo API.
-        """
-
-        addressbook_id = self.sogo.getAddressbookIdByName(self.name)
-        if not addressbook_id:
-            print(f"Addressbook '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.deleteAddressbook(addressbook_id)
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage addressbooks (add, delete, get, set_acl, get_acl, delete_acl, add_contact, delete_contact)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, set_acl, get_acl, delete_acl, add_contact, delete_contact")
-        parser.add_argument("--username", required=True, help="Username of the addressbook owner (e.g. user@example.com)")
-        parser.add_argument("--name", help="Addressbook name")
-        parser.add_argument("--sharee-email", help="Email address to share the addressbook with")
-        parser.add_argument("--acl", help="ACL rights for the sharee (e.g. r, w, rw)")
-        parser.add_argument("--subscribe", action='store_true', help="Subscribe the sharee to the addressbook")
-        parser.add_argument("--contact-name", help="Name of the contact or contactlist to add or delete")
-        parser.add_argument("--contact-email", help="Email address of the contact to add")
-        parser.add_argument("--type", choices=["card", "list"], help="Type of contact to add: card (single contact) or list (distribution list)")
-

data/Dockerfiles/controller/mailcow-adm/models/AliasModel.py

@@ -1,107 +0,0 @@
-from modules.Mailcow import Mailcow
-from models.BaseModel import BaseModel
-
-class AliasModel(BaseModel):
-    parser_command = "alias"
-    required_args = {
-        "add": [["address", "goto"]],
-        "delete": [["id"]],
-        "get":  [["id"]],
-        "edit": [["id"]]
-    }
-
-    def __init__(
-        self,
-        id=None,
-        address=None,
-        goto=None,
-        active=None,
-        sogo_visible=None,
-        **kwargs
-    ):
-        self.mailcow = Mailcow()
-
-        self.id = id
-        self.address = address
-        self.goto = goto
-        self.active = active
-        self.sogo_visible = sogo_visible
-
-    @classmethod
-    def from_dict(cls, data):
-        return cls(
-            address=data.get("address"),
-            goto=data.get("goto"),
-            active=data.get("active", None),
-            sogo_visible=data.get("sogo_visible", None)
-        )
-
-    def getAdd(self):
-        """
-        Get the alias details as a dictionary for adding, sets default values.
-        :return: Dictionary containing alias details.
-        """
-
-        alias = {
-            "address": self.address,
-            "goto": self.goto,
-            "active": self.active if self.active is not None else 1,
-            "sogo_visible": self.sogo_visible if self.sogo_visible is not None else 0
-        }
-        return {key: value for key, value in alias.items() if value is not None}
-
-    def getEdit(self):
-        """
-        Get the alias details as a dictionary for editing, sets no default values.
-        :return: Dictionary containing mailbox details.
-        """
-
-        alias = {
-            "address": self.address,
-            "goto": self.goto,
-            "active": self.active,
-            "sogo_visible": self.sogo_visible
-        }
-        return {key: value for key, value in alias.items() if value is not None}
-
-    def get(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getAlias(self.id)
-
-    def delete(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.deleteAlias(self.id)
-
-    def add(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.addAlias(self.getAdd())
-
-    def edit(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.editAlias(self.id, self.getEdit())
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage aliases (add, delete, get, edit)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, edit")
-        parser.add_argument("--id", help="Alias object ID (required for get, edit, delete)")
-        parser.add_argument("--address", help="Alias email address (e.g. alias@example.com)")
-        parser.add_argument("--goto", help="Destination address(es), comma-separated (e.g. user1@example.com,user2@example.com)")
-        parser.add_argument("--active", choices=["1", "0"], help="Activate (1) or deactivate (0) the alias")
-        parser.add_argument("--sogo-visible", choices=["1", "0"], help="Show alias in SOGo addressbook (1 = yes, 0 = no)")
-

data/Dockerfiles/controller/mailcow-adm/models/BaseModel.py

@@ -1,35 +0,0 @@
-class BaseModel:
-    parser_command = ""
-    required_args = {}
-
-    @classmethod
-    def has_required_args(cls, args):
-        """
-        Validate that all required arguments are present.
-        """
-        object_name = args.object if hasattr(args, "object") else args.get("object")
-        required_lists = cls.required_args.get(object_name, False)
-
-        if not required_lists:
-            return False
-
-        for required_set in required_lists:
-            result = True
-            for required_args in required_set:
-                if isinstance(args, dict):
-                    if not args.get(required_args):
-                        result = False
-                        break
-                elif not hasattr(args, required_args):
-                    result = False
-                    break
-            if result:
-                break
-
-        if not result:
-            print(f"Required arguments for '{object_name}': {required_lists}")
-        return result
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        pass

data/Dockerfiles/controller/mailcow-adm/models/CalendarModel.py

@@ -1,111 +0,0 @@
-from modules.Sogo import Sogo
-from models.BaseModel import BaseModel
-
-class CalendarModel(BaseModel):
-    parser_command = "calendar"
-    required_args = {
-        "add": [["username", "name"]],
-        "delete": [["username", "name"]],
-        "get":  [["username"]],
-        "import_ics": [["username", "name", "ics"]],
-        "set_acl": [["username", "name", "sharee_email", "acl"]],
-        "get_acl": [["username", "name"]],
-        "delete_acl": [["username", "name", "sharee_email"]],
-    }
-
-    def __init__(
-        self,
-        username=None,
-        name=None,
-        sharee_email=None,
-        acl=None,
-        subscribe=None,
-        ics=None,
-        **kwargs
-    ):
-        self.sogo = Sogo(username)
-
-        self.name = name
-        self.acl = acl
-        self.sharee_email = sharee_email
-        self.subscribe = subscribe
-        self.ics = ics
-
-    def add(self):
-        """
-        Add a new calendar.
-        :return: Response from SOGo API.
-        """
-        return self.sogo.addCalendar(self.name)
-
-    def delete(self):
-        """
-        Delete a calendar.
-        :return: Response from SOGo API.
-        """
-        calendar_id = self.sogo.getCalendarIdByName(self.name)
-        if not calendar_id:
-            print(f"Calendar '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.deleteCalendar(calendar_id)
-
-    def get(self):
-        """
-        Get the calendar details.
-        :return: Response from SOGo API.
-        """
-        return self.sogo.getCalendar()
-
-    def set_acl(self):
-        """
-        Set ACL for the calendar.
-        :return: Response from SOGo API.
-        """
-        calendar_id = self.sogo.getCalendarIdByName(self.name)
-        if not calendar_id:
-            print(f"Calendar '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.setCalendarACL(calendar_id, self.sharee_email, self.acl, self.subscribe)
-
-    def delete_acl(self):
-        """
-        Delete the calendar ACL.
-        :return: Response from SOGo API.
-        """
-        calendar_id = self.sogo.getCalendarIdByName(self.name)
-        if not calendar_id:
-            print(f"Calendar '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.deleteCalendarACL(calendar_id, self.sharee_email)
-
-    def get_acl(self):
-        """
-        Get the ACL for the calendar.
-        :return: Response from SOGo API.
-        """
-        calendar_id = self.sogo.getCalendarIdByName(self.name)
-        if not calendar_id:
-            print(f"Calendar '{self.name}' not found for user '{self.username}'.")
-            return None
-        return self.sogo.getCalendarACL(calendar_id)
-
-    def import_ics(self):
-        """
-        Import a calendar from an ICS file.
-        :return: Response from SOGo API.
-        """
-        return self.sogo.importCalendar(self.name, self.ics)
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage calendars (add, delete, get, import_ics, set_acl, get_acl, delete_acl)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, import_ics, set_acl, get_acl, delete_acl")
-        parser.add_argument("--username", required=True, help="Username of the calendar owner (e.g. user@example.com)")
-        parser.add_argument("--name", help="Calendar name")
-        parser.add_argument("--ics", help="Path to ICS file for import")
-        parser.add_argument("--sharee-email", help="Email address to share the calendar with")
-        parser.add_argument("--acl", help="ACL rights for the sharee (e.g. r, w, rw)")
-        parser.add_argument("--subscribe", action='store_true', help="Subscribe the sharee to the calendar")

data/Dockerfiles/controller/mailcow-adm/models/DomainModel.py

@@ -1,162 +0,0 @@
-from modules.Mailcow import Mailcow
-from models.BaseModel import BaseModel
-
-class DomainModel(BaseModel):
-    parser_command = "domain"
-    required_args = {
-        "add": [["domain"]],
-        "delete": [["domain"]],
-        "get":  [["domain"]],
-        "edit": [["domain"]]
-    }
-
-    def __init__(
-        self,
-        domain=None,
-        active=None,
-        aliases=None,
-        backupmx=None,
-        defquota=None,
-        description=None,
-        mailboxes=None,
-        maxquota=None,
-        quota=None,
-        relay_all_recipients=None,
-        rl_frame=None,
-        rl_value=None,
-        restart_sogo=None,
-        tags=None,
-        **kwargs
-    ):
-        self.mailcow = Mailcow()
-
-        self.domain = domain
-        self.active = active
-        self.aliases = aliases
-        self.backupmx = backupmx
-        self.defquota = defquota
-        self.description = description
-        self.mailboxes = mailboxes
-        self.maxquota = maxquota
-        self.quota = quota
-        self.relay_all_recipients = relay_all_recipients
-        self.rl_frame = rl_frame
-        self.rl_value = rl_value
-        self.restart_sogo = restart_sogo
-        self.tags = tags
-
-    @classmethod
-    def from_dict(cls, data):
-        return cls(
-            domain=data.get("domain"),
-            active=data.get("active", None),
-            aliases=data.get("aliases", None),
-            backupmx=data.get("backupmx", None),
-            defquota=data.get("defquota", None),
-            description=data.get("description", None),
-            mailboxes=data.get("mailboxes", None),
-            maxquota=data.get("maxquota", None),
-            quota=data.get("quota", None),
-            relay_all_recipients=data.get("relay_all_recipients", None),
-            rl_frame=data.get("rl_frame", None),
-            rl_value=data.get("rl_value", None),
-            restart_sogo=data.get("restart_sogo", None),
-            tags=data.get("tags", None)
-        )
-
-    def getAdd(self):
-        """
-        Get the domain details as a dictionary for adding, sets default values.
-        :return: Dictionary containing domain details.
-        """
-        domain = {
-            "domain": self.domain,
-            "active": self.active if self.active is not None else 1,
-            "aliases": self.aliases if self.aliases is not None else 400,
-            "backupmx": self.backupmx if self.backupmx is not None else 0,
-            "defquota": self.defquota if self.defquota is not None else 3072,
-            "description": self.description if self.description is not None else "",
-            "mailboxes": self.mailboxes if self.mailboxes is not None else 10,
-            "maxquota": self.maxquota if self.maxquota is not None else 10240,
-            "quota": self.quota if self.quota is not None else 10240,
-            "relay_all_recipients": self.relay_all_recipients if self.relay_all_recipients is not None else 0,
-            "rl_frame": self.rl_frame,
-            "rl_value": self.rl_value,
-            "restart_sogo": self.restart_sogo if self.restart_sogo is not None else 0,
-            "tags": self.tags if self.tags is not None else []
-        }
-        return {key: value for key, value in domain.items() if value is not None}
-
-    def getEdit(self):
-        """
-        Get the domain details as a dictionary for editing, sets no default values.
-        :return: Dictionary containing domain details.
-        """
-        domain = {
-            "domain": self.domain,
-            "active": self.active,
-            "aliases": self.aliases,
-            "backupmx": self.backupmx,
-            "defquota": self.defquota,
-            "description": self.description,
-            "mailboxes": self.mailboxes,
-            "maxquota": self.maxquota,
-            "quota": self.quota,
-            "relay_all_recipients": self.relay_all_recipients,
-            "rl_frame": self.rl_frame,
-            "rl_value": self.rl_value,
-            "restart_sogo": self.restart_sogo,
-            "tags": self.tags
-        }
-        return {key: value for key, value in domain.items() if value is not None}
-
-    def get(self):
-        """
-        Get the domain details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getDomain(self.domain)
-
-    def delete(self):
-        """
-        Delete the domain from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.deleteDomain(self.domain)
-
-    def add(self):
-        """
-        Add the domain to the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.addDomain(self.getAdd())
-
-    def edit(self):
-        """
-        Edit the domain in the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.editDomain(self.domain, self.getEdit())
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage domains (add, delete, get, edit)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, edit")
-        parser.add_argument("--domain", required=True, help="Domain name (e.g. domain.tld)")
-        parser.add_argument("--active", choices=["1", "0"], help="Activate (1) or deactivate (0) the domain")
-        parser.add_argument("--aliases", help="Number of aliases allowed for the domain")
-        parser.add_argument("--backupmx", choices=["1", "0"], help="Enable (1) or disable (0) backup MX")
-        parser.add_argument("--defquota", help="Default quota for mailboxes in MB")
-        parser.add_argument("--description", help="Description of the domain")
-        parser.add_argument("--mailboxes", help="Number of mailboxes allowed for the domain")
-        parser.add_argument("--maxquota", help="Maximum quota for the domain in MB")
-        parser.add_argument("--quota", help="Quota used by the domain in MB")
-        parser.add_argument("--relay-all-recipients", choices=["1", "0"], help="Relay all recipients (1 = yes, 0 = no)")
-        parser.add_argument("--rl-frame", help="Rate limit frame (e.g., s, m, h)")
-        parser.add_argument("--rl-value", help="Rate limit value")
-        parser.add_argument("--restart-sogo", help="Restart SOGo after changes (1 = yes, 0 = no)")
-        parser.add_argument("--tags", nargs="*", help="Tags for the domain")
-

data/Dockerfiles/controller/mailcow-adm/models/DomainadminModel.py

@@ -1,106 +0,0 @@
-from modules.Mailcow import Mailcow
-from models.BaseModel import BaseModel
-
-class DomainadminModel(BaseModel):
-    parser_command = "domainadmin"
-    required_args = {
-        "add": [["username", "domains", "password"]],
-        "delete": [["username"]],
-        "get":  [["username"]],
-        "edit": [["username"]]
-    }
-
-    def __init__(
-        self,
-        username=None,
-        domains=None,
-        password=None,
-        active=None,
-        **kwargs
-    ):
-        self.mailcow = Mailcow()
-
-        self.username = username
-        self.domains = domains
-        self.password = password
-        self.password2 = password
-        self.active = active
-
-    @classmethod
-    def from_dict(cls, data):
-        return cls(
-            username=data.get("username"),
-            domains=data.get("domains"),
-            password=data.get("password"),
-            password2=data.get("password"),
-            active=data.get("active", None),
-        )
-
-    def getAdd(self):
-        """
-        Get the domain admin details as a dictionary for adding, sets default values.
-        :return: Dictionary containing domain admin details.
-        """
-        domainadmin = {
-            "username": self.username,
-            "domains": self.domains,
-            "password": self.password,
-            "password2": self.password2,
-            "active": self.active if self.active is not None else "1"
-        }
-        return {key: value for key, value in domainadmin.items() if value is not None}
-
-    def getEdit(self):
-        """
-        Get the domain admin details as a dictionary for editing, sets no default values.
-        :return: Dictionary containing domain admin details.
-        """
-        domainadmin = {
-            "username": self.username,
-            "domains": self.domains,
-            "password": self.password,
-            "password2": self.password2,
-            "active": self.active
-        }
-        return {key: value for key, value in domainadmin.items() if value is not None}
-
-    def get(self):
-        """
-        Get the domain admin details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getDomainadmin(self.username)
-
-    def delete(self):
-        """
-        Delete the domain admin from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.deleteDomainadmin(self.username)
-
-    def add(self):
-        """
-        Add the domain admin to the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.addDomainadmin(self.getAdd())
-
-    def edit(self):
-        """
-        Edit the domain admin in the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.editDomainadmin(self.username, self.getEdit())
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage domain admins (add, delete, get, edit)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, edit")
-        parser.add_argument("--username", help="Username for the domain admin")
-        parser.add_argument("--domains", help="Comma-separated list of domains")
-        parser.add_argument("--password", help="Password for the domain admin")
-        parser.add_argument("--active", choices=["1", "0"], help="Activate (1) or deactivate (0) the domain admin")
-

data/Dockerfiles/controller/mailcow-adm/models/MailboxModel.py

@@ -1,164 +0,0 @@
-from modules.Mailcow import Mailcow
-from models.BaseModel import BaseModel
-
-class MailboxModel(BaseModel):
-    parser_command = "mailbox"
-    required_args = {
-        "add": [["username", "password"]],
-        "delete": [["username"]],
-        "get":  [["username"]],
-        "edit": [["username"]]
-    }
-
-    def __init__(
-        self,
-        password=None,
-        username=None,
-        domain=None,
-        local_part=None,
-        active=None,
-        sogo_access=None,
-        name=None,
-        authsource=None,
-        quota=None,
-        force_pw_update=None,
-        tls_enforce_in=None,
-        tls_enforce_out=None,
-        tags=None,
-        sender_acl=None,
-        **kwargs
-    ):
-        self.mailcow = Mailcow()
-
-        if username is not None and "@" in username:
-            self.username = username
-            self.local_part, self.domain = username.split("@")
-        else:
-            self.username = f"{local_part}@{domain}"
-            self.local_part = local_part
-            self.domain = domain
-
-        self.password = password
-        self.password2 = password
-        self.active = active
-        self.sogo_access = sogo_access
-        self.name = name
-        self.authsource = authsource
-        self.quota = quota
-        self.force_pw_update = force_pw_update
-        self.tls_enforce_in = tls_enforce_in
-        self.tls_enforce_out = tls_enforce_out
-        self.tags = tags
-        self.sender_acl = sender_acl
-
-    @classmethod
-    def from_dict(cls, data):
-        return cls(
-            domain=data.get("domain"),
-            local_part=data.get("local_part"),
-            password=data.get("password"),
-            password2=data.get("password"),
-            active=data.get("active", None),
-            sogo_access=data.get("sogo_access", None),
-            name=data.get("name", None),
-            authsource=data.get("authsource", None),
-            quota=data.get("quota", None),
-            force_pw_update=data.get("force_pw_update", None),
-            tls_enforce_in=data.get("tls_enforce_in", None),
-            tls_enforce_out=data.get("tls_enforce_out", None),
-            tags=data.get("tags", None),
-            sender_acl=data.get("sender_acl", None)
-        )
-
-    def getAdd(self):
-        """
-        Get the mailbox details as a dictionary for adding, sets default values.
-        :return: Dictionary containing mailbox details.
-        """
-
-        mailbox = {
-            "domain": self.domain,
-            "local_part": self.local_part,
-            "password": self.password,
-            "password2": self.password2,
-            "active": self.active if self.active is not None else 1,
-            "name": self.name if self.name is not None else "",
-            "authsource": self.authsource if self.authsource is not None else "mailcow",
-            "quota": self.quota if self.quota is not None else 0,
-            "force_pw_update": self.force_pw_update if self.force_pw_update is not None else 0,
-            "tls_enforce_in": self.tls_enforce_in if self.tls_enforce_in is not None else 0,
-            "tls_enforce_out": self.tls_enforce_out if self.tls_enforce_out is not None else 0,
-            "tags": self.tags if self.tags is not None else []
-        }
-        return {key: value for key, value in mailbox.items() if value is not None}
-
-    def getEdit(self):
-        """
-        Get the mailbox details as a dictionary for editing, sets no default values.
-        :return: Dictionary containing mailbox details.
-        """
-
-        mailbox = {
-            "domain": self.domain,
-            "local_part": self.local_part,
-            "password": self.password,
-            "password2": self.password2,
-            "active": self.active,
-            "name": self.name,
-            "authsource": self.authsource,
-            "quota": self.quota,
-            "force_pw_update": self.force_pw_update,
-            "tls_enforce_in": self.tls_enforce_in,
-            "tls_enforce_out": self.tls_enforce_out,
-            "tags": self.tags
-        }
-        return {key: value for key, value in mailbox.items() if value is not None}
-
-    def get(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getMailbox(self.username)
-
-    def delete(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.deleteMailbox(self.username)
-
-    def add(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.addMailbox(self.getAdd())
-
-    def edit(self):
-        """
-        Get the mailbox details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.editMailbox(self.username, self.getEdit())
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage mailboxes (add, delete, get, edit)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, edit")
-        parser.add_argument("--username", help="Full email address of the mailbox (e.g. user@example.com)")
-        parser.add_argument("--password", help="Password for the mailbox (required for add)")
-        parser.add_argument("--active", choices=["1", "0"], help="Activate (1) or deactivate (0) the mailbox")
-        parser.add_argument("--sogo-access", choices=["1", "0"], help="Redirect mailbox to SOGo after web login (1 = yes, 0 = no)")
-        parser.add_argument("--name", help="Display name of the mailbox owner")
-        parser.add_argument("--authsource", help="Authentication source (default: mailcow)")
-        parser.add_argument("--quota", help="Mailbox quota in bytes (0 = unlimited)")
-        parser.add_argument("--force-pw-update", choices=["1", "0"], help="Force password update on next login (1 = yes, 0 = no)")
-        parser.add_argument("--tls-enforce-in", choices=["1", "0"], help="Enforce TLS for incoming emails (1 = yes, 0 = no)")
-        parser.add_argument("--tls-enforce-out", choices=["1", "0"], help="Enforce TLS for outgoing emails (1 = yes, 0 = no)")
-        parser.add_argument("--tags", help="Comma-separated list of tags for the mailbox")
-        parser.add_argument("--sender-acl", help="Comma-separated list of allowed sender addresses for this mailbox")
-

data/Dockerfiles/controller/mailcow-adm/models/MaildirModel.py

@@ -1,67 +0,0 @@
-from modules.Dovecot import Dovecot
-from models.BaseModel import BaseModel
-
-class MaildirModel(BaseModel):
-    parser_command = "maildir"
-    required_args = {
-        "encrypt": [],
-        "decrypt": [],
-        "restore": [["username", "item"], ["list"]]
-    }
-
-    def __init__(
-        self,
-        username=None,
-        source=None,
-        item=None,
-        overwrite=None,
-        list=None,
-        **kwargs
-    ):
-        self.dovecot = Dovecot()
-
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-        self.username = username
-        self.source = source
-        self.item = item
-        self.overwrite = overwrite
-        self.list = list
-
-    def encrypt(self):
-        """
-        Encrypt the maildir for the specified user or all.
-        :return: Response from Dovecot.
-        """
-        return self.dovecot.encryptMaildir(self.source_dir, self.output_dir)
-
-    def decrypt(self):
-        """
-        Decrypt the maildir for the specified user or all.
-        :return: Response from Dovecot.
-        """
-        return self.dovecot.decryptMaildir(self.source_dir, self.output_dir)
-
-    def restore(self):
-        """
-        Restore or List maildir data for the specified user.
-        :return: Response from Dovecot.
-        """
-        if self.list:
-            return self.dovecot.listDeletedMaildirs()
-        return self.dovecot.restoreMaildir(self.username, self.item)
-
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage maildir (encrypt, decrypt, restore)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: encrypt, decrypt, restore")
-        parser.add_argument("--item", help="Item to restore")
-        parser.add_argument("--username", help="Username to restore the item to")
-        parser.add_argument("--list", action="store_true", help="List items to restore")
-        parser.add_argument("--source-dir", help="Path to the source maildir to import/encrypt/decrypt")
-        parser.add_argument("--output-dir", help="Directory to store encrypted/decrypted files inside the Dovecot container")

data/Dockerfiles/controller/mailcow-adm/models/MailerModel.py

@@ -1,62 +0,0 @@
-import json
-from models.BaseModel import BaseModel
-from modules.Mailer import Mailer
-
-class MailerModel(BaseModel):
-    parser_command = "mail"
-    required_args = {
-        "send": [["sender", "recipient", "subject", "body"]]
-    }
-
-    def __init__(
-        self,
-        sender=None,
-        recipient=None,
-        subject=None,
-        body=None,
-        context=None,
-        **kwargs
-    ):
-        self.sender = sender
-        self.recipient = recipient
-        self.subject = subject
-        self.body = body
-        self.context = context
-
-    def send(self):
-        if self.context is not None:
-            try:
-                self.context = json.loads(self.context)
-            except json.JSONDecodeError as e:
-                return f"Invalid context JSON: {e}"
-        else:
-            self.context = {}
-
-        mailer = Mailer(
-            smtp_host="postfix-mailcow",
-            smtp_port=25,
-            username=self.sender,
-            password="",
-            use_tls=True
-        )
-        res = mailer.send_mail(
-            subject=self.subject,
-            from_addr=self.sender,
-            to_addrs=self.recipient.split(","),
-            template=self.body,
-            context=self.context
-        )
-        return res
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Send emails via SMTP"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: send")
-        parser.add_argument("--sender", required=True, help="Email sender address")
-        parser.add_argument("--recipient", required=True, help="Email recipient address (comma-separated for multiple)")
-        parser.add_argument("--subject", required=True, help="Email subject")
-        parser.add_argument("--body", required=True, help="Email body (Jinja2 template supported)")
-        parser.add_argument("--context", help="Context for Jinja2 template rendering (JSON format)")

data/Dockerfiles/controller/mailcow-adm/models/StatusModel.py

@@ -1,45 +0,0 @@
-from modules.Mailcow import Mailcow
-from models.BaseModel import BaseModel
-
-class StatusModel(BaseModel):
-    parser_command = "status"
-    required_args = {
-        "version": [[]],
-        "vmail": [[]],
-        "containers":  [[]]
-    }
-
-    def __init__(
-        self,
-        **kwargs
-    ):
-        self.mailcow = Mailcow()
-
-    def version(self):
-        """
-        Get the version of the mailcow instance.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getStatusVersion()
-
-    def vmail(self):
-        """
-        Get the vmail details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getStatusVmail()
-
-    def containers(self):
-        """
-        Get the status of containers in the mailcow instance.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getStatusContainers()
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Get information about mailcow (version, vmail, containers)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: version, vmail, containers")

data/Dockerfiles/controller/mailcow-adm/models/SyncjobModel.py

@@ -1,221 +0,0 @@
-from modules.Mailcow import Mailcow
-from models.BaseModel import BaseModel
-
-class SyncjobModel(BaseModel):
-    parser_command = "syncjob"
-    required_args = {
-        "add": [["username", "host1", "port1", "user1", "password1", "enc1"]],
-        "delete": [["id"]],
-        "get":  [["username"]],
-        "edit": [["id"]],
-        "run": [["id"]]
-    }
-
-    def __init__(
-        self,
-        id=None,
-        username=None,
-        host1=None,
-        port1=None,
-        user1=None,
-        password1=None,
-        enc1=None,
-        mins_interval=None,
-        subfolder2=None,
-        maxage=None,
-        maxbytespersecond=None,
-        timeout1=None,
-        timeout2=None,
-        exclude=None,
-        custom_parameters=None,
-        delete2duplicates=None,
-        delete1=None,
-        delete2=None,
-        automap=None,
-        skipcrossduplicates=None,
-        subscribeall=None,
-        active=None,
-        force=None,
-        **kwargs
-    ):
-        self.mailcow = Mailcow()
-
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-        self.id = id
-        self.username = username
-        self.host1 = host1
-        self.port1 = port1
-        self.user1 = user1
-        self.password1 = password1
-        self.enc1 = enc1
-        self.mins_interval = mins_interval
-        self.subfolder2 = subfolder2
-        self.maxage = maxage
-        self.maxbytespersecond = maxbytespersecond
-        self.timeout1 = timeout1
-        self.timeout2 = timeout2
-        self.exclude = exclude
-        self.custom_parameters = custom_parameters
-        self.delete2duplicates = delete2duplicates
-        self.delete1 = delete1
-        self.delete2 = delete2
-        self.automap = automap
-        self.skipcrossduplicates = skipcrossduplicates
-        self.subscribeall = subscribeall
-        self.active = active
-        self.force = force
-
-    @classmethod
-    def from_dict(cls, data):
-        return cls(
-            username=data.get("username"),
-            host1=data.get("host1"),
-            port1=data.get("port1"),
-            user1=data.get("user1"),
-            password1=data.get("password1"),
-            enc1=data.get("enc1"),
-            mins_interval=data.get("mins_interval", None),
-            subfolder2=data.get("subfolder2", None),
-            maxage=data.get("maxage", None),
-            maxbytespersecond=data.get("maxbytespersecond", None),
-            timeout1=data.get("timeout1", None),
-            timeout2=data.get("timeout2", None),
-            exclude=data.get("exclude", None),
-            custom_parameters=data.get("custom_parameters", None),
-            delete2duplicates=data.get("delete2duplicates", None),
-            delete1=data.get("delete1", None),
-            delete2=data.get("delete2", None),
-            automap=data.get("automap", None),
-            skipcrossduplicates=data.get("skipcrossduplicates", None),
-            subscribeall=data.get("subscribeall", None),
-            active=data.get("active", None),
-        )
-
-    def getAdd(self):
-        """
-        Get the sync job details as a dictionary for adding, sets default values.
-        :return: Dictionary containing sync job details.
-        """
-        syncjob = {
-            "username": self.username,
-            "host1": self.host1,
-            "port1": self.port1,
-            "user1": self.user1,
-            "password1": self.password1,
-            "enc1": self.enc1,
-            "mins_interval": self.mins_interval if self.mins_interval is not None else 20,
-            "subfolder2": self.subfolder2 if self.subfolder2 is not None else "",
-            "maxage": self.maxage if self.maxage is not None else 0,
-            "maxbytespersecond": self.maxbytespersecond if self.maxbytespersecond is not None else 0,
-            "timeout1": self.timeout1 if self.timeout1 is not None else 600,
-            "timeout2": self.timeout2 if self.timeout2 is not None else 600,
-            "exclude": self.exclude if self.exclude is not None else "(?i)spam|(?i)junk",
-            "custom_parameters": self.custom_parameters if self.custom_parameters is not None else "",
-            "delete2duplicates": 1 if self.delete2duplicates else 0,
-            "delete1": 1 if self.delete1 else 0,
-            "delete2": 1 if self.delete2 else 0,
-            "automap": 1 if self.automap else 0,
-            "skipcrossduplicates": 1 if self.skipcrossduplicates else 0,
-            "subscribeall": 1 if self.subscribeall else 0,
-            "active": 1 if self.active else 0
-        }
-        return {key: value for key, value in syncjob.items() if value is not None}
-
-    def getEdit(self):
-        """
-        Get the sync job details as a dictionary for editing, sets no default values.
-        :return: Dictionary containing sync job details.
-        """
-        syncjob = {
-            "username": self.username,
-            "host1": self.host1,
-            "port1": self.port1,
-            "user1": self.user1,
-            "password1": self.password1,
-            "enc1": self.enc1,
-            "mins_interval": self.mins_interval,
-            "subfolder2": self.subfolder2,
-            "maxage": self.maxage,
-            "maxbytespersecond": self.maxbytespersecond,
-            "timeout1": self.timeout1,
-            "timeout2": self.timeout2,
-            "exclude": self.exclude,
-            "custom_parameters": self.custom_parameters,
-            "delete2duplicates": self.delete2duplicates,
-            "delete1": self.delete1,
-            "delete2": self.delete2,
-            "automap": self.automap,
-            "skipcrossduplicates": self.skipcrossduplicates,
-            "subscribeall": self.subscribeall,
-            "active": self.active
-        }
-        return {key: value for key, value in syncjob.items() if value is not None}
-
-    def get(self):
-        """
-        Get the sync job details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.getSyncjob(self.username)
-
-    def delete(self):
-        """
-        Get the sync job details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.deleteSyncjob(self.id)
-
-    def add(self):
-        """
-        Get the sync job details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.addSyncjob(self.getAdd())
-
-    def edit(self):
-        """
-        Get the sync job details from the mailcow API.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.editSyncjob(self.id, self.getEdit())
-
-    def run(self):
-        """
-        Run the sync job.
-        :return: Response from the mailcow API.
-        """
-        return self.mailcow.runSyncjob(self.id, force=self.force)
-
-    @classmethod
-    def add_parser(cls, subparsers):
-        parser = subparsers.add_parser(
-            cls.parser_command,
-            help="Manage sync jobs (add, delete, get, edit)"
-        )
-        parser.add_argument("object", choices=list(cls.required_args.keys()), help="Action to perform: add, delete, get, edit")
-        parser.add_argument("--id", help="Syncjob object ID (required for edit, delete, run)")
-        parser.add_argument("--username", help="Target mailbox username (e.g. user@example.com)")
-        parser.add_argument("--host1", help="Source IMAP server hostname")
-        parser.add_argument("--port1", help="Source IMAP server port")
-        parser.add_argument("--user1", help="Source IMAP account username")
-        parser.add_argument("--password1", help="Source IMAP account password")
-        parser.add_argument("--enc1", choices=["PLAIN", "SSL", "TLS"], help="Encryption for source server connection")
-        parser.add_argument("--mins-interval", help="Sync interval in minutes (default: 20)")
-        parser.add_argument("--subfolder2", help="Destination subfolder (default: empty)")
-        parser.add_argument("--maxage", help="Maximum mail age in days (default: 0 = unlimited)")
-        parser.add_argument("--maxbytespersecond", help="Maximum bandwidth in bytes/sec (default: 0 = unlimited)")
-        parser.add_argument("--timeout1", help="Timeout for source server in seconds (default: 600)")
-        parser.add_argument("--timeout2", help="Timeout for destination server in seconds (default: 600)")
-        parser.add_argument("--exclude", help="Regex pattern to exclude folders (default: (?i)spam|(?i)junk)")
-        parser.add_argument("--custom-parameters", help="Additional imapsync parameters")
-        parser.add_argument("--delete2duplicates", choices=["1", "0"], help="Delete duplicates on destination (1 = yes, 0 = no)")
-        parser.add_argument("--del1", choices=["1", "0"], help="Delete mails on source after sync (1 = yes, 0 = no)")
-        parser.add_argument("--del2", choices=["1", "0"], help="Delete mails on destination after sync (1 = yes, 0 = no)")
-        parser.add_argument("--automap", choices=["1", "0"], help="Enable folder automapping (1 = yes, 0 = no)")
-        parser.add_argument("--skipcrossduplicates", choices=["1", "0"], help="Skip cross-account duplicates (1 = yes, 0 = no)")
-        parser.add_argument("--subscribeall", choices=["1", "0"], help="Subscribe to all folders (1 = yes, 0 = no)")
-        parser.add_argument("--active", choices=["1", "0"], help="Activate syncjob (1 = yes, 0 = no)")
-        parser.add_argument("--force", action="store_true", help="Force the syncjob to run even if it is not active")
-

data/Dockerfiles/controller/mailcow-adm/modules/Docker.py

@@ -1,128 +0,0 @@
-import docker
-from docker.errors import APIError
-
-class Docker:
-    def __init__(self):
-        self.client = docker.from_env()
-
-    def exec_command(self, container_name, cmd, user=None):
-        """
-        Execute a command in a container by its container name.
-        :param container_name: The name of the container.
-        :param cmd: The command to execute as a list (e.g., ["ls", "-la"]).
-        :param user: The user to execute the command as (optional).
-        :return: A standardized response with status, output, and exit_code.
-        """
-
-        filters = {"name": container_name}
-
-        try:
-            for container in self.client.containers.list(filters=filters):
-                exec_result = container.exec_run(cmd, user=user)
-                return {
-                    "status": "success",
-                    "exit_code": exec_result.exit_code,
-                    "output": exec_result.output.decode("utf-8")
-                }
-        except APIError as e:
-            return {
-                "status": "error",
-                "exit_code": "APIError",
-                "output": str(e)
-            }
-        except Exception as e:
-            return {
-                "status": "error",
-                "exit_code": "Exception",
-                "output": str(e)
-            }
-
-    def start_container(self, container_name):
-        """
-        Start a container by its container name.
-        :param container_name: The name of the container.
-        :return: A standardized response with status, output, and exit_code.
-        """
-
-        filters = {"name": container_name}
-
-        try:
-            for container in self.client.containers.list(filters=filters):
-                container.start()
-                return {
-                    "status": "success",
-                    "exit_code": "0",
-                    "output": f"Container '{container_name}' started successfully."
-                }
-        except APIError as e:
-            return {
-                "status": "error",
-                "exit_code": "APIError",
-                "output": str(e)
-            }
-        except Exception as e:
-            return {
-                "status": "error",
-                "error_type": "Exception",
-                "output": str(e)
-            }
-
-    def stop_container(self, container_name):
-        """
-        Stop a container by its container name.
-        :param container_name: The name of the container.
-        :return: A standardized response with status, output, and exit_code.
-        """
-
-        filters = {"name": container_name}
-
-        try:
-            for container in self.client.containers.list(filters=filters):
-                container.stop()
-                return {
-                    "status": "success",
-                    "exit_code": "0",
-                    "output": f"Container '{container_name}' stopped successfully."
-                }
-        except APIError as e:
-            return {
-                "status": "error",
-                "exit_code": "APIError",
-                "output": str(e)
-            }
-        except Exception as e:
-            return {
-                "status": "error",
-                "exit_code": "Exception",
-                "output": str(e)
-            }
-
-    def restart_container(self, container_name):
-        """
-        Restart a container by its container name.
-        :param container_name: The name of the container.
-        :return: A standardized response with status, output, and exit_code.
-        """
-
-        filters = {"name": container_name}
-
-        try:
-            for container in self.client.containers.list(filters=filters):
-                container.restart()
-                return {
-                    "status": "success",
-                    "exit_code": "0",
-                    "output": f"Container '{container_name}' restarted successfully."
-                }
-        except APIError as e:
-            return {
-                "status": "error",
-                "exit_code": "APIError",
-                "output": str(e)
-            }
-        except Exception as e:
-            return {
-                "status": "error",
-                "exit_code": "Exception",
-                "output": str(e)
-            }

data/Dockerfiles/controller/mailcow-adm/modules/Dovecot.py

@@ -1,206 +0,0 @@
-import os
-
-from modules.Docker import Docker
-
-class Dovecot:
-    def __init__(self):
-        self.docker = Docker()
-
-    def decryptMaildir(self, source_dir="/var/vmail/", output_dir=None):
-        """
-        Decrypt files in /var/vmail using doveadm if they are encrypted.
-        :param output_dir: Directory inside the Dovecot container to store decrypted files, Default overwrite.
-        """
-        private_key = "/mail_crypt/ecprivkey.pem"
-        public_key = "/mail_crypt/ecpubkey.pem"
-
-        if output_dir:
-            # Ensure the output directory exists inside the container
-            mkdir_result = self.docker.exec_command("dovecot-mailcow", f"bash -c 'mkdir -p {output_dir} && chown vmail:vmail {output_dir}'")
-            if mkdir_result.get("status") != "success":
-                print(f"Error creating output directory: {mkdir_result.get('output')}")
-                return
-
-        find_command = [
-            "find", source_dir, "-type", "f", "-regextype", "egrep", "-regex", ".*S=.*W=.*"
-        ]
-
-        try:
-            find_result = self.docker.exec_command("dovecot-mailcow", " ".join(find_command))
-            if find_result.get("status") != "success":
-                print(f"Error finding files: {find_result.get('output')}")
-                return
-
-            files = find_result.get("output", "").splitlines()
-
-            for file in files:
-                head_command = f"head -c7 {file}"
-                head_result = self.docker.exec_command("dovecot-mailcow", head_command)
-                if head_result.get("status") == "success" and head_result.get("output", "").strip() == "CRYPTED":
-                    if output_dir:
-                        # Preserve the directory structure in the output directory
-                        relative_path = os.path.relpath(file, source_dir)
-                        output_file = os.path.join(output_dir, relative_path)
-                        current_path = output_dir
-                        for part in os.path.dirname(relative_path).split(os.sep):
-                            current_path = os.path.join(current_path, part)
-                            mkdir_result = self.docker.exec_command("dovecot-mailcow", f"bash -c '[ ! -d {current_path} ] && mkdir {current_path} && chown vmail:vmail {current_path}'")
-                            if mkdir_result.get("status") != "success":
-                                print(f"Error creating directory {current_path}: {mkdir_result.get('output')}")
-                                continue
-                    else:
-                        # Overwrite the original file
-                        output_file = file
-
-                    decrypt_command = (
-                        f"bash -c 'doveadm fs get compress lz4:1:crypt:private_key_path={private_key}:public_key_path={public_key}:posix:prefix=/ {file} > {output_file}'"
-                    )
-
-                    decrypt_result = self.docker.exec_command("dovecot-mailcow", decrypt_command)
-                    if decrypt_result.get("status") == "success":
-                        print(f"Decrypted {file}")
-
-                        # Verify the file size and set permissions
-                        size_check_command = f"bash -c '[ -s {output_file} ] && chmod 600 {output_file} && chown vmail:vmail {output_file} || rm -f {output_file}'"
-                        size_check_result = self.docker.exec_command("dovecot-mailcow", size_check_command)
-                        if size_check_result.get("status") != "success":
-                            print(f"Error setting permissions for {output_file}: {size_check_result.get('output')}\n")
-
-        except Exception as e:
-            print(f"Error during decryption: {e}")
-
-        return "Done"
-
-    def encryptMaildir(self, source_dir="/var/vmail/", output_dir=None):
-        """
-        Encrypt files in /var/vmail using doveadm if they are not already encrypted.
-        :param source_dir: Directory inside the Dovecot container to encrypt files.
-        :param output_dir: Directory inside the Dovecot container to store encrypted files, Default overwrite.
-        """
-        private_key = "/mail_crypt/ecprivkey.pem"
-        public_key = "/mail_crypt/ecpubkey.pem"
-
-        if output_dir:
-            # Ensure the output directory exists inside the container
-            mkdir_result = self.docker.exec_command("dovecot-mailcow", f"mkdir -p {output_dir}")
-            if mkdir_result.get("status") != "success":
-                print(f"Error creating output directory: {mkdir_result.get('output')}")
-                return
-
-        find_command = [
-            "find", source_dir, "-type", "f", "-regextype", "egrep", "-regex", ".*S=.*W=.*"
-        ]
-
-        try:
-            find_result = self.docker.exec_command("dovecot-mailcow", " ".join(find_command))
-            if find_result.get("status") != "success":
-                print(f"Error finding files: {find_result.get('output')}")
-                return
-
-            files = find_result.get("output", "").splitlines()
-
-            for file in files:
-                head_command = f"head -c7 {file}"
-                head_result = self.docker.exec_command("dovecot-mailcow", head_command)
-                if head_result.get("status") == "success" and head_result.get("output", "").strip() != "CRYPTED":
-                    if output_dir:
-                        # Preserve the directory structure in the output directory
-                        relative_path = os.path.relpath(file, source_dir)
-                        output_file = os.path.join(output_dir, relative_path)
-                        current_path = output_dir
-                        for part in os.path.dirname(relative_path).split(os.sep):
-                            current_path = os.path.join(current_path, part)
-                            mkdir_result = self.docker.exec_command("dovecot-mailcow", f"bash -c '[ ! -d {current_path} ] && mkdir {current_path} && chown vmail:vmail {current_path}'")
-                            if mkdir_result.get("status") != "success":
-                                print(f"Error creating directory {current_path}: {mkdir_result.get('output')}")
-                                continue
-                    else:
-                        # Overwrite the original file
-                        output_file = file
-
-                    encrypt_command = (
-                        f"bash -c 'doveadm fs put crypt private_key_path={private_key}:public_key_path={public_key}:posix:prefix=/ {file} {output_file}'"
-                    )
-
-                    encrypt_result = self.docker.exec_command("dovecot-mailcow", encrypt_command)
-                    if encrypt_result.get("status") == "success":
-                        print(f"Encrypted {file}")
-
-                        # Set permissions
-                        permissions_command = f"bash -c 'chmod 600 {output_file} && chown 5000:5000 {output_file}'"
-                        permissions_result = self.docker.exec_command("dovecot-mailcow", permissions_command)
-                        if permissions_result.get("status") != "success":
-                            print(f"Error setting permissions for {output_file}: {permissions_result.get('output')}\n")
-
-        except Exception as e:
-            print(f"Error during encryption: {e}")
-
-        return "Done"
-
-    def listDeletedMaildirs(self, source_dir="/var/vmail/_garbage"):
-        """
-        List deleted maildirs in the specified garbage directory.
-        :param source_dir: Directory to search for deleted maildirs.
-        :return: List of maildirs.
-        """
-        list_command = ["bash", "-c", f"ls -la {source_dir}"]
-
-        try:
-            result = self.docker.exec_command("dovecot-mailcow", list_command)
-            if result.get("status") != "success":
-                print(f"Error listing deleted maildirs: {result.get('output')}")
-                return []
-
-            lines = result.get("output", "").splitlines()
-            maildirs = {}
-
-            for idx, line in enumerate(lines):
-                parts = line.split()
-                if "_" in line:
-                    folder_name = parts[-1]
-                    time, maildir = folder_name.split("_", 1)
-
-                    if maildir.endswith("_index"):
-                        main_item = maildir[:-6]
-                        if main_item in maildirs:
-                            maildirs[main_item]["has_index"] = True
-                    else:
-                        maildirs[maildir] = {"item": idx, "time": time, "name": maildir, "has_index": False}
-
-            return list(maildirs.values())
-
-        except Exception as e:
-            print(f"Error during listing deleted maildirs: {e}")
-            return []
-
-    def restoreMaildir(self, username, item, source_dir="/var/vmail/_garbage"):
-        """
-        Restore a maildir item for a specific user from the deleted maildirs.
-        :param username: Username to restore the item to.
-        :param item: Item to restore (e.g., mailbox, folder).
-        :param source_dir: Directory containing deleted maildirs.
-        :return: Response from Dovecot.
-        """
-        username_splitted = username.split("@")
-        maildirs = self.listDeletedMaildirs()
-
-        maildir = None
-        for mdir in maildirs:
-            if mdir["item"] == int(item):
-                maildir = mdir
-                break
-        if not maildir:
-            return {"status": "error", "message": "Maildir not found."}
-
-        restore_command = f"mv {source_dir}/{maildir['time']}_{maildir['name']} /var/vmail/{username_splitted[1]}/{username_splitted[0]}"
-        restore_index_command = f"mv {source_dir}/{maildir['time']}_{maildir['name']}_index /var/vmail_index/{username}"
-
-        result = self.docker.exec_command("dovecot-mailcow", ["bash", "-c", restore_command])
-        if result.get("status") != "success":
-            return {"status": "error", "message": "Failed to restore maildir."}
-
-        result = self.docker.exec_command("dovecot-mailcow", ["bash", "-c", restore_index_command])
-        if result.get("status") != "success":
-            return {"status": "error", "message": "Failed to restore maildir index."}
-
-        return "Done"

data/Dockerfiles/controller/mailcow-adm/modules/Mailcow.py

@@ -1,457 +0,0 @@
-import requests
-import urllib3
-import sys
-import os
-import subprocess
-import tempfile
-import mysql.connector
-from contextlib import contextmanager
-from datetime import datetime
-from modules.Docker import Docker
-
-
-class Mailcow:
-    def __init__(self):
-        self.apiUrl = "/api/v1"
-        self.ignore_ssl_errors = True
-
-        self.baseUrl = f"https://{os.getenv('IPv4_NETWORK', '172.22.1')}.247:{os.getenv('HTTPS_PORT', '443')}"
-        self.host = os.getenv("MAILCOW_HOSTNAME", "")
-        self.apiKey = ""
-        if self.ignore_ssl_errors:
-            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-        self.db_config = {
-            'user': os.getenv('DBUSER'),
-            'password': os.getenv('DBPASS'),
-            'database': os.getenv('DBNAME'),
-            'unix_socket': '/var/run/mysqld/mysqld.sock',
-        }
-
-        self.docker = Docker()
-
-
-    # API Functions
-    def addDomain(self, domain):
-        """
-        Add a domain to the mailcow instance.
-        :param domain: Dictionary containing domain details.
-        :return: Response from the mailcow API.
-        """
-
-        return self.post('/add/domain', domain)
-
-    def addMailbox(self, mailbox):
-        """
-        Add a mailbox to the mailcow instance.
-        :param mailbox: Dictionary containing mailbox details.
-        :return: Response from the mailcow API.
-        """
-
-        return self.post('/add/mailbox', mailbox)
-
-    def addAlias(self, alias):
-        """
-        Add an alias to the mailcow instance.
-        :param alias: Dictionary containing alias details.
-        :return: Response from the mailcow API.
-        """
-
-        return self.post('/add/alias', alias)
-
-    def addSyncjob(self, syncjob):
-        """
-        Add a sync job to the mailcow instance.
-        :param syncjob: Dictionary containing sync job details.
-        :return: Response from the mailcow API.
-        """
-
-        return self.post('/add/syncjob', syncjob)
-
-    def addDomainadmin(self, domainadmin):
-        """
-        Add a domain admin to the mailcow instance.
-        :param domainadmin: Dictionary containing domain admin details.
-        :return: Response from the mailcow API.
-        """
-
-        return self.post('/add/domain-admin', domainadmin)
-
-    def deleteDomain(self, domain):
-        """
-        Delete a domain from the mailcow instance.
-        :param domain: Name of the domain to delete.
-        :return: Response from the mailcow API.
-        """
-
-        items = [domain]
-        return self.post('/delete/domain', items)
-
-    def deleteAlias(self, id):
-        """
-        Delete an alias from the mailcow instance.
-        :param id: ID of the alias to delete.
-        :return: Response from the mailcow API.
-        """
-
-        items = [id]
-        return self.post('/delete/alias', items)
-
-    def deleteSyncjob(self, id):
-        """
-        Delete a sync job from the mailcow instance.
-        :param id: ID of the sync job to delete.
-        :return: Response from the mailcow API.
-        """
-
-        items = [id]
-        return self.post('/delete/syncjob', items)
-
-    def deleteMailbox(self, mailbox):
-        """
-        Delete a mailbox from the mailcow instance.
-        :param mailbox: Name of the mailbox to delete.
-        :return: Response from the mailcow API.
-        """
-
-        items = [mailbox]
-        return self.post('/delete/mailbox', items)
-
-    def deleteDomainadmin(self, username):
-        """
-        Delete a domain admin from the mailcow instance.
-        :param username: Username of the domain admin to delete.
-        :return: Response from the mailcow API.
-        """
-
-        items = [username]
-        return self.post('/delete/domain-admin', items)
-
-    def post(self, endpoint, data):
-        """
-        Make a POST request to the mailcow API.
-        :param endpoint: The API endpoint to post to.
-        :param data: Data to be sent in the POST request.
-        :return: Response from the mailcow API.
-        """
-
-        url = f"{self.baseUrl}{self.apiUrl}/{endpoint.lstrip('/')}"
-        headers = {
-            "Content-Type": "application/json",
-            "Host": self.host
-        }
-        if self.apiKey:
-            headers["X-Api-Key"] = self.apiKey
-        response = requests.post(
-            url,
-            json=data,
-            headers=headers,
-            verify=not self.ignore_ssl_errors
-        )
-        response.raise_for_status()
-        return response.json()
-
-    def getDomain(self, domain):
-        """
-        Get a domain from the mailcow instance.
-        :param domain: Name of the domain to get.
-        :return: Response from the mailcow API.
-        """
-
-        return self.get(f'/get/domain/{domain}')
-
-    def getMailbox(self, username):
-        """
-        Get a mailbox from the mailcow instance.
-        :param mailbox: Dictionary containing mailbox details (e.g. {"username": "user@example.com"})
-        :return: Response from the mailcow API.
-        """
-        return self.get(f'/get/mailbox/{username}')
-
-    def getAlias(self, id):
-        """
-        Get an alias from the mailcow instance.
-        :param alias: Dictionary containing alias details (e.g. {"address": "alias@example.com"})
-        :return: Response from the mailcow API.
-        """
-        return self.get(f'/get/alias/{id}')
-
-    def getSyncjob(self, id):
-        """
-        Get a sync job from the mailcow instance.
-        :param syncjob: Dictionary containing sync job details (e.g. {"id": "123"})
-        :return: Response from the mailcow API.
-        """
-        return self.get(f'/get/syncjobs/{id}')
-
-    def getDomainadmin(self, username):
-        """
-        Get a domain admin from the mailcow instance.
-        :param username: Username of the domain admin to get.
-        :return: Response from the mailcow API.
-        """
-        return self.get(f'/get/domain-admin/{username}')
-
-    def getStatusVersion(self):
-        """
-        Get the version of the mailcow instance.
-        :return: Response from the mailcow API.
-        """
-        return self.get('/get/status/version')
-
-    def getStatusVmail(self):
-        """
-        Get the vmail status from the mailcow instance.
-        :return: Response from the mailcow API.
-        """
-        return self.get('/get/status/vmail')
-
-    def getStatusContainers(self):
-        """
-        Get the status of containers from the mailcow instance.
-        :return: Response from the mailcow API.
-        """
-        return self.get('/get/status/containers')
-
-    def get(self, endpoint, params=None):
-        """
-        Make a GET request to the mailcow API.
-        :param endpoint: The API endpoint to get from.
-        :param params: Parameters to be sent in the GET request.
-        :return: Response from the mailcow API.
-        """
-
-        url = f"{self.baseUrl}{self.apiUrl}/{endpoint.lstrip('/')}"
-        headers = {
-            "Content-Type": "application/json",
-            "Host": self.host
-        }
-        if self.apiKey:
-            headers["X-Api-Key"] = self.apiKey
-        response = requests.get(
-            url,
-            params=params,
-            headers=headers,
-            verify=not self.ignore_ssl_errors
-        )
-        response.raise_for_status()
-        return response.json()
-
-    def editDomain(self, domain, attributes):
-        """
-        Edit an existing domain in the mailcow instance.
-        :param domain: Name of the domain to edit
-        :param attributes: Dictionary containing the new domain attributes.
-        """
-
-        items = [domain]
-        return self.edit('/edit/domain', items, attributes)
-
-    def editMailbox(self, mailbox, attributes):
-        """
-        Edit an existing mailbox in the mailcow instance.
-        :param mailbox: Name of the mailbox to edit
-        :param attributes: Dictionary containing the new mailbox attributes.
-        """
-
-        items = [mailbox]
-        return self.edit('/edit/mailbox', items, attributes)
-
-    def editAlias(self, alias, attributes):
-        """
-        Edit an existing alias in the mailcow instance.
-        :param alias: Name of the alias to edit
-        :param attributes: Dictionary containing the new alias attributes.
-        """
-
-        items = [alias]
-        return self.edit('/edit/alias', items, attributes)
-
-    def editSyncjob(self, syncjob, attributes):
-        """
-        Edit an existing sync job in the mailcow instance.
-        :param syncjob: Name of the sync job to edit
-        :param attributes: Dictionary containing the new sync job attributes.
-        """
-
-        items = [syncjob]
-        return self.edit('/edit/syncjob', items, attributes)
-
-    def editDomainadmin(self, username, attributes):
-        """
-        Edit an existing domain admin in the mailcow instance.
-        :param username: Username of the domain admin to edit
-        :param attributes: Dictionary containing the new domain admin attributes.
-        """
-
-        items = [username]
-        return self.edit('/edit/domain-admin', items, attributes)
-
-    def edit(self, endpoint, items, attributes):
-        """
-        Make a POST request to edit items in the mailcow API.
-        :param items: List of items to edit.
-        :param attributes: Dictionary containing the new attributes for the items.
-        :return: Response from the mailcow API.
-        """
-
-        url = f"{self.baseUrl}{self.apiUrl}/{endpoint.lstrip('/')}"
-        headers = {
-            "Content-Type": "application/json",
-            "Host": self.host
-        }
-        if self.apiKey:
-            headers["X-Api-Key"] = self.apiKey
-        data = {
-            "items": items,
-            "attr": attributes
-        }
-        response = requests.post(
-            url,
-            json=data,
-            headers=headers,
-            verify=not self.ignore_ssl_errors
-        )
-        response.raise_for_status()
-        return response.json()
-
-
-    # System Functions
-    def runSyncjob(self, id, force=False):
-        """
-        Run a sync job.
-        :param id: ID of the sync job to run.
-        :return: Response from the imapsync script.
-        """
-
-        creds_path = "/app/sieve.creds"
-
-        conn = mysql.connector.connect(**self.db_config)
-        cursor = conn.cursor(dictionary=True)
-
-        with open(creds_path, 'r') as file:
-            master_user, master_pass = file.read().strip().split(':')
-
-        query = ("SELECT * FROM imapsync WHERE id = %s")
-        cursor.execute(query, (id,))
-
-        success = False
-        syncjob = cursor.fetchone()
-        if not syncjob:
-            cursor.close()
-            conn.close()
-            return f"Sync job with ID {id} not found."
-        if syncjob['active'] == 0 and not force:
-            cursor.close()
-            conn.close()
-            return f"Sync job with ID {id} is not active."
-
-        enc1_flag = "--tls1" if syncjob['enc1'] == "TLS" else "--ssl1" if syncjob['enc1'] == "SSL" else None
-
-
-        passfile1_path = f"/tmp/passfile1_{id}.txt"
-        passfile2_path = f"/tmp/passfile2_{id}.txt"
-        passfile1_cmd = [
-            "sh", "-c",
-            f"echo {syncjob['password1']} > {passfile1_path}"
-        ]
-        passfile2_cmd = [
-            "sh", "-c",
-            f"echo {master_pass} > {passfile2_path}"
-        ]
-
-        self.docker.exec_command("dovecot-mailcow", passfile1_cmd)
-        self.docker.exec_command("dovecot-mailcow", passfile2_cmd)
-
-        imapsync_cmd = [
-            "/usr/local/bin/imapsync",
-            "--tmpdir", "/tmp",
-            "--nofoldersizes",
-            "--addheader"
-        ]
-
-        if int(syncjob['timeout1']) > 0:
-            imapsync_cmd.extend(['--timeout1', str(syncjob['timeout1'])])
-        if int(syncjob['timeout2']) > 0:
-            imapsync_cmd.extend(['--timeout2', str(syncjob['timeout2'])])
-        if syncjob['exclude']:
-            imapsync_cmd.extend(['--exclude', syncjob['exclude']])
-        if syncjob['subfolder2']:
-            imapsync_cmd.extend(['--subfolder2', syncjob['subfolder2']])
-        if int(syncjob['maxage']) > 0:
-            imapsync_cmd.extend(['--maxage', str(syncjob['maxage'])])
-        if int(syncjob['maxbytespersecond']) > 0:
-            imapsync_cmd.extend(['--maxbytespersecond', str(syncjob['maxbytespersecond'])])
-        if int(syncjob['delete2duplicates']) == 1:
-            imapsync_cmd.append("--delete2duplicates")
-        if int(syncjob['subscribeall']) == 1:
-            imapsync_cmd.append("--subscribeall")
-        if int(syncjob['delete1']) == 1:
-            imapsync_cmd.append("--delete")
-        if int(syncjob['delete2']) == 1:
-            imapsync_cmd.append("--delete2")
-        if int(syncjob['automap']) == 1:
-            imapsync_cmd.append("--automap")
-        if int(syncjob['skipcrossduplicates']) == 1:
-            imapsync_cmd.append("--skipcrossduplicates")
-        if enc1_flag:
-            imapsync_cmd.append(enc1_flag)
-
-        imapsync_cmd.extend([
-            "--host1", syncjob['host1'],
-            "--user1", syncjob['user1'],
-            "--passfile1", passfile1_path,
-            "--port1", str(syncjob['port1']),
-            "--host2", "localhost",
-            "--user2", f"{syncjob['user2']}*{master_user}",
-            "--passfile2", passfile2_path
-        ])
-
-        if syncjob['dry'] == 1:
-            imapsync_cmd.append("--dry")
-
-        imapsync_cmd.extend([
-            "--no-modulesversion",
-            "--noreleasecheck"
-        ])
-
-        try:
-            cursor.execute("UPDATE imapsync SET is_running = 1, success = NULL, exit_status = NULL WHERE id = %s", (id,))
-            conn.commit()
-
-            result = self.docker.exec_command("dovecot-mailcow", imapsync_cmd)
-            print(result)
-
-            success = result['status'] == "success" and result['exit_code'] == 0
-            cursor.execute(
-                "UPDATE imapsync SET returned_text = %s, success = %s, exit_status = %s WHERE id = %s",
-                (result['output'], int(success), result['exit_code'], id)
-            )
-            conn.commit()
-
-        except Exception as e:
-            cursor.execute(
-                "UPDATE imapsync SET returned_text = %s, success = 0 WHERE id = %s",
-                (str(e), id)
-            )
-            conn.commit()
-
-        finally:
-            cursor.execute("UPDATE imapsync SET last_run = NOW(), is_running = 0 WHERE id = %s", (id,))
-            conn.commit()
-
-        delete_passfile1_cmd = [
-            "sh", "-c",
-            f"rm -f {passfile1_path}"
-        ]
-        delete_passfile2_cmd = [
-            "sh", "-c",
-            f"rm -f {passfile2_path}"
-        ]
-        self.docker.exec_command("dovecot-mailcow", delete_passfile1_cmd)
-        self.docker.exec_command("dovecot-mailcow", delete_passfile2_cmd)
-
-        cursor.close()
-        conn.close()
-
-        return "Sync job completed successfully." if success else "Sync job failed."

data/Dockerfiles/controller/mailcow-adm/modules/Mailer.py

@@ -1,64 +0,0 @@
-import smtplib
-import json
-import os
-from email.mime.text import MIMEText
-from email.mime.multipart import MIMEMultipart
-from jinja2 import Environment, BaseLoader
-
-class Mailer:
-    def __init__(self, smtp_host, smtp_port, username, password, use_tls=True):
-        self.smtp_host = smtp_host
-        self.smtp_port = smtp_port
-        self.username = username
-        self.password = password
-        self.use_tls = use_tls
-        self.server = None
-        self.env = Environment(loader=BaseLoader())
-
-    def connect(self):
-        print("Connecting to the SMTP server...")
-        self.server = smtplib.SMTP(self.smtp_host, self.smtp_port)
-        if self.use_tls:
-            self.server.starttls()
-            print("TLS activated!")
-        if self.username and self.password:
-            self.server.login(self.username, self.password)
-            print("Authenticated!")
-
-    def disconnect(self):
-        if self.server:
-            try:
-                if self.server.sock:
-                    self.server.quit()
-            except smtplib.SMTPServerDisconnected:
-                pass
-            finally:
-                self.server = None
-
-    def render_inline_template(self, template_string, context):
-        template = self.env.from_string(template_string)
-        return template.render(context)
-
-    def send_mail(self, subject, from_addr, to_addrs, template, context = {}):
-        try:
-            if template == "":
-                print("Cannot send email, template is empty!")
-                return "Failed: Template is empty."
-
-            body = self.render_inline_template(template, context)
-
-            msg = MIMEMultipart()
-            msg['From'] = from_addr
-            msg['To'] = ', '.join(to_addrs) if isinstance(to_addrs, list) else to_addrs
-            msg['Subject'] = subject
-            msg.attach(MIMEText(body, 'html'))
-
-            self.connect()
-            self.server.sendmail(from_addr, to_addrs, msg.as_string())
-            self.disconnect()
-            return f"Success: Email sent to {msg['To']}"
-        except Exception as e:
-            print(f"Error during send_mail: {type(e).__name__}: {e}")
-            return f"Failed: {type(e).__name__}: {e}"
-        finally:
-            self.disconnect()

data/Dockerfiles/controller/mailcow-adm/modules/Reader.py

@@ -1,51 +0,0 @@
-from jinja2 import Environment, Template
-import csv
-
-def split_at(value, sep, idx):
-    try:
-        return value.split(sep)[idx]
-    except Exception:
-        return ''
-
-class Reader:
-    """
-    Reader class to handle reading and processing of CSV and JSON files for mailcow.
-    """
-
-    def __init__(self):
-        pass
-
-    def read_csv(self, file_path, delimiter=',', encoding='iso-8859-1'):
-        """
-        Read a CSV file and return a list of dictionaries.
-        Each dictionary represents a row in the CSV file.
-        :param file_path: Path to the CSV file.
-        :param delimiter: Delimiter used in the CSV file (default: ',').
-        """
-        with open(file_path, mode='r', encoding=encoding) as file:
-            reader = csv.DictReader(file, delimiter=delimiter)
-            reader.fieldnames = [h.replace(" ", "_") if h else h for h in reader.fieldnames]
-            return [row for row in reader]
-
-    def map_csv_data(self, data, mapping_file_path, encoding='iso-8859-1'):
-        """
-        Map CSV data to a specific structure based on the provided Jinja2 template file.
-        :param data: List of dictionaries representing CSV rows.
-        :param mapping_file_path: Path to the Jinja2 template file.
-        :return: List of dictionaries with mapped data.
-        """
-        with open(mapping_file_path, 'r', encoding=encoding) as tpl_file:
-            template_content = tpl_file.read()
-        env = Environment()
-        env.filters['split_at'] = split_at
-        template = env.from_string(template_content)
-
-        mapped_data = []
-        for row in data:
-            rendered = template.render(**row)
-            try:
-                mapped_row = eval(rendered)
-            except Exception:
-                mapped_row = rendered
-            mapped_data.append(mapped_row)
-        return mapped_data

data/Dockerfiles/controller/mailcow-adm/modules/Sogo.py

@@ -1,512 +0,0 @@
-import requests
-import urllib3
-import os
-from uuid import uuid4
-from collections import defaultdict
-
-
-class Sogo:
-    def __init__(self, username, password=""):
-        self.apiUrl = "/SOGo/so"
-        self.davUrl = "/SOGo/dav"
-        self.ignore_ssl_errors = True
-
-        self.baseUrl = f"https://{os.getenv('IPv4_NETWORK', '172.22.1')}.247:{os.getenv('HTTPS_PORT', '443')}"
-        self.host = os.getenv("MAILCOW_HOSTNAME", "")
-        if self.ignore_ssl_errors:
-            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-        self.username = username
-        self.password = password
-
-    def addCalendar(self, calendar_name):
-        """
-        Add a new calendar to the sogo instance.
-        :param calendar_name: Name of the calendar to be created
-        :return: Response from the sogo API.
-        """
-
-        res = self.post(f"/{self.username}/Calendar/createFolder", {
-            "name": calendar_name
-        })
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def getCalendarIdByName(self, calendar_name):
-        """
-        Get the calendar ID by its name.
-        :param calendar_name: Name of the calendar to find
-        :return: Calendar ID if found, otherwise None.
-        """
-
-        res = self.get(f"/{self.username}/Calendar/calendarslist")
-        try:
-            for calendar in res.json()["calendars"]:
-                if calendar['name'] == calendar_name:
-                    return calendar['id']
-        except ValueError:
-            return None
-        return None
-
-    def getCalendar(self):
-        """
-        Get calendar list.
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Calendar/calendarslist")
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def deleteCalendar(self, calendar_id):
-        """
-        Delete a calendar.
-        :param calendar_id: ID of the calendar to be deleted
-        :return: Response from SOGo API.
-        """
-        res = self.get(f"/{self.username}/Calendar/{calendar_id}/delete")
-        return res.status_code == 204
-
-    def importCalendar(self, calendar_name, ics_file):
-        """
-        Import a calendar from an ICS file.
-        :param calendar_name: Name of the calendar to import into
-        :param ics_file: Path to the ICS file to import
-        :return: Response from SOGo API.
-        """
-
-        try:
-            with open(ics_file, "rb") as f:
-                pass
-        except Exception as e:
-            print(f"Could not open ICS file '{ics_file}': {e}")
-            return {"status": "error", "message": str(e)}
-
-        new_calendar = self.addCalendar(calendar_name)
-        selected_calendar = new_calendar.json()["id"]
-
-        url = f"{self.baseUrl}{self.apiUrl}/{self.username}/Calendar/{selected_calendar}/import"
-        auth = (self.username, self.password)
-        with open(ics_file, "rb") as f:
-            files = {'icsFile': (ics_file, f, 'text/calendar')}
-            res = requests.post(
-                url,
-                files=files,
-                auth=auth,
-                verify=not self.ignore_ssl_errors
-            )
-            try:
-                return res.json()
-            except ValueError:
-                return res.text
-
-        return None
-
-    def setCalendarACL(self, calendar_id, sharee_email, acl="r", subscribe=False):
-        """
-        Set CalDAV calendar permissions for a user (sharee).
-        :param calendar_id: ID of the calendar to share
-        :param sharee_email: Email of the user to share with
-        :param acl: "w" for write, "r" for read-only or combination "rw" for read-write
-        :param subscribe: True will scubscribe the sharee to the calendar
-        :return: None
-        """
-
-        # Access rights
-        if acl == "" or len(acl) > 2:
-            return "Invalid acl level specified. Use 'w', 'r' or combinations like 'rw'."
-        rights = [{
-            "c_email": sharee_email,
-            "uid": sharee_email,
-            "userClass": "normal-user",
-            "rights": {
-                "Public": "None",
-                "Private": "None",
-                "Confidential": "None",
-                "canCreateObjects": 0,
-                "canEraseObjects": 0
-            }
-        }]
-        if "w" in acl:
-            rights[0]["rights"]["canCreateObjects"] = 1
-            rights[0]["rights"]["canEraseObjects"] = 1
-        if "r" in acl:
-            rights[0]["rights"]["Public"] = "Viewer"
-            rights[0]["rights"]["Private"] = "Viewer"
-            rights[0]["rights"]["Confidential"] = "Viewer"
-
-        r_add = self.get(f"/{self.username}/Calendar/{calendar_id}/addUserInAcls?uid={sharee_email}")
-        if r_add.status_code < 200 or r_add.status_code > 299:
-            try:
-                return r_add.json()
-            except ValueError:
-                return r_add.text
-
-        r_save = self.post(f"/{self.username}/Calendar/{calendar_id}/saveUserRights", rights)
-        if r_save.status_code < 200 or r_save.status_code > 299:
-            try:
-                return r_save.json()
-            except ValueError:
-                return r_save.text
-
-        if subscribe:
-            r_subscribe = self.get(f"/{self.username}/Calendar/{calendar_id}/subscribeUsers?uids={sharee_email}")
-            if r_subscribe.status_code < 200 or r_subscribe.status_code > 299:
-                try:
-                    return r_subscribe.json()
-                except ValueError:
-                    return r_subscribe.text
-
-        return r_save.status_code == 200
-
-    def getCalendarACL(self, calendar_id):
-        """
-        Get CalDAV calendar permissions for a user (sharee).
-        :param calendar_id: ID of the calendar to get ACL from
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Calendar/{calendar_id}/acls")
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def deleteCalendarACL(self, calendar_id, sharee_email):
-        """
-        Delete a calendar ACL for a user (sharee).
-        :param calendar_id: ID of the calendar to delete ACL from
-        :param sharee_email: Email of the user whose ACL to delete
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Calendar/{calendar_id}/removeUserFromAcls?uid={sharee_email}")
-        return res.status_code == 204
-
-    def addAddressbook(self, addressbook_name):
-        """
-        Add a new addressbook to the sogo instance.
-        :param addressbook_name: Name of the addressbook to be created
-        :return: Response from the sogo API.
-        """
-
-        res = self.post(f"/{self.username}/Contacts/createFolder", {
-            "name": addressbook_name
-        })
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def getAddressbookIdByName(self, addressbook_name):
-        """
-        Get the addressbook ID by its name.
-        :param addressbook_name: Name of the addressbook to find
-        :return: Addressbook ID if found, otherwise None.
-        """
-
-        res = self.get(f"/{self.username}/Contacts/addressbooksList")
-        try:
-            for addressbook in res.json()["addressbooks"]:
-                if addressbook['name'] == addressbook_name:
-                    return addressbook['id']
-        except ValueError:
-            return None
-        return None
-
-    def deleteAddressbook(self, addressbook_id):
-        """
-        Delete an addressbook.
-        :param addressbook_id: ID of the addressbook to be deleted
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Contacts/{addressbook_id}/delete")
-        return res.status_code == 204
-
-    def getAddressbookList(self):
-        """
-        Get addressbook list.
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Contacts/addressbooksList")
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def setAddressbookACL(self, addressbook_id, sharee_email, acl="r", subscribe=False):
-        """
-        Set CalDAV addressbook permissions for a user (sharee).
-        :param addressbook_id: ID of the addressbook to share
-        :param sharee_email: Email of the user to share with
-        :param acl: "w" for write, "r" for read-only or combination "rw" for read-write
-        :param subscribe: True will subscribe the sharee to the addressbook
-        :return: None
-        """
-
-        # Access rights
-        if acl == "" or len(acl) > 2:
-            print("Invalid acl level specified. Use 's', 'w', 'r' or combinations like 'rws'.")
-            return "Invalid acl level specified. Use 'w', 'r' or combinations like 'rw'."
-        rights = [{
-            "c_email": sharee_email,
-            "uid": sharee_email,
-            "userClass": "normal-user",
-            "rights": {
-                "canCreateObjects": 0,
-                "canEditObjects": 0,
-                "canEraseObjects": 0,
-                "canViewObjects": 0,
-            }
-        }]
-        if "w" in acl:
-            rights[0]["rights"]["canCreateObjects"] = 1
-            rights[0]["rights"]["canEditObjects"] = 1
-            rights[0]["rights"]["canEraseObjects"] = 1
-        if "r" in acl:
-            rights[0]["rights"]["canViewObjects"] = 1
-
-        r_add = self.get(f"/{self.username}/Contacts/{addressbook_id}/addUserInAcls?uid={sharee_email}")
-        if r_add.status_code < 200 or r_add.status_code > 299:
-            try:
-                return r_add.json()
-            except ValueError:
-                return r_add.text
-
-        r_save = self.post(f"/{self.username}/Contacts/{addressbook_id}/saveUserRights", rights)
-        if r_save.status_code < 200 or r_save.status_code > 299:
-            try:
-                return r_save.json()
-            except ValueError:
-                return r_save.text
-
-        if subscribe:
-            r_subscribe = self.get(f"/{self.username}/Contacts/{addressbook_id}/subscribeUsers?uids={sharee_email}")
-            if r_subscribe.status_code < 200 or r_subscribe.status_code > 299:
-                try:
-                    return r_subscribe.json()
-                except ValueError:
-                    return r_subscribe.text
-
-        return r_save.status_code == 200
-
-    def getAddressbookACL(self, addressbook_id):
-        """
-        Get CalDAV addressbook permissions for a user (sharee).
-        :param addressbook_id: ID of the addressbook to get ACL from
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Contacts/{addressbook_id}/acls")
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def deleteAddressbookACL(self, addressbook_id, sharee_email):
-        """
-        Delete an addressbook ACL for a user (sharee).
-        :param addressbook_id: ID of the addressbook to delete ACL from
-        :param sharee_email: Email of the user whose ACL to delete
-        :return: Response from SOGo API.
-        """
-
-        res = self.get(f"/{self.username}/Contacts/{addressbook_id}/removeUserFromAcls?uid={sharee_email}")
-        return res.status_code == 204
-
-    def getAddressbookNewGuid(self, addressbook_id):
-        """
-        Request a new GUID for a SOGo addressbook.
-        :param addressbook_id: ID of the addressbook
-        :return: JSON response from SOGo or None if not found
-        """
-        res = self.get(f"/{self.username}/Contacts/{addressbook_id}/newguid")
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def addAddressbookContact(self, addressbook_id, contact_name, contact_email):
-        """
-        Save a vCard as a contact in the specified addressbook.
-        :param addressbook_id: ID of the addressbook
-        :param contact_name: Name of the contact
-        :param contact_email: Email of the contact
-        :return: JSON response from SOGo or None if not found
-        """
-        vcard_id = self.getAddressbookNewGuid(addressbook_id)
-        contact_data = {
-            "id": vcard_id["id"],
-            "pid": vcard_id["pid"],
-            "c_cn": contact_name,
-            "emails": [{
-                "type": "pref",
-                "value": contact_email
-            }],
-            "isNew": True,
-            "c_component": "vcard",
-        }
-
-        endpoint = f"/{self.username}/Contacts/{addressbook_id}/{vcard_id['id']}/saveAsContact"
-        res = self.post(endpoint, contact_data)
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def getAddressbookContacts(self, addressbook_id, contact_email=None):
-        """
-        Get all contacts from the specified addressbook.
-        :param addressbook_id: ID of the addressbook
-        :return: JSON response with contacts or None if not found
-        """
-        res = self.get(f"/{self.username}/Contacts/{addressbook_id}/view")
-        try:
-            res_json = res.json()
-            headers = res_json.get("headers", [])
-            if not headers or len(headers) < 2:
-                return []
-
-            field_names = headers[0]
-            contacts = []
-            for row in headers[1:]:
-                contact = dict(zip(field_names, row))
-                contacts.append(contact)
-
-            if contact_email:
-                contact = {}
-                for c in contacts:
-                    if c["c_mail"] == contact_email or c["c_cn"] == contact_email:
-                        contact = c
-                        break
-                return contact
-
-            return contacts
-        except ValueError:
-            return res.text
-
-    def addAddressbookContactList(self, addressbook_id, contact_name, contact_email=None):
-        """
-        Add a new contact list to the addressbook.
-        :param addressbook_id: ID of the addressbook
-        :param contact_name: Name of the contact list
-        :param contact_email: Comma-separated emails to include in the list
-        :return: Response from SOGo API.
-        """
-        gal_domain = self.username.split("@")[-1]
-        vlist_id = self.getAddressbookNewGuid(addressbook_id)
-        contact_emails = contact_email.split(",") if contact_email else []
-        contacts = self.getAddressbookContacts(addressbook_id)
-
-        refs = []
-        for contact in contacts:
-            if contact['c_mail'] in contact_emails:
-                refs.append({
-                    "refs": [],
-                    "categories": [],
-                    "c_screenname": contact.get("c_screenname", ""),
-                    "pid": contact.get("pid", vlist_id["pid"]),
-                    "id": contact.get("id", ""),
-                    "notes": [""],
-                    "empty": " ",
-                    "hasphoto": contact.get("hasphoto", 0),
-                    "c_cn": contact.get("c_cn", ""),
-                    "c_uid": contact.get("c_uid", None),
-                    "containername": contact.get("containername", f"GAL {gal_domain}"),  # or your addressbook name
-                    "sourceid": contact.get("sourceid", gal_domain),
-                    "c_component": contact.get("c_component", "vcard"),
-                    "c_sn": contact.get("c_sn", ""),
-                    "c_givenname": contact.get("c_givenname", ""),
-                    "c_name": contact.get("c_name", contact.get("id", "")),
-                    "c_telephonenumber": contact.get("c_telephonenumber", ""),
-                    "fn": contact.get("fn", ""),
-                    "c_mail": contact.get("c_mail", ""),
-                    "emails": contact.get("emails", []),
-                    "c_o": contact.get("c_o", ""),
-                    "reference": contact.get("id", ""),
-                    "birthday": contact.get("birthday", "")
-                })
-
-        contact_data = {
-            "refs": refs,
-            "categories": [],
-            "c_screenname": None,
-            "pid": vlist_id["pid"],
-            "c_component": "vlist",
-            "notes": [""],
-            "empty": " ",
-            "isNew": True,
-            "id": vlist_id["id"],
-            "c_cn": contact_name,
-            "birthday": ""
-        }
-
-        endpoint = f"/{self.username}/Contacts/{addressbook_id}/{vlist_id['id']}/saveAsList"
-        res = self.post(endpoint, contact_data)
-        try:
-            return res.json()
-        except ValueError:
-            return res.text
-
-    def deleteAddressbookItem(self, addressbook_id, contact_name):
-        """
-        Delete an addressbook item by its ID.
-        :param addressbook_id: ID of the addressbook item to delete
-        :param contact_name: Name of the contact to delete
-        :return: Response from SOGo API.
-        """
-        res = self.getAddressbookContacts(addressbook_id, contact_name)
-
-        if "id" not in res:
-            print(f"Contact '{contact_name}' not found in addressbook '{addressbook_id}'.")
-            return None
-        res = self.post(f"/{self.username}/Contacts/{addressbook_id}/batchDelete", {
-            "uids": [res["id"]],
-        })
-        return res.status_code == 204
-
-    def get(self, endpoint, params=None):
-        """
-        Make a GET request to the mailcow API.
-        :param endpoint: The API endpoint to get.
-        :param params: Optional parameters for the GET request.
-        :return: Response from the mailcow API.
-        """
-        url = f"{self.baseUrl}{self.apiUrl}{endpoint}"
-        auth = (self.username, self.password)
-        headers = {"Host": self.host}
-
-        response = requests.get(
-            url,
-            params=params,
-            auth=auth,
-            headers=headers,
-            verify=not self.ignore_ssl_errors
-        )
-        return response
-
-    def post(self, endpoint, data):
-        """
-        Make a POST request to the mailcow API.
-        :param endpoint: The API endpoint to post to.
-        :param data: Data to be sent in the POST request.
-        :return: Response from the mailcow API.
-        """
-        url = f"{self.baseUrl}{self.apiUrl}{endpoint}"
-        auth = (self.username, self.password)
-        headers = {"Host": self.host}
-
-        response = requests.post(
-            url,
-            json=data,
-            auth=auth,
-            headers=headers,
-            verify=not self.ignore_ssl_errors
-        )
-        return response
-

data/Dockerfiles/controller/mailcow-adm/modules/Utils.py

@@ -1,37 +0,0 @@
-import json
-import random
-import string
-
-
-class Utils:
-    def __init(self):
-        pass
-
-    def normalize_email(self, email):
-        replacements = {
-            "ä": "ae", "ö": "oe", "ü": "ue", "ß": "ss",
-            "Ä": "Ae", "Ö": "Oe", "Ü": "Ue"
-        }
-        for orig, repl in replacements.items():
-            email = email.replace(orig, repl)
-        return email
-
-    def generate_password(self, length=8):
-        chars = string.ascii_letters + string.digits
-        return ''.join(random.choices(chars, k=length))
-
-    def pprint(self, data=""):
-        """
-        Pretty print a dictionary, list, or text.
-        If data is a text containing JSON, it will be printed in a formatted way.
-        """
-        if isinstance(data, (dict, list)):
-            print(json.dumps(data, indent=2, ensure_ascii=False))
-        elif isinstance(data, str):
-            try:
-                json_data = json.loads(data)
-                print(json.dumps(json_data, indent=2, ensure_ascii=False))
-            except json.JSONDecodeError:
-                print(data)
-        else:
-            print(data)

data/Dockerfiles/controller/mailcow-adm/requirements.txt

@@ -1,4 +0,0 @@
-jinja2
-requests
-mysql-connector-python
-pytest

data/Dockerfiles/controller/mailcow-adm/tests/test_AliasModel.py

@@ -1,94 +0,0 @@
-import pytest
-import json
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../")))
-from models.DomainModel import DomainModel
-from models.AliasModel import AliasModel
-
-
-def test_model():
-    # Generate random alias
-    random_alias = f"alias_test{os.urandom(4).hex()}@mailcow.local"
-
-    # Create an instance of AliasModel
-    model = AliasModel(
-        address=random_alias,
-        goto="test@mailcow.local,test2@mailcow.local"
-    )
-
-    # Test the parser_command attribute
-    assert model.parser_command == "alias", "Parser command should be 'alias'"
-
-    # add Domain for testing
-    domain_model = DomainModel(domain="mailcow.local")
-    domain_model.add()
-
-    # 1. Alias add tests, should success
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "success", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 3, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "alias_added", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'alias_added'\n{json.dumps(r_add, indent=2)}"
-
-    # Assign created alias ID for further tests
-    model.id = r_add[0]['msg'][2]
-
-    # 2. Alias add tests, should fail because the alias already exists
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "danger", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "is_alias_or_mailbox", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'is_alias_or_mailbox'\n{json.dumps(r_add, indent=2)}"
-
-    # 3. Alias get tests
-    r_get = model.get()
-    assert isinstance(r_get, dict), f"Expected a dict but received: {json.dumps(r_get, indent=2)}"
-    assert "domain" in r_get, f"'domain' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "goto" in r_get, f"'goto' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "address" in r_get, f"'address' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert r_get['domain'] == model.address.split("@")[1], f"Wrong 'domain' received: {r_get['domain']}, expected: {model.address.split('@')[1]}\n{json.dumps(r_get, indent=2)}"
-    assert r_get['goto'] == model.goto, f"Wrong 'goto' received: {r_get['goto']}, expected: {model.goto}\n{json.dumps(r_get, indent=2)}"
-    assert r_get['address'] == model.address, f"Wrong 'address' received: {r_get['address']}, expected: {model.address}\n{json.dumps(r_get, indent=2)}"
-
-    # 4. Alias edit tests
-    model.goto = "test@mailcow.local"
-    model.active = 0
-    r_edit = model.edit()
-    assert isinstance(r_edit, list), f"Expected a array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit) > 0, f"Wrong array received: {json.dumps(r_edit, indent=2)}"
-    assert "type" in r_edit[0], f"'type' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['type'] == "success", f"Wrong 'type' received: {r_edit[0]['type']}\n{json.dumps(r_edit, indent=2)}"
-    assert "msg" in r_edit[0], f"'msg' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert isinstance(r_edit[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit[0]['msg']) > 0 and len(r_edit[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['msg'][0] == "alias_modified", f"Wrong 'msg' received: {r_edit[0]['msg'][0]}, expected: 'alias_modified'\n{json.dumps(r_edit, indent=2)}"
-
-    # 5. Alias delete tests
-    r_delete = model.delete()
-    assert isinstance(r_delete, list), f"Expected a array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete) > 0, f"Wrong array received: {json.dumps(r_delete, indent=2)}"
-    assert "type" in r_delete[0], f"'type' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['type'] == "success", f"Wrong 'type' received: {r_delete[0]['type']}\n{json.dumps(r_delete, indent=2)}"
-    assert "msg" in r_delete[0], f"'msg' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert isinstance(r_delete[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete[0]['msg']) > 0 and len(r_delete[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['msg'][0] == "alias_removed", f"Wrong 'msg' received: {r_delete[0]['msg'][0]}, expected: 'alias_removed'\n{json.dumps(r_delete, indent=2)}"
-
-    # delete testing Domain
-    domain_model.delete()
-
-
-if __name__ == "__main__":
-  print("Running AliasModel tests...")
-  test_model()
-  print("All tests passed!")

data/Dockerfiles/controller/mailcow-adm/tests/test_BaseModel.py

@@ -1,71 +0,0 @@
-import pytest
-from models.BaseModel import BaseModel
-
-
-class Args:
-    def __init__(self, **kwargs):
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-
-def test_has_required_args():
-    BaseModel.required_args = {
-        "test_object": [["arg1"], ["arg2", "arg3"]],
-    }
-
-    # Test cases with Args object
-    args = Args(object="non_existent_object")
-    assert BaseModel.has_required_args(args) == False
-
-    args = Args(object="test_object")
-    assert BaseModel.has_required_args(args) == False
-
-    args = Args(object="test_object", arg1="value")
-    assert BaseModel.has_required_args(args) == True
-
-    args = Args(object="test_object", arg2="value")
-    assert BaseModel.has_required_args(args) == False
-
-    args = Args(object="test_object", arg3="value")
-    assert BaseModel.has_required_args(args) == False
-
-    args = Args(object="test_object", arg2="value", arg3="value")
-    assert BaseModel.has_required_args(args) == True
-
-    # Test cases with dict object
-    args = {"object": "non_existent_object"}
-    assert BaseModel.has_required_args(args) == False
-
-    args = {"object": "test_object"}
-    assert BaseModel.has_required_args(args) == False
-
-    args = {"object": "test_object", "arg1": "value"}
-    assert BaseModel.has_required_args(args) == True
-
-    args = {"object": "test_object", "arg2": "value"}
-    assert BaseModel.has_required_args(args) == False
-
-    args = {"object": "test_object", "arg3": "value"}
-    assert BaseModel.has_required_args(args) == False
-
-    args = {"object": "test_object", "arg2": "value", "arg3": "value"}
-    assert BaseModel.has_required_args(args) == True
-
-
-    BaseModel.required_args = {
-        "test_object": [[]],
-    }
-
-    # Test cases with Args object
-    args = Args(object="non_existent_object")
-    assert BaseModel.has_required_args(args) == False
-
-    args = Args(object="test_object")
-    assert BaseModel.has_required_args(args) == True
-
-    # Test cases with dict object
-    args = {"object": "non_existent_object"}
-    assert BaseModel.has_required_args(args) == False
-
-    args = {"object": "test_object"}
-    assert BaseModel.has_required_args(args) == True

data/Dockerfiles/controller/mailcow-adm/tests/test_DomainModel.py

@@ -1,74 +0,0 @@
-import pytest
-import json
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../")))
-from models.DomainModel import DomainModel
-
-
-def test_model():
-    # Create an instance of DomainModel
-    model = DomainModel(
-        domain="mailcow.local",
-    )
-
-    # Test the parser_command attribute
-    assert model.parser_command == "domain", "Parser command should be 'domain'"
-
-    # 1. Domain add tests, should success
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0 and len(r_add) >= 2, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[1], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[1]['type'] == "success", f"Wrong 'type' received: {r_add[1]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[1], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[1]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[1]['msg']) > 0 and len(r_add[1]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[1]['msg'][0] == "domain_added", f"Wrong 'msg' received: {r_add[1]['msg'][0]}, expected: 'domain_added'\n{json.dumps(r_add, indent=2)}"
-
-    # 2. Domain add tests, should fail because the domain already exists
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "danger", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "domain_exists", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'domain_exists'\n{json.dumps(r_add, indent=2)}"
-
-    # 3. Domain get tests
-    r_get = model.get()
-    assert isinstance(r_get, dict), f"Expected a dict but received: {json.dumps(r_get, indent=2)}"
-    assert "domain_name" in r_get, f"'domain_name' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert r_get['domain_name'] == model.domain, f"Wrong 'domain_name' received: {r_get['domain_name']}, expected: {model.domain}\n{json.dumps(r_get, indent=2)}"
-
-    # 4. Domain edit tests
-    model.active = 0
-    r_edit = model.edit()
-    assert isinstance(r_edit, list), f"Expected a array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit) > 0, f"Wrong array received: {json.dumps(r_edit, indent=2)}"
-    assert "type" in r_edit[0], f"'type' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['type'] == "success", f"Wrong 'type' received: {r_edit[0]['type']}\n{json.dumps(r_edit, indent=2)}"
-    assert "msg" in r_edit[0], f"'msg' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert isinstance(r_edit[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit[0]['msg']) > 0 and len(r_edit[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['msg'][0] == "domain_modified", f"Wrong 'msg' received: {r_edit[0]['msg'][0]}, expected: 'domain_modified'\n{json.dumps(r_edit, indent=2)}"
-
-    # 5. Domain delete tests
-    r_delete = model.delete()
-    assert isinstance(r_delete, list), f"Expected a array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete) > 0, f"Wrong array received: {json.dumps(r_delete, indent=2)}"
-    assert "type" in r_delete[0], f"'type' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['type'] == "success", f"Wrong 'type' received: {r_delete[0]['type']}\n{json.dumps(r_delete, indent=2)}"
-    assert "msg" in r_delete[0], f"'msg' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert isinstance(r_delete[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete[0]['msg']) > 0 and len(r_delete[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['msg'][0] == "domain_removed", f"Wrong 'msg' received: {r_delete[0]['msg'][0]}, expected: 'domain_removed'\n{json.dumps(r_delete, indent=2)}"
-
-
-if __name__ == "__main__":
-  print("Running DomainModel tests...")
-  test_model()
-  print("All tests passed!")

data/Dockerfiles/controller/mailcow-adm/tests/test_DomainadminModel.py

@@ -1,89 +0,0 @@
-import pytest
-import json
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../")))
-from models.DomainModel import DomainModel
-from models.DomainadminModel import DomainadminModel
-
-
-def test_model():
-    # Generate random domainadmin
-    random_username = f"dadmin_test{os.urandom(4).hex()}"
-    random_password = f"{os.urandom(4).hex()}"
-
-    # Create an instance of DomainadminModel
-    model = DomainadminModel(
-        username=random_username,
-        password=random_password,
-        domains="mailcow.local",
-    )
-
-    # Test the parser_command attribute
-    assert model.parser_command == "domainadmin", "Parser command should be 'domainadmin'"
-
-    # add Domain for testing
-    domain_model = DomainModel(domain="mailcow.local")
-    domain_model.add()
-
-    # 1. Domainadmin add tests, should success
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "success", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 3, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "domain_admin_added", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'domain_admin_added'\n{json.dumps(r_add, indent=2)}"
-
-    # 2. Domainadmin add tests, should fail because the domainadmin already exists
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "danger", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "object_exists", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'object_exists'\n{json.dumps(r_add, indent=2)}"
-
-    # 3. Domainadmin get tests
-    r_get = model.get()
-    assert isinstance(r_get, dict), f"Expected a dict but received: {json.dumps(r_get, indent=2)}"
-    assert "selected_domains" in r_get, f"'selected_domains' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "username" in r_get, f"'username' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert set(model.domains.replace(" ", "").split(",")) == set(r_get['selected_domains']), f"Wrong 'selected_domains' received: {r_get['selected_domains']}, expected: {model.domains}\n{json.dumps(r_get, indent=2)}"
-    assert r_get['username'] == model.username, f"Wrong 'username' received: {r_get['username']}, expected: {model.username}\n{json.dumps(r_get, indent=2)}"
-
-    # 4. Domainadmin edit tests
-    model.active = 0
-    r_edit = model.edit()
-    assert isinstance(r_edit, list), f"Expected a array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit) > 0, f"Wrong array received: {json.dumps(r_edit, indent=2)}"
-    assert "type" in r_edit[0], f"'type' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['type'] == "success", f"Wrong 'type' received: {r_edit[0]['type']}\n{json.dumps(r_edit, indent=2)}"
-    assert "msg" in r_edit[0], f"'msg' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert isinstance(r_edit[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit[0]['msg']) > 0 and len(r_edit[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['msg'][0] == "domain_admin_modified", f"Wrong 'msg' received: {r_edit[0]['msg'][0]}, expected: 'domain_admin_modified'\n{json.dumps(r_edit, indent=2)}"
-
-    # 5. Domainadmin delete tests
-    r_delete = model.delete()
-    assert isinstance(r_delete, list), f"Expected a array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete) > 0, f"Wrong array received: {json.dumps(r_delete, indent=2)}"
-    assert "type" in r_delete[0], f"'type' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['type'] == "success", f"Wrong 'type' received: {r_delete[0]['type']}\n{json.dumps(r_delete, indent=2)}"
-    assert "msg" in r_delete[0], f"'msg' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert isinstance(r_delete[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete[0]['msg']) > 0 and len(r_delete[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['msg'][0] == "domain_admin_removed", f"Wrong 'msg' received: {r_delete[0]['msg'][0]}, expected: 'domain_admin_removed'\n{json.dumps(r_delete, indent=2)}"
-
-    # delete testing Domain
-    domain_model.delete()
-
-if __name__ == "__main__":
-  print("Running DomainadminModel tests...")
-  test_model()
-  print("All tests passed!")

data/Dockerfiles/controller/mailcow-adm/tests/test_MailboxModel.py

@@ -1,89 +0,0 @@
-import pytest
-import json
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../")))
-from models.DomainModel import DomainModel
-from models.MailboxModel import MailboxModel
-
-
-def test_model():
-    # Generate random mailbox
-    random_username = f"mbox_test{os.urandom(4).hex()}@mailcow.local"
-    random_password = f"{os.urandom(4).hex()}"
-
-    # Create an instance of MailboxModel
-    model = MailboxModel(
-        username=random_username,
-        password=random_password
-    )
-
-    # Test the parser_command attribute
-    assert model.parser_command == "mailbox", "Parser command should be 'mailbox'"
-
-    # add Domain for testing
-    domain_model = DomainModel(domain="mailcow.local")
-    domain_model.add()
-
-    # 1. Mailbox add tests, should success
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0 and len(r_add) <= 2, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[1], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[1]['type'] == "success", f"Wrong 'type' received: {r_add[1]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[1], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[1]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[1]['msg']) > 0 and len(r_add[1]['msg']) <= 3, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[1]['msg'][0] == "mailbox_added", f"Wrong 'msg' received: {r_add[1]['msg'][0]}, expected: 'mailbox_added'\n{json.dumps(r_add, indent=2)}"
-
-    # 2. Mailbox add tests, should fail because the mailbox already exists
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "danger", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "object_exists", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'object_exists'\n{json.dumps(r_add, indent=2)}"
-
-    # 3. Mailbox get tests
-    r_get = model.get()
-    assert isinstance(r_get, dict), f"Expected a dict but received: {json.dumps(r_get, indent=2)}"
-    assert "domain" in r_get, f"'domain' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "local_part" in r_get, f"'local_part' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert r_get['domain'] == model.domain, f"Wrong 'domain' received: {r_get['domain']}, expected: {model.domain}\n{json.dumps(r_get, indent=2)}"
-    assert r_get['local_part'] == model.local_part, f"Wrong 'local_part' received: {r_get['local_part']}, expected: {model.local_part}\n{json.dumps(r_get, indent=2)}"
-
-    # 4. Mailbox edit tests
-    model.active = 0
-    r_edit = model.edit()
-    assert isinstance(r_edit, list), f"Expected a array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit) > 0, f"Wrong array received: {json.dumps(r_edit, indent=2)}"
-    assert "type" in r_edit[0], f"'type' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['type'] == "success", f"Wrong 'type' received: {r_edit[0]['type']}\n{json.dumps(r_edit, indent=2)}"
-    assert "msg" in r_edit[0], f"'msg' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert isinstance(r_edit[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit[0]['msg']) > 0 and len(r_edit[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['msg'][0] == "mailbox_modified", f"Wrong 'msg' received: {r_edit[0]['msg'][0]}, expected: 'mailbox_modified'\n{json.dumps(r_edit, indent=2)}"
-
-    # 5. Mailbox delete tests
-    r_delete = model.delete()
-    assert isinstance(r_delete, list), f"Expected a array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete) > 0, f"Wrong array received: {json.dumps(r_delete, indent=2)}"
-    assert "type" in r_delete[0], f"'type' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['type'] == "success", f"Wrong 'type' received: {r_delete[0]['type']}\n{json.dumps(r_delete, indent=2)}"
-    assert "msg" in r_delete[0], f"'msg' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert isinstance(r_delete[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete[0]['msg']) > 0 and len(r_delete[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['msg'][0] == "mailbox_removed", f"Wrong 'msg' received: {r_delete[0]['msg'][0]}, expected: 'mailbox_removed'\n{json.dumps(r_delete, indent=2)}"
-
-    # delete testing Domain
-    domain_model.delete()
-
-
-if __name__ == "__main__":
-  print("Running MailboxModel tests...")
-  test_model()
-  print("All tests passed!")

data/Dockerfiles/controller/mailcow-adm/tests/test_StatusModel.py

@@ -1,39 +0,0 @@
-import pytest
-import json
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../")))
-from models.StatusModel import StatusModel
-
-
-def test_model():
-    # Create an instance of StatusModel
-    model = StatusModel()
-
-    # Test the parser_command attribute
-    assert model.parser_command == "status", "Parser command should be 'status'"
-
-    # 1. Status version tests
-    r_version = model.version()
-    assert isinstance(r_version, dict), f"Expected a dict but received: {json.dumps(r_version, indent=2)}"
-    assert "version" in r_version, f"'version' key missing in response: {json.dumps(r_version, indent=2)}"
-
-    # 2. Status vmail tests
-    r_vmail = model.vmail()
-    assert isinstance(r_vmail, dict), f"Expected a dict but received: {json.dumps(r_vmail, indent=2)}"
-    assert "type" in r_vmail, f"'type' key missing in response: {json.dumps(r_vmail, indent=2)}"
-    assert "disk" in r_vmail, f"'disk' key missing in response: {json.dumps(r_vmail, indent=2)}"
-    assert "used" in r_vmail, f"'used' key missing in response: {json.dumps(r_vmail, indent=2)}"
-    assert "total" in r_vmail, f"'total' key missing in response: {json.dumps(r_vmail, indent=2)}"
-    assert "used_percent" in r_vmail, f"'used_percent' key missing in response: {json.dumps(r_vmail, indent=2)}"
-
-    # 3. Status containers tests
-    r_containers = model.containers()
-    assert isinstance(r_containers, dict), f"Expected a dict but received: {json.dumps(r_containers, indent=2)}"
-
-
-if __name__ == "__main__":
-  print("Running StatusModel tests...")
-  test_model()
-  print("All tests passed!")

data/Dockerfiles/controller/mailcow-adm/tests/test_SyncjobModel.py

@@ -1,106 +0,0 @@
-import pytest
-import json
-import sys
-import os
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../")))
-from models.DomainModel import DomainModel
-from models.MailboxModel import MailboxModel
-from models.SyncjobModel import SyncjobModel
-
-
-def test_model():
-    # Generate random Mailbox
-    random_username = f"mbox_test@mailcow.local"
-    random_password = f"{os.urandom(4).hex()}"
-
-    # Create an instance of SyncjobModel
-    model = SyncjobModel(
-        username=random_username,
-        host1="mailcow.local",
-        port1=993,
-        user1="testuser@mailcow.local",
-        password1="testpassword",
-        enc1="SSL",
-    )
-
-    # Test the parser_command attribute
-    assert model.parser_command == "syncjob", "Parser command should be 'syncjob'"
-
-    # add Domain and Mailbox for testing
-    domain_model = DomainModel(domain="mailcow.local")
-    domain_model.add()
-    mbox_model = MailboxModel(username=random_username, password=random_password)
-    mbox_model.add()
-
-    # 1. Syncjob add tests, should success
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0 and len(r_add) <= 2, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "success", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 3, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "mailbox_modified", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'mailbox_modified'\n{json.dumps(r_add, indent=2)}"
-
-    # Assign created syncjob ID for further tests
-    model.id = r_add[0]['msg'][2]
-
-    # 2. Syncjob add tests, should fail because the syncjob already exists
-    r_add = model.add()
-    assert isinstance(r_add, list), f"Expected a array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add) > 0, f"Wrong array received: {json.dumps(r_add, indent=2)}"
-    assert "type" in r_add[0], f"'type' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['type'] == "danger", f"Wrong 'type' received: {r_add[0]['type']}\n{json.dumps(r_add, indent=2)}"
-    assert "msg" in r_add[0], f"'msg' key missing in response: {json.dumps(r_add, indent=2)}"
-    assert isinstance(r_add[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_add, indent=2)}"
-    assert len(r_add[0]['msg']) > 0 and len(r_add[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_add, indent=2)}"
-    assert r_add[0]['msg'][0] == "object_exists", f"Wrong 'msg' received: {r_add[0]['msg'][0]}, expected: 'object_exists'\n{json.dumps(r_add, indent=2)}"
-
-    # 3. Syncjob get tests
-    r_get = model.get()
-    assert isinstance(r_get, list), f"Expected a list but received: {json.dumps(r_get, indent=2)}"
-    assert "user2" in r_get[0], f"'user2' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "host1" in r_get[0], f"'host1' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "port1" in r_get[0], f"'port1' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "user1" in r_get[0], f"'user1' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert "enc1" in r_get[0], f"'enc1' key missing in response: {json.dumps(r_get, indent=2)}"
-    assert r_get[0]['user2'] == model.username, f"Wrong 'user2' received: {r_get[0]['user2']}, expected: {model.username}\n{json.dumps(r_get, indent=2)}"
-    assert r_get[0]['host1'] == model.host1, f"Wrong 'host1' received: {r_get[0]['host1']}, expected: {model.host1}\n{json.dumps(r_get, indent=2)}"
-    assert r_get[0]['port1'] == model.port1, f"Wrong 'port1' received: {r_get[0]['port1']}, expected: {model.port1}\n{json.dumps(r_get, indent=2)}"
-    assert r_get[0]['user1'] == model.user1, f"Wrong 'user1' received: {r_get[0]['user1']}, expected: {model.user1}\n{json.dumps(r_get, indent=2)}"
-    assert r_get[0]['enc1'] == model.enc1, f"Wrong 'enc1' received: {r_get[0]['enc1']}, expected: {model.enc1}\n{json.dumps(r_get, indent=2)}"
-
-    # 4. Syncjob edit tests
-    model.active = 1
-    r_edit = model.edit()
-    assert isinstance(r_edit, list), f"Expected a array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit) > 0, f"Wrong array received: {json.dumps(r_edit, indent=2)}"
-    assert "type" in r_edit[0], f"'type' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['type'] == "success", f"Wrong 'type' received: {r_edit[0]['type']}\n{json.dumps(r_edit, indent=2)}"
-    assert "msg" in r_edit[0], f"'msg' key missing in response: {json.dumps(r_edit, indent=2)}"
-    assert isinstance(r_edit[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_edit, indent=2)}"
-    assert len(r_edit[0]['msg']) > 0 and len(r_edit[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_edit, indent=2)}"
-    assert r_edit[0]['msg'][0] == "mailbox_modified", f"Wrong 'msg' received: {r_edit[0]['msg'][0]}, expected: 'mailbox_modified'\n{json.dumps(r_edit, indent=2)}"
-
-    # 5. Syncjob delete tests
-    r_delete = model.delete()
-    assert isinstance(r_delete, list), f"Expected a array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete) > 0, f"Wrong array received: {json.dumps(r_delete, indent=2)}"
-    assert "type" in r_delete[0], f"'type' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['type'] == "success", f"Wrong 'type' received: {r_delete[0]['type']}\n{json.dumps(r_delete, indent=2)}"
-    assert "msg" in r_delete[0], f"'msg' key missing in response: {json.dumps(r_delete, indent=2)}"
-    assert isinstance(r_delete[0]['msg'], list), f"Expected a 'msg' array but received: {json.dumps(r_delete, indent=2)}"
-    assert len(r_delete[0]['msg']) > 0 and len(r_delete[0]['msg']) <= 2, f"Wrong 'msg' array received: {json.dumps(r_delete, indent=2)}"
-    assert r_delete[0]['msg'][0] == "deleted_syncjob", f"Wrong 'msg' received: {r_delete[0]['msg'][0]}, expected: 'deleted_syncjob'\n{json.dumps(r_delete, indent=2)}"
-
-    # delete testing Domain and Mailbox
-    mbox_model.delete()
-    domain_model.delete()
-
-
-if __name__ == "__main__":
-  print("Running SyncjobModel tests...")
-  test_model()
-  print("All tests passed!")

data/Dockerfiles/controller/stop-supervisor.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-printf "READY\n";
-
-while read line; do
-  echo "Processing Event: $line" >&2;
-  kill -3 $(cat "/var/run/supervisord.pid")
-done < /dev/stdin

data/Dockerfiles/controller/supervisord.conf

@@ -1,17 +0,0 @@
-[supervisord]
-nodaemon=true
-user=root
-pidfile=/var/run/supervisord.pid
-
-[program:api]
-command=python /app/api/main.py
-autostart=true
-autorestart=true
-stdout_logfile=/dev/stdout
-stderr_logfile=/dev/stderr
-stdout_logfile_maxbytes=0
-stderr_logfile_maxbytes=0
-
-[eventlistener:processes]
-command=/usr/local/sbin/stop-supervisor.sh
-events=PROCESS_STATE_STOPPED, PROCESS_STATE_EXITED, PROCESS_STATE_FATAL

data/Dockerfiles/dockerapi/Dockerfile

@@ -6,29 +6,22 @@ ARG PIP_BREAK_SYSTEM_PACKAGES=1
 WORKDIR /app
 
 RUN apk add --update --no-cache python3 \
-  bash \
   py3-pip \
   openssl \
   tzdata \
   py3-psutil \
   py3-redis \
   py3-async-timeout \
-  supervisor \
-  curl \
 && pip3 install --upgrade pip \
   fastapi \
   uvicorn \
   aiodocker \
   docker
-
-COPY mailcow-adm/ /app/mailcow-adm/
-RUN pip3 install -r /app/mailcow-adm/requirements.txt
-
-COPY api/ /app/api/
+RUN mkdir /app/modules
 
 COPY docker-entrypoint.sh /app/
-COPY supervisord.conf /etc/supervisor/supervisord.conf
-COPY stop-supervisor.sh /usr/local/sbin/stop-supervisor.sh
+COPY main.py /app/main.py
+COPY modules/ /app/modules/
 
 ENTRYPOINT ["/bin/sh", "/app/docker-entrypoint.sh"]
-CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/supervisord.conf"]
+CMD ["python", "main.py"]

data/Dockerfiles/dockerapi/docker-entrypoint.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+`openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes \
+  -keyout /app/dockerapi_key.pem \
+  -out /app/dockerapi_cert.pem \
+  -subj /CN=dockerapi/O=mailcow \
+  -addext subjectAltName=DNS:dockerapi`
+
+exec "$@"

data/Dockerfiles/dockerapi/main.py

@@ -32,21 +32,21 @@ async def lifespan(app: FastAPI):
 
   logger.info("Init APP")
 
-  # Init redis client
-  if os.environ['REDIS_SLAVEOF_IP'] != "":
-    redis_client = redis = await aioredis.from_url(f"redis://{os.environ['REDIS_SLAVEOF_IP']}:{os.environ['REDIS_SLAVEOF_PORT']}/0", password=os.environ['REDISPASS'])
+  # Init valkey client
+  if os.environ['VALKEY_SLAVEOF_IP'] != "":
+    valkey_client = valkey = await aioredis.from_url(f"redis://{os.environ['VALKEY_SLAVEOF_IP']}:{os.environ['VALKEY_SLAVEOF_PORT']}/0", password=os.environ['VALKEYPASS'])
   else:
-    redis_client = redis = await aioredis.from_url("redis://redis-mailcow:6379/0", password=os.environ['REDISPASS'])
+    valkey_client = valkey = await aioredis.from_url("redis://valkey-mailcow:6379/0", password=os.environ['VALKEYPASS'])
 
   # Init docker clients
   sync_docker_client = docker.DockerClient(base_url='unix://var/run/docker.sock', version='auto')
   async_docker_client = aiodocker.Docker(url='unix:///var/run/docker.sock')
 
-  dockerapi = DockerApi(redis_client, sync_docker_client, async_docker_client, logger)
+  dockerapi = DockerApi(valkey_client, sync_docker_client, async_docker_client, logger)
 
-  logger.info("Subscribe to redis channel")
-  # Subscribe to redis channel
-  dockerapi.pubsub = redis.pubsub()
+  logger.info("Subscribe to valkey channel")
+  # Subscribe to valkey channel
+  dockerapi.pubsub = valkey.pubsub()
   await dockerapi.pubsub.subscribe("MC_CHANNEL")
   asyncio.create_task(handle_pubsub_messages(dockerapi.pubsub))
 
@@ -57,9 +57,9 @@ async def lifespan(app: FastAPI):
   dockerapi.sync_docker_client.close()
   await dockerapi.async_docker_client.close()
 
-  # Close redis
+  # Close valkey
   await dockerapi.pubsub.unsubscribe("MC_CHANNEL")
-  await dockerapi.redis_client.close()
+  await dockerapi.valkey_client.close()
 
 app = FastAPI(lifespan=lifespan)
 
@@ -73,11 +73,11 @@ async def get_host_update_stats():
     dockerapi.host_stats_isUpdating = True
 
   while True:
-    if await dockerapi.redis_client.exists('host_stats'):
+    if await dockerapi.valkey_client.exists('host_stats'):
       break
     await asyncio.sleep(1.5)
 
-  stats = json.loads(await dockerapi.redis_client.get('host_stats'))
+  stats = json.loads(await dockerapi.valkey_client.get('host_stats'))
   return Response(content=json.dumps(stats, indent=4), media_type="application/json")
 
 @app.get("/containers/{container_id}/json")
@@ -185,11 +185,11 @@ async def post_container_update_stats(container_id : str):
     dockerapi.containerIds_to_update.append(container_id)
 
   while True:
-    if await dockerapi.redis_client.exists(container_id + '_stats'):
+    if await dockerapi.valkey_client.exists(container_id + '_stats'):
       break
     await asyncio.sleep(1.5)
 
-  stats = json.loads(await dockerapi.redis_client.get(container_id + '_stats'))
+  stats = json.loads(await dockerapi.valkey_client.get(container_id + '_stats'))
   return Response(content=json.dumps(stats, indent=4), media_type="application/json")
 
 
@@ -254,8 +254,8 @@ if __name__ == '__main__':
     app,
     host="0.0.0.0",
     port=443,
-    ssl_certfile="/app/controller_cert.pem",
-    ssl_keyfile="/app/controller_key.pem",
+    ssl_certfile="/app/dockerapi_cert.pem",
+    ssl_keyfile="/app/dockerapi_key.pem",
     log_level="info",
     loop="none"
   )

data/Dockerfiles/dockerapi/modules/DockerApi.py

@@ -10,8 +10,8 @@ from datetime import datetime
 from fastapi import FastAPI, Response, Request
 
 class DockerApi:
-  def __init__(self, redis_client, sync_docker_client, async_docker_client, logger):
-    self.redis_client = redis_client
+  def __init__(self, valkey_client, sync_docker_client, async_docker_client, logger):
+    self.valkey_client = valkey_client
     self.sync_docker_client = sync_docker_client
     self.async_docker_client = async_docker_client
     self.logger = logger
@@ -533,7 +533,7 @@ class DockerApi:
         "architecture": platform.machine()
       }
 
-      await self.redis_client.set('host_stats', json.dumps(host_stats), ex=10)
+      await self.valkey_client.set('host_stats', json.dumps(host_stats), ex=10)
     except Exception as e:
       res = {
         "type": "danger",
@@ -550,14 +550,14 @@ class DockerApi:
           if container._id == container_id:
             res = await container.stats(stream=False)
 
-            if await self.redis_client.exists(container_id + '_stats'):
-              stats = json.loads(await self.redis_client.get(container_id + '_stats'))
+            if await self.valkey_client.exists(container_id + '_stats'):
+              stats = json.loads(await self.valkey_client.get(container_id + '_stats'))
             else:
               stats = []
             stats.append(res[0])
             if len(stats) > 3:
               del stats[0]
-            await self.redis_client.set(container_id + '_stats', json.dumps(stats), ex=60)
+            await self.valkey_client.set(container_id + '_stats', json.dumps(stats), ex=60)
       except Exception as e:
         res = {
           "type": "danger",

data/Dockerfiles/dovecot/Dockerfile

@@ -3,7 +3,7 @@ FROM alpine:3.21
 LABEL maintainer="The Infrastructure Company GmbH <info@servercow.de>"
 
 # renovate: datasource=github-releases depName=tianon/gosu versioning=semver-coerced extractVersion=^(?<version>.*)$
-ARG GOSU_VERSION=1.19
+ARG GOSU_VERSION=1.17
 
 ENV LANG=C.UTF-8
 ENV LC_ALL=C.UTF-8
@@ -118,7 +118,7 @@ RUN addgroup -g 5000 vmail \
 COPY trim_logs.sh /usr/local/bin/trim_logs.sh
 COPY clean_q_aged.sh /usr/local/bin/clean_q_aged.sh
 COPY syslog-ng.conf /etc/syslog-ng/syslog-ng.conf
-COPY syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng-redis_slave.conf
+COPY syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng-valkey_slave.conf
 COPY imapsync /usr/local/bin/imapsync
 COPY imapsync_runner.pl /usr/local/bin/imapsync_runner.pl
 COPY report-spam.sieve /usr/lib/dovecot/sieve/report-spam.sieve

data/Dockerfiles/dovecot/clean_q_aged.sh

@@ -2,7 +2,7 @@
 
 source /source_env.sh
 
-MAX_AGE=$(redis-cli --raw -h redis-mailcow -a ${REDISPASS} --no-auth-warning GET Q_MAX_AGE)
+MAX_AGE=$(redis-cli --raw -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning GET Q_MAX_AGE)
 
 if [[ -z ${MAX_AGE} ]]; then
   echo "Max age for quarantine items not defined"

data/Dockerfiles/dovecot/docker-entrypoint.sh

@@ -13,18 +13,18 @@ until dig +short mailcow.email > /dev/null; do
 done
 
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  REDIS_CMDLINE="redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning"
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  VALKEY_CMDLINE="redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning"
 else
-  REDIS_CMDLINE="redis-cli -h redis -p 6379 -a ${REDISPASS} --no-auth-warning"
+  VALKEY_CMDLINE="redis-cli -h valkey-mailcow -p 6379 -a ${VALKEYPASS} --no-auth-warning"
 fi
 
-until [[ $(${REDIS_CMDLINE} PING) == "PONG" ]]; do
-  echo "Waiting for Redis..."
+until [[ $(${VALKEY_CMDLINE} PING) == "PONG" ]]; do
+  echo "Waiting for Valkey..."
   sleep 2
 done
 
-${REDIS_CMDLINE} SET DOVECOT_REPL_HEALTH 1 > /dev/null
+${VALKEY_CMDLINE} SET DOVECOT_REPL_HEALTH 1 > /dev/null
 
 # Create missing directories
 [[ ! -d /etc/dovecot/sql/ ]] && mkdir -p /etc/dovecot/sql/
@@ -204,17 +204,16 @@ EOF
 # Create random master Password for SOGo SSO
 RAND_PASS=$(cat /dev/urandom | tr -dc 'a-z0-9' | fold -w 32 | head -n 1)
 echo -n ${RAND_PASS} > /etc/phpfpm/sogo-sso.pass
+# Creating additional creds file for SOGo notify crons (calendars, etc)
+echo -n ${RAND_USER}@mailcow.local:${RAND_PASS} > /etc/sogo/cron.creds
 cat <<EOF > /etc/dovecot/sogo-sso.conf
 # Autogenerated by mailcow
 passdb {
   driver = static
-  args = allow_nets=${IPV4_NETWORK}.248/32 password={plain}${RAND_PASS}
+  args = allow_real_nets=${IPV4_NETWORK}.248/32 password={plain}${RAND_PASS}
 }
 EOF
 
-# Creating additional creds file for SOGo notify crons (calendars, etc) (dummy user, sso password)
-echo -n ${RAND_USER}@mailcow.local:${RAND_PASS} > /etc/sogo/cron.creds
-
 if [[ "${MASTER}" =~ ^([nN][oO]|[nN])+$ ]]; then
   # Toggling MASTER will result in a rebuild of containers, so the quota script will be recreated
   cat <<'EOF' > /usr/local/bin/quota_notify.py
@@ -342,8 +341,8 @@ done
 # May be related to something inside Docker, I seriously don't know
 touch /etc/dovecot/auth/passwd-verify.lua
 
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  cp /etc/syslog-ng/syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng.conf
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  cp /etc/syslog-ng/syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng.conf
 fi
 
 exec "$@"

data/Dockerfiles/dovecot/quarantine_notify.py

@@ -32,7 +32,7 @@ try:
 
   while True:
     try:
-      r = redis.StrictRedis(host='redis', decode_responses=True, port=6379, db=0, password=os.environ['REDISPASS'])
+      r = redis.StrictRedis(host='valkey-mailcow', decode_responses=True, port=6379, db=0, password=os.environ['VALKEYPASS'])
       r.ping()
     except Exception as ex:
       print('%s - trying again...'  % (ex))

data/Dockerfiles/dovecot/quota_notify.py

@@ -23,7 +23,7 @@ else:
 
 while True:
   try:
-    r = redis.StrictRedis(host='redis', decode_responses=True, port=6379, db=0, username='quota_notify', password='')
+    r = redis.StrictRedis(host='valkey-mailcow', decode_responses=True, port=6379, db=0, username='quota_notify', password='')
     r.ping()
   except Exception as ex:
     print('%s - trying again...'  % (ex))

data/Dockerfiles/dovecot/repl_health.sh

@@ -3,16 +3,16 @@
 source /source_env.sh
 
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  REDIS_CMDLINE="redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning"
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  VALKEY_CMDLINE="redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning"
 else
-  REDIS_CMDLINE="redis-cli -h redis -p 6379 -a ${REDISPASS} --no-auth-warning"
+  VALKEY_CMDLINE="redis-cli -h valkey-mailcow -p 6379 -a ${VALKEYPASS} --no-auth-warning"
 fi
 
 # Is replication active?
 # grep on file is less expensive than doveconf
 if [ -n ${MAILCOW_REPLICA_IP} ]; then
-  ${REDIS_CMDLINE} SET DOVECOT_REPL_HEALTH 1 > /dev/null
+  ${VALKEY_CMDLINE} SET DOVECOT_REPL_HEALTH 1 > /dev/null
   exit
 fi
 
@@ -22,7 +22,7 @@ FAILED_SYNCS=$(doveadm replicator status | grep "Waiting 'failed' requests" | gr
 # 1 failed job for mailcow.local is expected and healthy
 if [[ "${FAILED_SYNCS}" != 0 ]] && [[ "${FAILED_SYNCS}" != 1 ]]; then
   printf "Dovecot replicator has %d failed jobs\n" "${FAILED_SYNCS}"
-  ${REDIS_CMDLINE} SET DOVECOT_REPL_HEALTH "${FAILED_SYNCS}" > /dev/null
+  ${VALKEY_CMDLINE} SET DOVECOT_REPL_HEALTH "${FAILED_SYNCS}" > /dev/null
 else
-  ${REDIS_CMDLINE} SET DOVECOT_REPL_HEALTH 1 > /dev/null
+  ${VALKEY_CMDLINE} SET DOVECOT_REPL_HEALTH 1 > /dev/null
 fi

data/Dockerfiles/dovecot/sa-rules.sh

@@ -25,11 +25,11 @@ sed -i -e 's/\([^\\]\)\$\([^\/]\)/\1\\$\2/g' /etc/rspamd/custom/sa-rules
 
 if [[ "$(cat /etc/rspamd/custom/sa-rules | md5sum | cut -d' ' -f1)" != "${HASH_SA_RULES}" ]]; then
   CONTAINER_NAME=rspamd-mailcow
-  CONTAINER_ID=$(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | \
+  CONTAINER_ID=$(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | \
     jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | \
     jq -rc "select( .name | tostring | contains(\"${CONTAINER_NAME}\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id")
   if [[ ! -z ${CONTAINER_ID} ]]; then
-    curl --silent --insecure -XPOST --connect-timeout 15 --max-time 120 https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/restart
+    curl --silent --insecure -XPOST --connect-timeout 15 --max-time 120 https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/restart
   fi
 fi
 

data/Dockerfiles/dovecot/syslog-ng-valkey_slave.conf

@@ -15,21 +15,21 @@ source s_dgram {
   internal();
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis1")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey1")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("LPUSH" "DOVECOT_MAILLOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
-destination d_redis_f2b_channel {
+destination d_valkey_f2b_channel {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis2")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey2")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("PUBLISH" "F2B_CHANNEL" "$(sanitize $MESSAGE)")
   );
 };
@@ -48,6 +48,6 @@ log {
   filter(f_replica);
   destination(d_stdout);
   filter(f_mail);
-  destination(d_redis_ui_log);
-  destination(d_redis_f2b_channel);
+  destination(d_valkey_ui_log);
+  destination(d_valkey_f2b_channel);
 };

data/Dockerfiles/dovecot/syslog-ng.conf

@@ -15,21 +15,21 @@ source s_dgram {
   internal();
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("redis-mailcow")
-    persist-name("redis1")
+    host("valkey-mailcow")
+    persist-name("valkey1")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("LPUSH" "DOVECOT_MAILLOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
-destination d_redis_f2b_channel {
+destination d_valkey_f2b_channel {
   redis(
-    host("redis-mailcow")
-    persist-name("redis2")
+    host("valkey-mailcow")
+    persist-name("valkey2")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("PUBLISH" "F2B_CHANNEL" "$(sanitize $MESSAGE)")
   );
 };
@@ -48,6 +48,6 @@ log {
   filter(f_replica);
   destination(d_stdout);
   filter(f_mail);
-  destination(d_redis_ui_log);
-  destination(d_redis_f2b_channel);
+  destination(d_valkey_ui_log);
+  destination(d_valkey_f2b_channel);
 };

data/Dockerfiles/dovecot/trim_logs.sh

@@ -9,18 +9,17 @@ catch_non_zero() {
 }
 source /source_env.sh
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  REDIS_CMDLINE="redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning"
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  VALKEY_CMDLINE="redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning"
 else
-  REDIS_CMDLINE="redis-cli -h redis -p 6379 -a ${REDISPASS} --no-auth-warning"
+  VALKEY_CMDLINE="redis-cli -h valkey-mailcow -p 6379 -a ${VALKEYPASS} --no-auth-warning"
 fi
-catch_non_zero "${REDIS_CMDLINE} LTRIM ACME_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM POSTFIX_MAILLOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM DOVECOT_MAILLOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM SOGO_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM NETFILTER_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM AUTODISCOVER_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM API_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM RL_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM WATCHDOG_LOG 0 ${LOG_LINES}"
-catch_non_zero "${REDIS_CMDLINE} LTRIM CRON_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM ACME_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM POSTFIX_MAILLOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM DOVECOT_MAILLOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM SOGO_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM NETFILTER_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM AUTODISCOVER_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM API_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM RL_LOG 0 ${LOG_LINES}"
+catch_non_zero "${VALKEY_CMDLINE} LTRIM WATCHDOG_LOG 0 ${LOG_LINES}"

data/Dockerfiles/netfilter/main.py

@@ -44,25 +44,24 @@ def refreshF2boptions():
   global exit_code
   f2boptions = {}
 
-  if not r.get('F2B_OPTIONS'):
-    f2boptions['ban_time'] = r.get('F2B_BAN_TIME')
-    f2boptions['max_ban_time'] = r.get('F2B_MAX_BAN_TIME')
-    f2boptions['ban_time_increment'] = r.get('F2B_BAN_TIME_INCREMENT')
-    f2boptions['max_attempts'] = r.get('F2B_MAX_ATTEMPTS')
-    f2boptions['retry_window'] = r.get('F2B_RETRY_WINDOW')
-    f2boptions['netban_ipv4'] = r.get('F2B_NETBAN_IPV4')
-    f2boptions['netban_ipv6'] = r.get('F2B_NETBAN_IPV6')
+  if not valkey.get('F2B_OPTIONS'):
+    f2boptions['ban_time'] = valkey.get('F2B_BAN_TIME')
+    f2boptions['max_ban_time'] = valkey.get('F2B_MAX_BAN_TIME')
+    f2boptions['ban_time_increment'] = valkey.get('F2B_BAN_TIME_INCREMENT')
+    f2boptions['max_attempts'] = valkey.get('F2B_MAX_ATTEMPTS')
+    f2boptions['retry_window'] = valkey.get('F2B_RETRY_WINDOW')
+    f2boptions['netban_ipv4'] = valkey.get('F2B_NETBAN_IPV4')
+    f2boptions['netban_ipv6'] = valkey.get('F2B_NETBAN_IPV6')
   else:
     try:
-      f2boptions = json.loads(r.get('F2B_OPTIONS'))
-    except ValueError as e:
-      logger.logCrit(
-        'Error loading F2B options: F2B_OPTIONS is not json. Exception: %s' % e)
+      f2boptions = json.loads(valkey.get('F2B_OPTIONS'))
+    except ValueError:
+      logger.logCrit('Error loading F2B options: F2B_OPTIONS is not json')
       quit_now = True
       exit_code = 2
 
   verifyF2boptions(f2boptions)
-  r.set('F2B_OPTIONS', json.dumps(f2boptions, ensure_ascii=False))
+  valkey.set('F2B_OPTIONS', json.dumps(f2boptions, ensure_ascii=False))
 
 def verifyF2boptions(f2boptions):
   verifyF2boption(f2boptions, 'ban_time', 1800)
@@ -82,7 +81,7 @@ def refreshF2bregex():
   global f2bregex
   global quit_now
   global exit_code
-  if not r.get('F2B_REGEX'):
+  if not valkey.get('F2B_REGEX'):
     f2bregex = {}
     f2bregex[1] = r'mailcow UI: Invalid password for .+ by ([0-9a-f\.:]+)'
     f2bregex[2] = r'Rspamd UI: Invalid password by ([0-9a-f\.:]+)'
@@ -93,11 +92,11 @@ def refreshF2bregex():
     f2bregex[7] = r'\w+\([^,]+,([0-9a-f\.:]+),<[^>]+>\): unknown user \(SHA1 of given password: [a-f0-9]+\)'
     f2bregex[8] = r'SOGo.+ Login from \'([0-9a-f\.:]+)\' for user .+ might not have worked'
     f2bregex[9] = r'([0-9a-f\.:]+) \"GET \/SOGo\/.* HTTP.+\" 403 .+'
-    r.set('F2B_REGEX', json.dumps(f2bregex, ensure_ascii=False))
+    valkey.set('F2B_REGEX', json.dumps(f2bregex, ensure_ascii=False))
   else:
     try:
       f2bregex = {}
-      f2bregex = json.loads(r.get('F2B_REGEX'))
+      f2bregex = json.loads(valkey.get('F2B_REGEX'))
     except ValueError:
       logger.logCrit('Error loading F2B options: F2B_REGEX is not json')
       quit_now = True
@@ -176,7 +175,7 @@ def ban(address):
 
     logdebug("Updating F2B_ACTIVE_BANS[%s]=%d" %
               (net, cur_time + NET_BAN_TIME))
-    r.hset('F2B_ACTIVE_BANS', '%s' % net, cur_time + NET_BAN_TIME)
+    valkey.hset('F2B_ACTIVE_BANS', '%s' % net, cur_time + NET_BAN_TIME)
   else:
     logger.logWarn('%d more attempts in the next %d seconds until %s is banned' % (
       MAX_ATTEMPTS - bans[net]['attempts'], RETRY_WINDOW, net))
@@ -187,7 +186,7 @@ def unban(net):
   if not net in bans:
     logger.logInfo(
       '%s is not banned, skipping unban and deleting from queue (if any)' % net)
-    r.hdel('F2B_QUEUE_UNBAN', '%s' % net)
+    valkey.hdel('F2B_QUEUE_UNBAN', '%s' % net)
     return
   logger.logInfo('Unbanning %s' % net)
   if type(ipaddress.ip_network(net)) is ipaddress.IPv4Network:
@@ -198,8 +197,8 @@ def unban(net):
     with lock:
       logdebug("Calling tables.unbanIPv6(%s)" % net)
       tables.unbanIPv6(net)
-  r.hdel('F2B_ACTIVE_BANS', '%s' % net)
-  r.hdel('F2B_QUEUE_UNBAN', '%s' % net)
+  valkey.hdel('F2B_ACTIVE_BANS', '%s' % net)
+  valkey.hdel('F2B_QUEUE_UNBAN', '%s' % net)
   if net in bans:
     logdebug("Unban for %s, setting attempts=0, ban_counter+=1" % net)
     bans[net]['attempts'] = 0
@@ -226,10 +225,10 @@ def permBan(net, unban=False):
 
 
   if is_unbanned:
-    r.hdel('F2B_PERM_BANS', '%s' % net)
+    valkey.hdel('F2B_PERM_BANS', '%s' % net)
     logger.logCrit('Removed host/network %s from denylist' % net)
   elif is_banned:
-    r.hset('F2B_PERM_BANS', '%s' % net, int(round(time.time())))
+    valkey.hset('F2B_PERM_BANS', '%s' % net, int(round(time.time())))
     logger.logCrit('Added host/network %s to denylist' % net)
 
 def clear():
@@ -244,17 +243,17 @@ def clear():
     tables.clearIPv6Table()
     try:
       if r is not None:
-        r.delete('F2B_ACTIVE_BANS')
-        r.delete('F2B_PERM_BANS')
+        valkey.delete('F2B_ACTIVE_BANS')
+        valkey.delete('F2B_PERM_BANS')
     except Exception as ex:
-      logger.logWarn('Error clearing redis keys F2B_ACTIVE_BANS and F2B_PERM_BANS: %s' % ex)
+      logger.logWarn('Error clearing valkey keys F2B_ACTIVE_BANS and F2B_PERM_BANS: %s' % ex)
 
 def watch():
   global pubsub
   global quit_now
   global exit_code
 
-  logger.logInfo('Watching Redis channel F2B_CHANNEL')
+  logger.logInfo('Watching Valkey channel F2B_CHANNEL')
   pubsub.subscribe('F2B_CHANNEL')
 
   while not quit_now:
@@ -306,7 +305,7 @@ def autopurge():
     time.sleep(10)
     refreshF2boptions()
     MAX_ATTEMPTS = int(f2boptions['max_attempts'])
-    QUEUE_UNBAN = r.hgetall('F2B_QUEUE_UNBAN')
+    QUEUE_UNBAN = valkey.hgetall('F2B_QUEUE_UNBAN')
     logdebug("QUEUE_UNBAN: %s" % QUEUE_UNBAN)
     if QUEUE_UNBAN:
       for net in QUEUE_UNBAN:
@@ -391,7 +390,7 @@ def whitelistUpdate():
   global WHITELIST
   while not quit_now:
     start_time = time.time()
-    list = r.hgetall('F2B_WHITELIST')
+    list = valkey.hgetall('F2B_WHITELIST')
     new_whitelist = []
     if list:
       new_whitelist = genNetworkList(list)
@@ -406,7 +405,7 @@ def blacklistUpdate():
   global BLACKLIST
   while not quit_now:
     start_time = time.time()
-    list = r.hgetall('F2B_BLACKLIST')
+    list = valkey.hgetall('F2B_BLACKLIST')
     new_blacklist = []
     if list:
       new_blacklist = genNetworkList(list)
@@ -467,35 +466,35 @@ if __name__ == '__main__':
     logger.logInfo(f"Setting {chain_name} isolation")
     tables.create_mailcow_isolation_rule("br-mailcow", [3306, 6379, 8983, 12345], os.getenv("MAILCOW_REPLICA_IP"))
 
-  # connect to redis
+  # connect to valkey
   while True:
     try:
-      redis_slaveof_ip = os.getenv('REDIS_SLAVEOF_IP', '')
-      redis_slaveof_port = os.getenv('REDIS_SLAVEOF_PORT', '')
+      valkey_slaveof_ip = os.getenv('VALKEY_SLAVEOF_IP', '')
+      valkey_slaveof_port = os.getenv('VALKEY_SLAVEOF_PORT', '')
       logdebug(
-        "Connecting redis (SLAVEOF_IP:%s, PORT:%s)" % (redis_slaveof_ip, redis_slaveof_port))
-      if "".__eq__(redis_slaveof_ip):
-        r = redis.StrictRedis(
-          host=os.getenv('IPV4_NETWORK', '172.22.1') + '.249', decode_responses=True, port=6379, db=0, password=os.environ['REDISPASS'])
+        "Connecting valkey (SLAVEOF_IP:%s, PORT:%s)" % (valkey_slaveof_ip, valkey_slaveof_port))
+      if "".__eq__(valkey_slaveof_ip):
+        valkey = redis.StrictRedis(
+          host=os.getenv('IPV4_NETWORK', '172.22.1') + '.249', decode_responses=True, port=6379, db=0, password=os.environ['VALKEYPASS'])
       else:
-        r = redis.StrictRedis(
-          host=redis_slaveof_ip, decode_responses=True, port=redis_slaveof_port, db=0, password=os.environ['REDISPASS'])
-      r.ping()
-      pubsub = r.pubsub()
+        valkey = redis.StrictRedis(
+          host=valkey_slaveof_ip, decode_responses=True, port=valkey_slaveof_port, db=0, password=os.environ['VALKEYPASS'])
+      valkey.ping()
+      pubsub = valkey.pubsub()
     except Exception as ex:
       logdebug(
         'Redis connection failed: %s - trying again in 3 seconds' % (ex))
       time.sleep(3)
     else:
       break
-  logger.set_redis(r)
-  logdebug("Redis connection established, setting up F2B keys")
+  logger.set_valkey(valkey)
+  logdebug("Valkey connection established, setting up F2B keys")
 
-  if r.exists('F2B_LOG'):
+  if valkey.exists('F2B_LOG'):
     logdebug("Renaming F2B_LOG to NETFILTER_LOG")
-    r.rename('F2B_LOG', 'NETFILTER_LOG')
-  r.delete('F2B_ACTIVE_BANS')
-  r.delete('F2B_PERM_BANS')
+    valkey.rename('F2B_LOG', 'NETFILTER_LOG')
+  valkey.delete('F2B_ACTIVE_BANS')
+  valkey.delete('F2B_PERM_BANS')
 
   refreshF2boptions()
 

data/Dockerfiles/netfilter/modules/Logger.py

@@ -4,19 +4,19 @@ import datetime
 
 class Logger:
   def __init__(self):
-    self.r = None
+    self.valkey = None
 
-  def set_redis(self, redis):
-    self.r = redis
+  def set_valkey(self, valkey):
+    self.valkey = valkey
 
   def _format_timestamp(self):
     # Local time with milliseconds
     return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
   def log(self, priority, message):
-    # build redis-friendly dict
+    # build valkey-friendly dict
     tolog = {
-      'time': int(round(time.time())),  # keep raw timestamp for Redis
+      'time': int(round(time.time())),  # keep raw timestamp for Valkey
       'priority': priority,
       'message': message
     }
@@ -26,11 +26,11 @@ class Logger:
     print(f"{ts} {priority.upper()}: {message}", flush=True)
 
     # also push JSON to Redis if connected
-    if self.r is not None:
+    if self.valkey is not None:
       try:
-        self.r.lpush('NETFILTER_LOG', json.dumps(tolog, ensure_ascii=False))
+        self.valkey.lpush('NETFILTER_LOG', json.dumps(tolog, ensure_ascii=False))
       except Exception as ex:
-        print(f'{ts} WARN: Failed logging to redis: {ex}', flush=True)
+        print(f'{ts} WARN: Failed logging to valkey: {ex}', flush=True)
 
   def logWarn(self, message):
     self.log('warn', message)

data/Dockerfiles/phpfpm/Dockerfile

@@ -3,15 +3,15 @@ FROM php:8.2-fpm-alpine3.21
 LABEL maintainer = "The Infrastructure Company GmbH <info@servercow.de>"
 
 # renovate: datasource=github-tags depName=krakjoe/apcu versioning=semver-coerced extractVersion=^v(?<version>.*)$
-ARG APCU_PECL_VERSION=5.1.28
+ARG APCU_PECL_VERSION=5.1.26
 # renovate: datasource=github-tags depName=Imagick/imagick versioning=semver-coerced extractVersion=(?<version>.*)$
-ARG IMAGICK_PECL_VERSION=3.8.1
+ARG IMAGICK_PECL_VERSION=3.8.0
 # renovate: datasource=github-tags depName=php/pecl-mail-mailparse versioning=semver-coerced extractVersion=^v(?<version>.*)$
-ARG MAILPARSE_PECL_VERSION=3.1.9
+ARG MAILPARSE_PECL_VERSION=3.1.8
 # renovate: datasource=github-tags depName=php-memcached-dev/php-memcached versioning=semver-coerced extractVersion=^v(?<version>.*)$
-ARG MEMCACHED_PECL_VERSION=3.4.0
+ARG MEMCACHED_PECL_VERSION=3.3.0
 # renovate: datasource=github-tags depName=phpredis/phpredis versioning=semver-coerced extractVersion=(?<version>.*)$
-ARG REDIS_PECL_VERSION=6.3.0
+ARG REDIS_PECL_VERSION=6.2.0
 # renovate: datasource=github-tags depName=composer/composer versioning=semver-coerced extractVersion=(?<version>.*)$
 ARG COMPOSER_VERSION=2.8.6
 

data/Dockerfiles/phpfpm/docker-entrypoint.sh

@@ -9,30 +9,30 @@ while ! mariadb-admin status --ssl=false --socket=/var/run/mysqld/mysqld.sock -u
 done
 
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  REDIS_HOST=$REDIS_SLAVEOF_IP
-  REDIS_PORT=$REDIS_SLAVEOF_PORT
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  VALKEY_HOST=$VALKEY_SLAVEOF_IP
+  VALKEY_PORT=$VALKEY_SLAVEOF_PORT
 else
-  REDIS_HOST="redis"
-  REDIS_PORT="6379"
+  VALKEY_HOST="valkey-mailcow"
+  VALKEY_PORT="6379"
 fi
-REDIS_CMDLINE="redis-cli -h ${REDIS_HOST} -p ${REDIS_PORT} -a ${REDISPASS} --no-auth-warning"
+VALKEY_CMDLINE="redis-cli -h ${VALKEY_HOST} -p ${VALKEY_PORT} -a ${VALKEYPASS} --no-auth-warning"
 
-until [[ $(${REDIS_CMDLINE} PING) == "PONG" ]]; do
-  echo "Waiting for Redis..."
+until [[ $(${VALKEY_CMDLINE} PING) == "PONG" ]]; do
+  echo "Waiting for Valkey..."
   sleep 2
 done
 
-# Set redis session store
+# Set valkey session store
 echo -n '
 session.save_handler = redis
-session.save_path = "tcp://'${REDIS_HOST}':'${REDIS_PORT}'?auth='${REDISPASS}'"
+session.save_path = "tcp://'${VALKEY_HOST}':'${VALKEY_PORT}'?auth='${VALKEYPASS}'"
 ' > /usr/local/etc/php/conf.d/session_store.ini
 
 # Check mysql_upgrade (master and slave)
 CONTAINER_ID=
 until [[ ! -z "${CONTAINER_ID}" ]] && [[ "${CONTAINER_ID}" =~ ^[[:alnum:]]*$ ]]; do
-  CONTAINER_ID=$(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" 2> /dev/null | jq -rc "select( .name | tostring | contains(\"mysql-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" 2> /dev/null)
+  CONTAINER_ID=$(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" 2> /dev/null | jq -rc "select( .name | tostring | contains(\"mysql-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" 2> /dev/null)
   echo "Could not get mysql-mailcow container id... trying again"
   sleep 2
 done
@@ -44,7 +44,7 @@ until [[ ${SQL_UPGRADE_STATUS} == 'success' ]]; do
     echo "Tried to upgrade MySQL and failed, giving up after ${SQL_LOOP_C} retries and starting container (oops, not good)"
     break
   fi
-  SQL_FULL_UPGRADE_RETURN=$(curl --silent --insecure -XPOST https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/exec -d '{"cmd":"system", "task":"mysql_upgrade"}' --silent -H 'Content-type: application/json')
+  SQL_FULL_UPGRADE_RETURN=$(curl --silent --insecure -XPOST https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/exec -d '{"cmd":"system", "task":"mysql_upgrade"}' --silent -H 'Content-type: application/json')
   SQL_UPGRADE_STATUS=$(echo ${SQL_FULL_UPGRADE_RETURN} | jq -r .type)
   SQL_LOOP_C=$((SQL_LOOP_C+1))
   echo "SQL upgrade iteration #${SQL_LOOP_C}"
@@ -69,12 +69,12 @@ done
 
 # doing post-installation stuff, if SQL was upgraded (master and slave)
 if [ ${SQL_CHANGED} -eq 1 ]; then
-  POSTFIX=$(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" 2> /dev/null | jq -rc "select( .name | tostring | contains(\"postfix-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" 2> /dev/null)
+  POSTFIX=$(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" 2> /dev/null | jq -rc "select( .name | tostring | contains(\"postfix-mailcow\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id" 2> /dev/null)
   if [[ -z "${POSTFIX}" ]] || ! [[ "${POSTFIX}" =~ ^[[:alnum:]]*$ ]]; then
     echo "Could not determine Postfix container ID, skipping Postfix restart."
   else
     echo "Restarting Postfix"
-    curl -X POST --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${POSTFIX}/restart | jq -r '.msg'
+    curl -X POST --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${POSTFIX}/restart | jq -r '.msg'
     echo "Sleeping 5 seconds..."
     sleep 5
   fi
@@ -83,7 +83,7 @@ fi
 # Check mysql tz import (master and slave)
 TZ_CHECK=$(mariadb --skip-ssl --socket=/var/run/mysqld/mysqld.sock -u ${DBUSER} -p${DBPASS} ${DBNAME} -e "SELECT CONVERT_TZ('2019-11-02 23:33:00','Europe/Berlin','UTC') AS time;" -BN 2> /dev/null)
 if [[ -z ${TZ_CHECK} ]] || [[ "${TZ_CHECK}" == "NULL" ]]; then
-  SQL_FULL_TZINFO_IMPORT_RETURN=$(curl --silent --insecure -XPOST https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/exec -d '{"cmd":"system", "task":"mysql_tzinfo_to_sql"}' --silent -H 'Content-type: application/json')
+  SQL_FULL_TZINFO_IMPORT_RETURN=$(curl --silent --insecure -XPOST https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/exec -d '{"cmd":"system", "task":"mysql_tzinfo_to_sql"}' --silent -H 'Content-type: application/json')
   echo "MySQL mysql_tzinfo_to_sql - debug output:"
   echo ${SQL_FULL_TZINFO_IMPORT_RETURN}
 fi
@@ -91,22 +91,22 @@ fi
 if [[ "${MASTER}" =~ ^([yY][eE][sS]|[yY])+$ ]]; then
   echo "We are master, preparing..."
   # Set a default release format
-  if [[ -z $(${REDIS_CMDLINE} --raw GET Q_RELEASE_FORMAT) ]]; then
-    ${REDIS_CMDLINE} --raw SET Q_RELEASE_FORMAT raw
+  if [[ -z $(${VALKEY_CMDLINE} --raw GET Q_RELEASE_FORMAT) ]]; then
+    ${VALKEY_CMDLINE} --raw SET Q_RELEASE_FORMAT raw
   fi
 
   # Set max age of q items - if unset
-  if [[ -z $(${REDIS_CMDLINE} --raw GET Q_MAX_AGE) ]]; then
-    ${REDIS_CMDLINE} --raw SET Q_MAX_AGE 365
+  if [[ -z $(${VALKEY_CMDLINE} --raw GET Q_MAX_AGE) ]]; then
+    ${VALKEY_CMDLINE} --raw SET Q_MAX_AGE 365
   fi
 
   # Set default password policy - if unset
-  if [[ -z $(${REDIS_CMDLINE} --raw HGET PASSWD_POLICY length) ]]; then
-    ${REDIS_CMDLINE} --raw HSET PASSWD_POLICY length 6
-    ${REDIS_CMDLINE} --raw HSET PASSWD_POLICY chars 0
-    ${REDIS_CMDLINE} --raw HSET PASSWD_POLICY special_chars 0
-    ${REDIS_CMDLINE} --raw HSET PASSWD_POLICY lowerupper 0
-    ${REDIS_CMDLINE} --raw HSET PASSWD_POLICY numbers 0
+  if [[ -z $(${VALKEY_CMDLINE} --raw HGET PASSWD_POLICY length) ]]; then
+    ${VALKEY_CMDLINE} --raw HSET PASSWD_POLICY length 6
+    ${VALKEY_CMDLINE} --raw HSET PASSWD_POLICY chars 0
+    ${VALKEY_CMDLINE} --raw HSET PASSWD_POLICY special_chars 0
+    ${VALKEY_CMDLINE} --raw HSET PASSWD_POLICY lowerupper 0
+    ${VALKEY_CMDLINE} --raw HSET PASSWD_POLICY numbers 0
   fi
 
   # Trigger db init
@@ -114,9 +114,9 @@ if [[ "${MASTER}" =~ ^([yY][eE][sS]|[yY])+$ ]]; then
   php -c /usr/local/etc/php -f /web/inc/init_db.inc.php
 
   # Recreating domain map
-  echo "Rebuilding domain map in Redis..."
+  echo "Rebuilding domain map in Valkey..."
   declare -a DOMAIN_ARR
-    ${REDIS_CMDLINE} DEL DOMAIN_MAP > /dev/null
+    ${VALKEY_CMDLINE} DEL DOMAIN_MAP > /dev/null
   while read line
   do
     DOMAIN_ARR+=("$line")
@@ -128,7 +128,7 @@ if [[ "${MASTER}" =~ ^([yY][eE][sS]|[yY])+$ ]]; then
 
   if [[ ! -z ${DOMAIN_ARR} ]]; then
   for domain in "${DOMAIN_ARR[@]}"; do
-    ${REDIS_CMDLINE} HSET DOMAIN_MAP ${domain} 1 > /dev/null
+    ${VALKEY_CMDLINE} HSET DOMAIN_MAP ${domain} 1 > /dev/null
   done
   fi
 
@@ -167,7 +167,7 @@ DELIMITER //
 CREATE EVENT clean_spamalias
 ON SCHEDULE EVERY 1 DAY DO
 BEGIN
-  DELETE FROM spamalias WHERE validity < UNIX_TIMESTAMP() AND permanent = 0;
+  DELETE FROM spamalias WHERE validity < UNIX_TIMESTAMP();
 END;
 //
 DELIMITER ;

data/Dockerfiles/postfix-tlspol/Dockerfile

@@ -4,7 +4,7 @@ WORKDIR /src
 ENV CGO_ENABLED=0 \
     GO111MODULE=on \
 		NOOPT=1 \
-    VERSION=1.8.22
+    VERSION=1.8.14
 
 RUN git clone --branch v${VERSION} https://github.com/Zuplu/postfix-tlspol && \
     cd /src/postfix-tlspol && \
@@ -34,7 +34,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 COPY supervisord.conf /etc/supervisor/supervisord.conf
 COPY syslog-ng.conf /etc/syslog-ng/syslog-ng.conf
-COPY syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng-redis_slave.conf
+COPY syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng-valkey_slave.conf
 COPY postfix-tlspol.sh /opt/postfix-tlspol.sh
 COPY stop-supervisor.sh /usr/local/sbin/stop-supervisor.sh
 COPY docker-entrypoint.sh /docker-entrypoint.sh

data/Dockerfiles/postfix-tlspol/docker-entrypoint.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  cp /etc/syslog-ng/syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng.conf
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  cp /etc/syslog-ng/syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng.conf
 fi
 
 exec "$@"

data/Dockerfiles/postfix-tlspol/postfix-tlspol.sh

@@ -17,14 +17,14 @@ until dig +short mailcow.email > /dev/null; do
 done
 
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  export REDIS_CMDLINE="redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning"
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  export VALKEY_CMDLINE="redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning"
 else
-  export REDIS_CMDLINE="redis-cli -h redis -p 6379 -a ${REDISPASS} --no-auth-warning"
+  export VALKEY_CMDLINE="redis-cli -h valkey -p 6379 -a ${VALKEYPASS} --no-auth-warning"
 fi
 
-until [[ $(${REDIS_CMDLINE} PING) == "PONG" ]]; do
-  echo "Waiting for Redis..."
+until [[ $(${VALKEY_CMDLINE} PING) == "PONG" ]]; do
+  echo "Waiting for Valkey..."
   sleep 2
 done
 

data/Dockerfiles/postfix-tlspol/syslog-ng-valkey_slave.conf

@@ -15,12 +15,12 @@ source s_src {
   internal();
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis1")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey1")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("LPUSH" "POSTFIX_MAILLOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
@@ -41,5 +41,5 @@ log {
   filter(f_ignore);
   destination(d_stdout);
   filter(f_mail);
-  destination(d_redis_ui_log);
+  destination(d_valkey_ui_log);
 };

data/Dockerfiles/postfix-tlspol/syslog-ng.conf

@@ -15,12 +15,12 @@ source s_src {
   internal();
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("redis-mailcow")
-    persist-name("redis1")
+    host("valkey-mailcow")
+    persist-name("valkey1")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("LPUSH" "POSTFIX_MAILLOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
@@ -41,5 +41,5 @@ log {
   filter(f_ignore);
   destination(d_stdout);
   filter(f_mail);
-  destination(d_redis_ui_log);
+  destination(d_valkey_ui_log);
 };

data/Dockerfiles/postfix/Dockerfile

@@ -41,7 +41,7 @@ RUN groupadd -g 102 postfix \
 
 COPY supervisord.conf /etc/supervisor/supervisord.conf
 COPY syslog-ng.conf /etc/syslog-ng/syslog-ng.conf
-COPY syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng-redis_slave.conf
+COPY syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng-valkey_slave.conf
 COPY postfix.sh /opt/postfix.sh
 COPY rspamd-pipe-ham /usr/local/bin/rspamd-pipe-ham
 COPY rspamd-pipe-spam /usr/local/bin/rspamd-pipe-spam

data/Dockerfiles/postfix/docker-entrypoint.sh

@@ -8,8 +8,8 @@ for file in /hooks/*; do
   fi
 done
 
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  cp /etc/syslog-ng/syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng.conf
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  cp /etc/syslog-ng/syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng.conf
 fi
 
 # Fix OpenSSL 3.X TLS1.0, 1.1 support (https://community.mailcow.email/d/4062-hi-all/20)
@@ -21,6 +21,6 @@ if grep -qE '\!SSLv2|\!SSLv3|>=TLSv1(\.[0-1])?$' /opt/postfix/conf/main.cf /opt/
     echo "[tls_system_default]" >> /etc/ssl/openssl.cnf
     echo "MinProtocol = TLSv1" >> /etc/ssl/openssl.cnf
     echo "CipherString = DEFAULT@SECLEVEL=0" >> /etc/ssl/openssl.cnf
-fi  
+fi
 
 exec "$@"

data/Dockerfiles/postfix/postfix.sh

@@ -329,17 +329,14 @@ query = SELECT goto FROM alias
           SELECT id FROM alias
             WHERE address='%s'
             AND (active='1' OR active='2')
-            AND sender_allowed='1'
         ), (
           SELECT id FROM alias
             WHERE address='@%d'
             AND (active='1' OR active='2')
-            AND sender_allowed='1'
         )
       )
     )
     AND active='1'
-    AND sender_allowed='1'
     AND (domain IN
       (SELECT domain FROM domain
         WHERE domain='%d'
@@ -393,7 +390,7 @@ hosts = unix:/var/run/mysqld/mysqld.sock
 dbname = ${DBNAME}
 query = SELECT goto FROM spamalias
   WHERE address='%s'
-    AND (validity >= UNIX_TIMESTAMP() OR permanent != 0)
+    AND validity >= UNIX_TIMESTAMP()
 EOF
 
 if [ ! -f /opt/postfix/conf/dns_blocklists.cf ]; then
@@ -527,4 +524,4 @@ if [[ $? != 0 ]]; then
 else
   postfix -c /opt/postfix/conf start
   sleep 126144000
-fi
+fi

data/Dockerfiles/postfix/syslog-ng-valkey_slave.conf

@@ -15,21 +15,21 @@ source s_src {
   internal();
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis1")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey1")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("LPUSH" "POSTFIX_MAILLOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
-destination d_redis_f2b_channel {
+destination d_valkey_f2b_channel {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis2")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey2")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("PUBLISH" "F2B_CHANNEL" "$(sanitize $MESSAGE)")
   );
 };
@@ -50,6 +50,6 @@ log {
   filter(f_ignore);
   destination(d_stdout);
   filter(f_mail);
-  destination(d_redis_ui_log);
-  destination(d_redis_f2b_channel);
+  destination(d_valkey_ui_log);
+  destination(d_valkey_f2b_channel);
 };

data/Dockerfiles/postfix/syslog-ng.conf

@@ -15,21 +15,21 @@ source s_src {
   internal();
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("redis-mailcow")
-    persist-name("redis1")
+    host("valkey-mailcow")
+    persist-name("valkey1")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("LPUSH" "POSTFIX_MAILLOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
-destination d_redis_f2b_channel {
+destination d_valkey_f2b_channel {
   redis(
-    host("redis-mailcow")
-    persist-name("redis2")
+    host("valkey-mailcow")
+    persist-name("valkey2")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("PUBLISH" "F2B_CHANNEL" "$(sanitize $MESSAGE)")
   );
 };
@@ -50,6 +50,6 @@ log {
   filter(f_ignore);
   destination(d_stdout);
   filter(f_mail);
-  destination(d_redis_ui_log);
-  destination(d_redis_f2b_channel);
+  destination(d_valkey_ui_log);
+  destination(d_valkey_f2b_channel);
 };

data/Dockerfiles/rspamd/Dockerfile

@@ -1,9 +1,9 @@
-FROM debian:trixie-slim
+FROM debian:bookworm-slim
 LABEL maintainer="The Infrastructure Company GmbH <info@servercow.de>"
 
 ARG DEBIAN_FRONTEND=noninteractive
-ARG RSPAMD_VER=rspamd_3.14.2-82~90302bc
-ARG CODENAME=trixie
+ARG RSPAMD_VER=rspamd_3.12.1-1~6dbfca2fa
+ARG CODENAME=bookworm
 ENV LC_ALL=C
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
@@ -14,8 +14,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
   dnsutils \
   netcat-traditional \
   wget \
-  redis-tools \
-  procps \
+  redis-tools \ 
+  procps \ 
   nano \
   lua-cjson \
   && arch=$(arch | sed s/aarch64/arm64/ | sed s/x86_64/amd64/) \

data/Dockerfiles/rspamd/docker-entrypoint.sh

@@ -52,33 +52,33 @@ if [[ ! -z ${RSPAMD_V6} ]]; then
   echo ${RSPAMD_V6}/128 >> /etc/rspamd/custom/rspamd_trusted.map
 fi
 
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
   cat <<EOF > /etc/rspamd/local.d/redis.conf
-read_servers = "redis:6379";
-write_servers = "${REDIS_SLAVEOF_IP}:${REDIS_SLAVEOF_PORT}";
-password = "${REDISPASS}";
+read_servers = "valkey-mailcow:6379";
+write_servers = "${VALKEY_SLAVEOF_IP}:${VALKEY_SLAVEOF_PORT}";
+password = "${VALKEYPASS}";
 timeout = 10;
 EOF
-  until [[ $(redis-cli -h redis-mailcow -a ${REDISPASS} --no-auth-warning PING) == "PONG" ]]; do
-    echo "Waiting for Redis @redis-mailcow..."
+  until [[ $(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning PING) == "PONG" ]]; do
+    echo "Waiting for Valkey @valkey-mailcow..."
     sleep 2
   done
-  until [[ $(redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning PING) == "PONG" ]]; do
-    echo "Waiting for Redis @${REDIS_SLAVEOF_IP}..."
+  until [[ $(redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning PING) == "PONG" ]]; do
+    echo "Waiting for Valkey @${VALKEY_SLAVEOF_IP}..."
     sleep 2
   done
-  redis-cli -h redis-mailcow -a ${REDISPASS} --no-auth-warning SLAVEOF ${REDIS_SLAVEOF_IP} ${REDIS_SLAVEOF_PORT}
+  redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning SLAVEOF ${VALKEY_SLAVEOF_IP} ${VALKEY_SLAVEOF_PORT}
 else
   cat <<EOF > /etc/rspamd/local.d/redis.conf
-servers = "redis:6379";
-password = "${REDISPASS}";
+servers = "valkey-mailcow:6379";
+password = "${VALKEYPASS}";
 timeout = 10;
 EOF
-  until [[ $(redis-cli -h redis-mailcow -a ${REDISPASS} --no-auth-warning PING) == "PONG" ]]; do
-    echo "Waiting for Redis slave..."
+  until [[ $(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning PING) == "PONG" ]]; do
+    echo "Waiting for Valkey slave..."
     sleep 2
   done
-  redis-cli -h redis-mailcow -a ${REDISPASS} --no-auth-warning SLAVEOF NO ONE
+  redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning SLAVEOF NO ONE
 fi
 
 if [[ "${SKIP_OLEFY}" =~ ^([yY][eE][sS]|[yY])+$ ]]; then

data/Dockerfiles/sogo/Dockerfile

@@ -6,7 +6,7 @@ ARG DEBIAN_FRONTEND=noninteractive
 ARG DEBIAN_VERSION=bookworm
 ARG SOGO_DEBIAN_REPOSITORY=https://packagingv2.sogo.nu/sogo-nightly-debian/
 # renovate: datasource=github-releases depName=tianon/gosu versioning=semver-coerced extractVersion=^(?<version>.*)$
-ARG GOSU_VERSION=1.19
+ARG GOSU_VERSION=1.17
 ENV LC_ALL=C
 
 # Prerequisites
@@ -44,7 +44,7 @@ RUN echo "Building from repository $SOGO_DEBIAN_REPOSITORY" \
 
 COPY ./bootstrap-sogo.sh /bootstrap-sogo.sh
 COPY syslog-ng.conf /etc/syslog-ng/syslog-ng.conf
-COPY syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng-redis_slave.conf
+COPY syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng-valkey_slave.conf
 COPY supervisord.conf /etc/supervisor/supervisord.conf
 COPY acl.diff /acl.diff
 COPY navMailcowBtns.diff /navMailcowBtns.diff

data/Dockerfiles/sogo/bootstrap-sogo.sh

@@ -50,6 +50,10 @@ cat <<EOF > /var/lib/sogo/GNUstep/Defaults/sogod.plist
     <string>YES</string>
     <key>SOGoEncryptionKey</key>
     <string>${RAND_PASS}</string>
+    <key>SOGoURLEncryptionEnabled</key>
+    <string>YES</string>
+    <key>SOGoURLEncryptionPassphrase</key>
+    <string>${SOGO_URL_ENCRYPTION_KEY}</string>
     <key>OCSAdminURL</key>
     <string>mysql://${DBUSER}:${DBPASS}@%2Fvar%2Frun%2Fmysqld%2Fmysqld.sock/${DBNAME}/sogo_admin</string>
     <key>OCSCacheFolderURL</key>

data/Dockerfiles/sogo/docker-entrypoint.sh

@@ -6,8 +6,8 @@ if [[ "${SKIP_SOGO}" =~ ^([yY][eE][sS]|[yY])+$ ]]; then
   exit 0
 fi
 
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  cp /etc/syslog-ng/syslog-ng-redis_slave.conf /etc/syslog-ng/syslog-ng.conf
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  cp /etc/syslog-ng/syslog-ng-valkey_slave.conf /etc/syslog-ng/syslog-ng.conf
 fi
 
 echo "$TZ" > /etc/timezone

data/Dockerfiles/sogo/syslog-ng-valkey_slave.conf

@@ -17,28 +17,28 @@ source s_sogo {
   pipe("/dev/sogo_log" owner(sogo) group(sogo));
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis1")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey1")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("LPUSH" "SOGO_LOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
-destination d_redis_f2b_channel {
+destination d_valkey_f2b_channel {
   redis(
-    host("`REDIS_SLAVEOF_IP`")
-    persist-name("redis2")
-    port(`REDIS_SLAVEOF_PORT`)
-    auth("`REDISPASS`")
+    host("`VALKEY_SLAVEOF_IP`")
+    persist-name("valkey2")
+    port(`VALKEY_SLAVEOF_PORT`)
+    auth("`VALKEYPASS`")
     command("PUBLISH" "F2B_CHANNEL" "$(sanitize $MESSAGE)")
   );
 };
 log {
   source(s_sogo);
-  destination(d_redis_ui_log);
-  destination(d_redis_f2b_channel);
+  destination(d_valkey_ui_log);
+  destination(d_valkey_f2b_channel);
 };
 log {
   source(s_sogo);

data/Dockerfiles/sogo/syslog-ng.conf

@@ -17,28 +17,28 @@ source s_sogo {
   pipe("/dev/sogo_log" owner(sogo) group(sogo));
 };
 destination d_stdout { pipe("/dev/stdout"); };
-destination d_redis_ui_log {
+destination d_valkey_ui_log {
   redis(
-    host("redis-mailcow")
-    persist-name("redis1")
+    host("valkey-mailcow")
+    persist-name("valkey1")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("LPUSH" "SOGO_LOG" "$(format-json time=\"$S_UNIXTIME\" priority=\"$PRIORITY\" program=\"$PROGRAM\" message=\"$MESSAGE\")\n")
   );
 };
-destination d_redis_f2b_channel {
+destination d_valkey_f2b_channel {
   redis(
-    host("redis-mailcow")
-    persist-name("redis2")
+    host("valkey-mailcow")
+    persist-name("valkey2")
     port(6379)
-    auth("`REDISPASS`")
+    auth("`VALKEYPASS`")
     command("PUBLISH" "F2B_CHANNEL" "$(sanitize $MESSAGE)")
   );
 };
 log {
   source(s_sogo);
-  destination(d_redis_ui_log);
-  destination(d_redis_f2b_channel);
+  destination(d_valkey_ui_log);
+  destination(d_valkey_f2b_channel);
 };
 log {
   source(s_sogo);

data/Dockerfiles/valkeymigrator/Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.13.2-alpine3.21
+
+WORKDIR /app
+
+COPY migrate.py /app/migrate.py
+RUN pip install --no-cache-dir redis
+
+CMD ["python", "/app/migrate.py"]

data/Dockerfiles/valkeymigrator/migrate.py

@@ -0,0 +1,78 @@
+import subprocess
+import redis
+import time
+import os
+
+# Container names
+SOURCE_CONTAINER = "redis-old-mailcow"
+DEST_CONTAINER = "valkey-mailcow"
+VALKEYPASS = os.getenv("VALKEYPASS")
+
+
+def migrate_redis():
+    src_redis = redis.StrictRedis(host=SOURCE_CONTAINER, port=6379, db=0, password=VALKEYPASS, decode_responses=False)
+    dest_redis = redis.StrictRedis(host=DEST_CONTAINER, port=6379, db=0, password=VALKEYPASS, decode_responses=False)
+
+    cursor = 0
+    batch_size = 100
+    migrated_count = 0
+
+    print("Starting migration...")
+
+    while True:
+        cursor, keys = src_redis.scan(cursor=cursor, match="*", count=batch_size)
+        keys_to_migrate = [key for key in keys if not key.startswith(b"PHPREDIS_SESSION:")]
+
+        for key in keys_to_migrate:
+            key_type = src_redis.type(key)
+            print(f"Import {key} of type {key_type}")
+
+            if key_type == b"string":
+                value = src_redis.get(key)
+                dest_redis.set(key, value)
+
+            elif key_type == b"hash":
+                value = src_redis.hgetall(key)
+                dest_redis.hset(key, mapping=value)
+
+            elif key_type == b"list":
+                value = src_redis.lrange(key, 0, -1)
+                for v in value:
+                    dest_redis.rpush(key, v)
+
+            elif key_type == b"set":
+                value = src_redis.smembers(key)
+                for v in value:
+                    dest_redis.sadd(key, v)
+
+            elif key_type == b"zset":
+                value = src_redis.zrange(key, 0, -1, withscores=True)
+                for v, score in value:
+                    dest_redis.zadd(key, {v: score})
+
+            # Preserve TTL if exists
+            ttl = src_redis.ttl(key)
+            if ttl > 0:
+                dest_redis.expire(key, ttl)
+
+            migrated_count += 1
+
+        if cursor == 0:
+            break  # No more keys to scan
+
+    print(f"Migration completed! {migrated_count} keys migrated.")
+
+    print("Forcing Valkey to save data...")
+    try:
+        dest_redis.save()  # Immediate RDB save (blocking)
+        dest_redis.bgrewriteaof()  # Rewrites the AOF file in the background
+        print("Data successfully saved to disk.")
+    except Exception as e:
+        print(f"Failed to save data: {e}")
+
+# Main script execution
+if __name__ == "__main__":
+    try:
+        migrate_redis()
+    finally:
+        pass

data/Dockerfiles/watchdog/watchdog.sh

@@ -44,18 +44,18 @@ while ! mariadb-admin status --ssl=false --socket=/var/run/mysqld/mysqld.sock -u
 done
 
 # Do not attempt to write to slave
-if [[ ! -z ${REDIS_SLAVEOF_IP} ]]; then
-  REDIS_CMDLINE="redis-cli -h ${REDIS_SLAVEOF_IP} -p ${REDIS_SLAVEOF_PORT} -a ${REDISPASS} --no-auth-warning"
+if [[ ! -z ${VALKEY_SLAVEOF_IP} ]]; then
+  VALKEY_CMDLINE="redis-cli -h ${VALKEY_SLAVEOF_IP} -p ${VALKEY_SLAVEOF_PORT} -a ${VALKEYPASS} --no-auth-warning"
 else
-  REDIS_CMDLINE="redis-cli -h redis -p 6379 -a ${REDISPASS} --no-auth-warning"
+  VALKEY_CMDLINE="redis-cli -h valkey-mailcow -p 6379 -a ${VALKEYPASS} --no-auth-warning"
 fi
 
-until [[ $(${REDIS_CMDLINE} PING) == "PONG" ]]; do
-  echo "Waiting for Redis..."
+until [[ $(${VALKEY_CMDLINE} PING) == "PONG" ]]; do
+  echo "Waiting for Valkey..."
   sleep 2
 done
 
-${REDIS_CMDLINE} DEL F2B_RES > /dev/null
+${VALKEY_CMDLINE} DEL F2B_RES > /dev/null
 
 # Common functions
 get_ipv6(){
@@ -90,15 +90,15 @@ progress() {
   [[ ${CURRENT} -gt ${TOTAL} ]] && return
   [[ ${CURRENT} -lt 0 ]] && CURRENT=0
   PERCENT=$(( 200 * ${CURRENT} / ${TOTAL} % 2 + 100 * ${CURRENT} / ${TOTAL} ))
-  ${REDIS_CMDLINE} LPUSH WATCHDOG_LOG "{\"time\":\"$(date +%s)\",\"service\":\"${SERVICE}\",\"lvl\":\"${PERCENT}\",\"hpnow\":\"${CURRENT}\",\"hptotal\":\"${TOTAL}\",\"hpdiff\":\"${DIFF}\"}" > /dev/null
-  log_msg "${SERVICE} health level: ${PERCENT}% (${CURRENT}/${TOTAL}), health trend: ${DIFF}" no_redis
+  ${VALKEY_CMDLINE} LPUSH WATCHDOG_LOG "{\"time\":\"$(date +%s)\",\"service\":\"${SERVICE}\",\"lvl\":\"${PERCENT}\",\"hpnow\":\"${CURRENT}\",\"hptotal\":\"${TOTAL}\",\"hpdiff\":\"${DIFF}\"}" > /dev/null
+  log_msg "${SERVICE} health level: ${PERCENT}% (${CURRENT}/${TOTAL}), health trend: ${DIFF}" no_valkey
   # Return 10 to indicate a dead service
   [ ${CURRENT} -le 0 ] && return 10
 }
 
 log_msg() {
-  if [[ ${2} != "no_redis" ]]; then
-    ${REDIS_CMDLINE} LPUSH WATCHDOG_LOG "{\"time\":\"$(date +%s)\",\"message\":\"$(printf '%s' "${1}" | \
+  if [[ ${2} != "no_valkey" ]]; then
+    ${VALKEY_CMDLINE} LPUSH WATCHDOG_LOG "{\"time\":\"$(date +%s)\",\"message\":\"$(printf '%s' "${1}" | \
       tr '\r\n%&;$"_[]{}-' ' ')\"}" > /dev/null
   fi
   echo $(date) $(printf '%s\n' "${1}")
@@ -114,10 +114,10 @@ function notify_error() {
   # If exists, mail will be throttled by argument in seconds
   [[ ! -z ${3} ]] && THROTTLE=${3}
   if [[ ! -z ${THROTTLE} ]]; then
-    TTL_LEFT="$(${REDIS_CMDLINE} TTL THROTTLE_${1} 2> /dev/null)"
+    TTL_LEFT="$(${VALKEY_CMDLINE} TTL THROTTLE_${1} 2> /dev/null)"
     if [[ "${TTL_LEFT}" == "-2" ]]; then
       # Delay key not found, setting a delay key now
-      ${REDIS_CMDLINE} SET THROTTLE_${1} 1 EX ${THROTTLE}
+      ${VALKEY_CMDLINE} SET THROTTLE_${1} 1 EX ${THROTTLE}
     else
       log_msg "Not sending notification email now, blocked for ${TTL_LEFT} seconds..."
       return 1
@@ -200,12 +200,12 @@ get_container_ip() {
     else
       sleep 0.5
       # get long container id for exact match
-      CONTAINER_ID=($(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring == \"${1}\") | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id"))
+      CONTAINER_ID=($(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring == \"${1}\") | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id"))
       # returned id can have multiple elements (if scaled), shuffle for random test
       CONTAINER_ID=($(printf "%s\n" "${CONTAINER_ID[@]}" | shuf))
       if [[ ! -z ${CONTAINER_ID} ]]; then
         for matched_container in "${CONTAINER_ID[@]}"; do
-          CONTAINER_IPS=($(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${matched_container}/json | jq -r '.NetworkSettings.Networks[].IPAddress'))
+          CONTAINER_IPS=($(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${matched_container}/json | jq -r '.NetworkSettings.Networks[].IPAddress'))
           for ip_match in "${CONTAINER_IPS[@]}"; do
             # grep will do nothing if one of these vars is empty
             [[ -z ${ip_match} ]] && continue
@@ -324,21 +324,21 @@ unbound_checks() {
   return 1
 }
 
-redis_checks() {
-  # A check for the local redis container
+valkey_checks() {
+  # A check for the local valkey container
   err_count=0
   diff_c=0
-  THRESHOLD=${REDIS_THRESHOLD}
+  THRESHOLD=${VALKEY_THRESHOLD}
   # Reduce error count by 2 after restarting an unhealthy container
   trap "[ ${err_count} -gt 1 ] && err_count=$(( ${err_count} - 2 ))" USR1
   while [ ${err_count} -lt ${THRESHOLD} ]; do
-    touch /tmp/redis-mailcow; echo "$(tail -50 /tmp/redis-mailcow)" > /tmp/redis-mailcow
-    host_ip=$(get_container_ip redis-mailcow)
+    touch /tmp/valkey-mailcow; echo "$(tail -50 /tmp/valkey-mailcow)" > /tmp/valkey-mailcow
+    host_ip=$(get_container_ip valkey-mailcow)
     err_c_cur=${err_count}
-    /usr/lib/nagios/plugins/check_tcp -4 -H redis-mailcow -p 6379 -E -s "AUTH ${REDISPASS}\nPING\n" -q "QUIT" -e "PONG" 2>> /tmp/redis-mailcow 1>&2; err_count=$(( ${err_count} + $? ))
+    /usr/lib/nagios/plugins/check_tcp -4 -H valkey-mailcow -p 6379 -E -s "AUTH ${VALKEYPASS}\nPING\n" -q "QUIT" -e "PONG" 2>> /tmp/valkey-mailcow 1>&2; err_count=$(( ${err_count} + $? ))
     [ ${err_c_cur} -eq ${err_count} ] && [ ! $((${err_count} - 1)) -lt 0 ] && err_count=$((${err_count} - 1)) diff_c=1
     [ ${err_c_cur} -ne ${err_count} ] && diff_c=$(( ${err_c_cur} - ${err_count} ))
-    progress "Redis" ${THRESHOLD} $(( ${THRESHOLD} - ${err_count} )) ${diff_c}
+    progress "Valkey" ${THRESHOLD} $(( ${THRESHOLD} - ${err_count} )) ${diff_c}
     if [[ $? == 10 ]]; then
       diff_c=0
       sleep 1
@@ -533,12 +533,12 @@ dovecot_repl_checks() {
   err_count=0
   diff_c=0
   THRESHOLD=${DOVECOT_REPL_THRESHOLD}
-  D_REPL_STATUS=$(redis-cli -h redis -a ${REDISPASS} --no-auth-warning -r GET DOVECOT_REPL_HEALTH)
+  D_REPL_STATUS=$(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning -r GET DOVECOT_REPL_HEALTH)
   # Reduce error count by 2 after restarting an unhealthy container
   trap "[ ${err_count} -gt 1 ] && err_count=$(( ${err_count} - 2 ))" USR1
   while [ ${err_count} -lt ${THRESHOLD} ]; do
     err_c_cur=${err_count}
-    D_REPL_STATUS=$(redis-cli --raw -h redis -a ${REDISPASS} --no-auth-warning GET DOVECOT_REPL_HEALTH)
+    D_REPL_STATUS=$(redis-cli --raw -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning GET DOVECOT_REPL_HEALTH)
     if [[ "${D_REPL_STATUS}" != "1" ]]; then
       err_count=$(( ${err_count} + 1 ))
     fi
@@ -608,19 +608,19 @@ ratelimit_checks() {
   err_count=0
   diff_c=0
   THRESHOLD=${RATELIMIT_THRESHOLD}
-  RL_LOG_STATUS=$(redis-cli -h redis -a ${REDISPASS} --no-auth-warning LRANGE RL_LOG 0 0 | jq .qid)
+  RL_LOG_STATUS=$(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning LRANGE RL_LOG 0 0 | jq .qid)
   # Reduce error count by 2 after restarting an unhealthy container
   trap "[ ${err_count} -gt 1 ] && err_count=$(( ${err_count} - 2 ))" USR1
   while [ ${err_count} -lt ${THRESHOLD} ]; do
     err_c_cur=${err_count}
     RL_LOG_STATUS_PREV=${RL_LOG_STATUS}
-    RL_LOG_STATUS=$(redis-cli -h redis -a ${REDISPASS} --no-auth-warning LRANGE RL_LOG 0 0 | jq .qid)
+    RL_LOG_STATUS=$(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning LRANGE RL_LOG 0 0 | jq .qid)
     if [[ ${RL_LOG_STATUS_PREV} != ${RL_LOG_STATUS} ]]; then
       err_count=$(( ${err_count} + 1 ))
       echo 'Last 10 applied ratelimits (may overlap with previous reports).' > /tmp/ratelimit
       echo 'Full ratelimit buckets can be emptied by deleting the ratelimit hash from within mailcow UI (see /debug -> Protocols -> Ratelimit):' >> /tmp/ratelimit
       echo >> /tmp/ratelimit
-      redis-cli --raw -h redis -a ${REDISPASS} --no-auth-warning LRANGE RL_LOG 0 10 | jq . >> /tmp/ratelimit
+      redis-cli --raw -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning LRANGE RL_LOG 0 10 | jq . >> /tmp/ratelimit
     fi
     [ ${err_c_cur} -eq ${err_count} ] && [ ! $((${err_count} - 1)) -lt 0 ] && err_count=$((${err_count} - 1)) diff_c=1
     [ ${err_c_cur} -ne ${err_count} ] && diff_c=$(( ${err_c_cur} - ${err_count} ))
@@ -669,20 +669,20 @@ fail2ban_checks() {
   err_count=0
   diff_c=0
   THRESHOLD=${FAIL2BAN_THRESHOLD}
-  F2B_LOG_STATUS=($(${REDIS_CMDLINE} --raw HKEYS F2B_ACTIVE_BANS))
+  F2B_LOG_STATUS=($(${VALKEY_CMDLINE} --raw HKEYS F2B_ACTIVE_BANS))
   F2B_RES=
   # Reduce error count by 2 after restarting an unhealthy container
   trap "[ ${err_count} -gt 1 ] && err_count=$(( ${err_count} - 2 ))" USR1
   while [ ${err_count} -lt ${THRESHOLD} ]; do
     err_c_cur=${err_count}
     F2B_LOG_STATUS_PREV=(${F2B_LOG_STATUS[@]})
-    F2B_LOG_STATUS=($(${REDIS_CMDLINE} --raw HKEYS F2B_ACTIVE_BANS))
+    F2B_LOG_STATUS=($(${VALKEY_CMDLINE} --raw HKEYS F2B_ACTIVE_BANS))
     array_diff F2B_RES F2B_LOG_STATUS F2B_LOG_STATUS_PREV
     if [[ ! -z "${F2B_RES}" ]]; then
       err_count=$(( ${err_count} + 1 ))
-      echo -n "${F2B_RES[@]}" | tr -cd "[a-fA-F0-9.:/] " | timeout 3s ${REDIS_CMDLINE} -x SET F2B_RES > /dev/null
+      echo -n "${F2B_RES[@]}" | tr -cd "[a-fA-F0-9.:/] " | timeout 3s ${VALKEY_CMDLINE} -x SET F2B_RES > /dev/null
       if [ $? -ne 0 ]; then
-         ${REDIS_CMDLINE} -x DEL F2B_RES
+         ${VALKEY_CMDLINE} -x DEL F2B_RES
       fi
     fi
     [ ${err_c_cur} -eq ${err_count} ] && [ ! $((${err_count} - 1)) -lt 0 ] && err_count=$((${err_count} - 1)) diff_c=1
@@ -703,9 +703,9 @@ acme_checks() {
   err_count=0
   diff_c=0
   THRESHOLD=${ACME_THRESHOLD}
-  ACME_LOG_STATUS=$(redis-cli -h redis -a ${REDISPASS} --no-auth-warning GET ACME_FAIL_TIME)
+  ACME_LOG_STATUS=$(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning GET ACME_FAIL_TIME)
   if [[ -z "${ACME_LOG_STATUS}" ]]; then
-    ${REDIS_CMDLINE} SET ACME_FAIL_TIME 0
+    ${VALKEY_CMDLINE} SET ACME_FAIL_TIME 0
     ACME_LOG_STATUS=0
   fi
   # Reduce error count by 2 after restarting an unhealthy container
@@ -715,7 +715,7 @@ acme_checks() {
     ACME_LOG_STATUS_PREV=${ACME_LOG_STATUS}
     ACME_LC=0
     until [[ ! -z ${ACME_LOG_STATUS} ]] || [ ${ACME_LC} -ge 3 ]; do
-      ACME_LOG_STATUS=$(redis-cli -h redis -a ${REDISPASS} --no-auth-warning GET ACME_FAIL_TIME 2> /dev/null)
+      ACME_LOG_STATUS=$(redis-cli -h valkey-mailcow -a ${VALKEYPASS} --no-auth-warning GET ACME_FAIL_TIME 2> /dev/null)
       sleep 3
       ACME_LC=$((ACME_LC+1))
     done
@@ -864,14 +864,14 @@ BACKGROUND_TASKS+=(${PID})
 
 (
 while true; do
-  if ! redis_checks; then
-    log_msg "Local Redis hit error limit"
-    echo redis-mailcow > /tmp/com_pipe
+  if ! valkey_checks; then
+    log_msg "Local Valkey hit error limit"
+    echo valkey-mailcow > /tmp/com_pipe
   fi
 done
 ) &
 PID=$!
-echo "Spawned redis_checks with PID ${PID}"
+echo "Spawned valkey_checks with PID ${PID}"
 BACKGROUND_TASKS+=(${PID})
 
 (
@@ -1075,15 +1075,15 @@ while true; do
 done
 ) &
 
-# Monitor controller
+# Monitor dockerapi
 (
 while true; do
-  while nc -z controller 443; do
+  while nc -z dockerapi 443; do
     sleep 3
   done
-  log_msg "Cannot find controller-mailcow, waiting to recover..."
+  log_msg "Cannot find dockerapi-mailcow, waiting to recover..."
   kill -STOP ${BACKGROUND_TASKS[*]}
-  until nc -z controller 443; do
+  until nc -z dockerapi 443; do
     sleep 3
   done
   kill -CONT ${BACKGROUND_TASKS[*]}
@@ -1129,9 +1129,9 @@ while true; do
     # Define $2 to override message text, else print service was restarted at ...
     notify_error "${com_pipe_answer}" "Please check acme-mailcow for further information."
   elif [[ ${com_pipe_answer} == "fail2ban" ]]; then
-    F2B_RES=($(timeout 4s ${REDIS_CMDLINE} --raw GET F2B_RES 2> /dev/null))
+    F2B_RES=($(timeout 4s ${VALKEY_CMDLINE} --raw GET F2B_RES 2> /dev/null))
     if [[ ! -z "${F2B_RES}" ]]; then
-      ${REDIS_CMDLINE} DEL F2B_RES > /dev/null
+      ${VALKEY_CMDLINE} DEL F2B_RES > /dev/null
       host=
       for host in "${F2B_RES[@]}"; do
         log_msg "Banned ${host}"
@@ -1143,12 +1143,12 @@ while true; do
   elif [[ ${com_pipe_answer} =~ .+-mailcow ]]; then
     kill -STOP ${BACKGROUND_TASKS[*]}
     sleep 10
-    CONTAINER_ID=$(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"${com_pipe_answer}\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id")
+    CONTAINER_ID=$(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/json | jq -r ".[] | {name: .Config.Labels[\"com.docker.compose.service\"], project: .Config.Labels[\"com.docker.compose.project\"], id: .Id}" | jq -rc "select( .name | tostring | contains(\"${com_pipe_answer}\")) | select( .project | tostring | contains(\"${COMPOSE_PROJECT_NAME,,}\")) | .id")
     if [[ ! -z ${CONTAINER_ID} ]]; then
       if [[ "${com_pipe_answer}" == "php-fpm-mailcow" ]]; then
-        HAS_INITDB=$(curl --silent --insecure -XPOST https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/top | jq '.msg.Processes[] | contains(["php -c /usr/local/etc/php -f /web/inc/init_db.inc.php"])' | grep true)
+        HAS_INITDB=$(curl --silent --insecure -XPOST https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/top | jq '.msg.Processes[] | contains(["php -c /usr/local/etc/php -f /web/inc/init_db.inc.php"])' | grep true)
       fi
-      S_RUNNING=$(($(date +%s) - $(curl --silent --insecure https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/json | jq .State.StartedAt | xargs -n1 date +%s -d)))
+      S_RUNNING=$(($(date +%s) - $(curl --silent --insecure https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/json | jq .State.StartedAt | xargs -n1 date +%s -d)))
       if [ ${S_RUNNING} -lt 360 ]; then
         log_msg "Container is running for less than 360 seconds, skipping action..."
       elif [[ ! -z ${HAS_INITDB} ]]; then
@@ -1156,7 +1156,7 @@ while true; do
         sleep 60
       else
         log_msg "Sending restart command to ${CONTAINER_ID}..."
-        curl --silent --insecure -XPOST https://controller.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/restart
+        curl --silent --insecure -XPOST https://dockerapi.${COMPOSE_PROJECT_NAME}_mailcow-network/containers/${CONTAINER_ID}/restart
         notify_error "${com_pipe_answer}"
         log_msg "Wait for restarted container to settle and continue watching..."
         sleep 35

data/conf/dovecot/auth/mailcowauth.php

@@ -23,16 +23,16 @@ if (file_exists('../../../web/inc/vars.local.inc.php')) {
 require_once '../../../web/inc/lib/vendor/autoload.php';
 
 
-// Init Redis
-$redis = new Redis();
+// Init Valkey
+$valkey = new Redis();
 try {
-  if (!empty(getenv('REDIS_SLAVEOF_IP'))) {
-    $redis->connect(getenv('REDIS_SLAVEOF_IP'), getenv('REDIS_SLAVEOF_PORT'));
+  if (!empty(getenv('VALKEY_SLAVEOF_IP'))) {
+    $valkey->connect(getenv('VALKEY_SLAVEOF_IP'), getenv('VALKEY_SLAVEOF_PORT'));
   }
   else {
-    $redis->connect('redis-mailcow', 6379);
+    $valkey->connect('valkey-mailcow', 6379);
   }
-  $redis->auth(getenv("REDISPASS"));
+  $valkey->auth(getenv("VALKEYPASS"));
 }
 catch (Exception $e) {
   error_log("MAILCOWAUTH: " . $e . PHP_EOL);
@@ -80,21 +80,14 @@ if ($isSOGoRequest) {
 }
 if ($result === false){
   // If it's a SOGo Request, don't check for protocol access
-  if ($isSOGoRequest) {
-    $service = 'SOGO';
-    $post['service'] = 'NONE';
-  } else {
-    $service = $post['service'];
-  }
-
-  $result = apppass_login($post['username'], $post['password'], array(
-    'service' => $post['service'],
+  $service = ($isSOGoRequest) ? false : array($post['service'] => true);
+  $result = apppass_login($post['username'], $post['password'], $service, array(
     'is_internal' => true,
     'remote_addr' => $post['real_rip']
   ));
   if ($result) {
-    error_log('MAILCOWAUTH: App auth for user ' . $post['username'] . " with service " . $service . " from IP " . $post['real_rip']);
-    set_sasl_log($post['username'], $post['real_rip'], $service);
+    error_log('MAILCOWAUTH: App auth for user ' . $post['username'] . " with service " . $post['service'] . " from IP " . $post['real_rip']);
+    set_sasl_log($post['username'], $post['real_rip'], $post['service']);
   }
 }
 if ($result === false){

data/conf/nginx/templates/nginx.conf.j2

@@ -13,7 +13,6 @@ events {
 http {
     include /etc/nginx/mime.types;
     default_type  application/octet-stream;
-    server_tokens off;
 
     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                       '$status $body_bytes_sent "$http_referer" '

data/conf/nginx/templates/sites-default.conf.j2

@@ -14,6 +14,7 @@ ssl_session_tickets off;
 
 add_header Strict-Transport-Security "max-age=15768000;";
 add_header X-Content-Type-Options nosniff;
+add_header X-XSS-Protection "1; mode=block";
 add_header X-Robots-Tag none;
 add_header X-Download-Options noopen;
 add_header X-Frame-Options "SAMEORIGIN" always;
@@ -185,7 +186,6 @@ location ^~ /Microsoft-Server-ActiveSync {
     auth_request_set $user $upstream_http_x_user;
     auth_request_set $auth $upstream_http_x_auth;
     auth_request_set $auth_type $upstream_http_x_auth_type;
-    auth_request_set $real_ip $remote_addr;
     proxy_set_header x-webobjects-remote-user "$user";
     proxy_set_header Authorization "$auth";
     proxy_set_header x-webobjects-auth-type "$auth_type";
@@ -211,7 +211,6 @@ location ^~ /SOGo {
         auth_request_set $user $upstream_http_x_user;
         auth_request_set $auth $upstream_http_x_auth;
         auth_request_set $auth_type $upstream_http_x_auth_type;
-        auth_request_set $real_ip $remote_addr;
         proxy_set_header x-webobjects-remote-user "$user";
         proxy_set_header Authorization "$auth";
         proxy_set_header x-webobjects-auth-type "$auth_type";
@@ -234,7 +233,6 @@ location ^~ /SOGo {
     auth_request_set $user $upstream_http_x_user;
     auth_request_set $auth $upstream_http_x_auth;
     auth_request_set $auth_type $upstream_http_x_auth_type;
-    auth_request_set $real_ip $remote_addr;
     proxy_set_header x-webobjects-remote-user "$user";
     proxy_set_header Authorization "$auth";
     proxy_set_header x-webobjects-auth-type "$auth_type";

data/conf/phpfpm/crons/keycloak-sync.php

@@ -23,16 +23,16 @@ catch (PDOException $e) {
   exit;
 }
 
-// Init Redis
-$redis = new Redis();
+// Init Valkey
+$valkey = new Redis();
 try {
-  if (!empty(getenv('REDIS_SLAVEOF_IP'))) {
-    $redis->connect(getenv('REDIS_SLAVEOF_IP'), getenv('REDIS_SLAVEOF_PORT'));
+  if (!empty(getenv('VALKEY_SLAVEOF_IP'))) {
+    $valkey->connect(getenv('VALKEY_SLAVEOF_IP'), getenv('VALKEY_SLAVEOF_PORT'));
   }
   else {
-    $redis->connect('redis-mailcow', 6379);
+    $valkey->connect('valkey-mailcow', 6379);
   }
-  $redis->auth(getenv("REDISPASS"));
+  $valkey->auth(getenv("VALKEYPASS"));
 }
 catch (Exception $e) {
   echo "Exiting: " . $e->getMessage();
@@ -41,7 +41,7 @@ catch (Exception $e) {
 }
 
 function logMsg($priority, $message, $task = "Keycloak Sync") {
-  global $redis;
+  global $valkey;
 
   $finalMsg = array(
     "time" => time(),
@@ -49,7 +49,7 @@ function logMsg($priority, $message, $task = "Keycloak Sync") {
     "task" => $task,
     "message" => $message
   );
-  $redis->lPush('CRON_LOG', json_encode($finalMsg));
+  $valkey->lPush('CRON_LOG', json_encode($finalMsg));
 }
 
 // Load core functions first

data/conf/phpfpm/crons/ldap-sync.php

@@ -23,16 +23,16 @@ catch (PDOException $e) {
   exit;
 }
 
-// Init Redis
-$redis = new Redis();
+// Init Valkey
+$valkey = new Redis();
 try {
-  if (!empty(getenv('REDIS_SLAVEOF_IP'))) {
-    $redis->connect(getenv('REDIS_SLAVEOF_IP'), getenv('REDIS_SLAVEOF_PORT'));
+  if (!empty(getenv('VALKEY_SLAVEOF_IP'))) {
+    $valkey->connect(getenv('VALKEY_SLAVEOF_IP'), getenv('VALKEY_SLAVEOF_PORT'));
   }
   else {
-    $redis->connect('redis-mailcow', 6379);
+    $valkey->connect('valkey-mailcow', 6379);
   }
-  $redis->auth(getenv("REDISPASS"));
+  $valkey->auth(getenv("VALKEYPASS"));
 }
 catch (Exception $e) {
   echo "Exiting: " . $e->getMessage();
@@ -41,7 +41,7 @@ catch (Exception $e) {
 }
 
 function logMsg($priority, $message, $task = "LDAP Sync") {
-  global $redis;
+  global $valkey;
 
   $finalMsg = array(
     "time" => time(),
@@ -49,7 +49,7 @@ function logMsg($priority, $message, $task = "LDAP Sync") {
     "task" => $task,
     "message" => $message
   );
-  $redis->lPush('CRON_LOG', json_encode($finalMsg));
+  $valkey->lPush('CRON_LOG', json_encode($finalMsg));
 }
 
 // Load core functions first

data/conf/phpfpm/php-conf.d/opcache-recommended.ini

@@ -1,16 +1,7 @@
-; NOTE: Restart phpfpm on ANY manual changes to PHP files!
-
-; opcache
 opcache.enable=1
 opcache.enable_cli=1
 opcache.interned_strings_buffer=16
 opcache.max_accelerated_files=10000
 opcache.memory_consumption=128
 opcache.save_comments=1
-opcache.validate_timestamps=0
-
-; JIT
-; Disabled for now due to some PHP segmentation faults observed
-; in certain environments. Possibly some PHP or PHP extension bug.
-opcache.jit=disable
-opcache.jit_buffer_size=0
+opcache.revalidate_freq=1

data/conf/postfix/postscreen_access.cidr

@@ -1,6 +1,6 @@
-# Whitelist generated by Postwhite v3.4 on Thu Jan  1 00:24:01 UTC 2026
+# Whitelist generated by Postwhite v3.4 on Wed Oct  1 00:21:33 UTC 2025
 # https://github.com/stevejenkins/postwhite/
-# 2105 total rules
+# 2216 total rules
 2a00:1450:4000::/36	permit
 2a01:111:f400::/48	permit
 2a01:111:f403:2800::/53	permit
@@ -29,9 +29,7 @@
 2a01:b747:3005:200::/56	permit
 2a01:b747:3006:200::/56	permit
 2a02:a60:0:5::/64	permit
-2a0f:f640::/56	permit
 2c0f:fb50:4000::/36	permit
-2.207.151.53	permit
 2.207.217.30	permit
 3.64.237.68	permit
 3.65.3.180	permit
@@ -52,11 +50,14 @@
 8.25.194.0/23	permit
 8.25.196.0/23	permit
 8.36.116.0/24	permit
+8.39.54.0/23	permit
+8.39.54.250/31	permit
 8.39.144.0/24	permit
+8.40.222.0/23	permit
+8.40.222.250/31	permit
 12.130.86.238	permit
-13.107.213.38	permit
-13.107.246.38	permit
-13.108.16.0/20	permit
+13.107.213.41	permit
+13.107.246.41	permit
 13.110.208.0/21	permit
 13.110.209.0/24	permit
 13.110.216.0/22	permit
@@ -168,6 +169,7 @@
 34.215.104.144	permit
 34.218.115.239	permit
 34.225.212.172	permit
+34.241.242.183	permit
 35.83.148.184	permit
 35.155.198.111	permit
 35.158.23.94	permit
@@ -191,6 +193,7 @@
 40.233.64.216	permit
 40.233.83.78	permit
 40.233.88.28	permit
+43.239.212.33	permit
 44.206.138.57	permit
 44.210.169.44	permit
 44.217.45.156	permit
@@ -272,6 +275,7 @@
 50.112.246.219	permit
 52.1.14.157	permit
 52.5.230.59	permit
+52.6.74.205	permit
 52.12.53.23	permit
 52.13.214.179	permit
 52.26.1.71	permit
@@ -295,6 +299,15 @@
 52.94.124.0/28	permit
 52.95.48.152/29	permit
 52.95.49.88/29	permit
+52.96.91.34	permit
+52.96.111.82	permit
+52.96.172.98	permit
+52.96.214.50	permit
+52.96.222.194	permit
+52.96.222.226	permit
+52.96.223.2	permit
+52.96.228.130	permit
+52.96.229.242	permit
 52.100.0.0/15	permit
 52.102.0.0/16	permit
 52.103.0.0/17	permit
@@ -328,6 +341,7 @@
 54.244.54.130	permit
 54.244.242.0/24	permit
 54.255.61.23	permit
+56.124.6.228	permit
 57.103.64.0/18	permit
 57.129.93.249	permit
 62.13.128.0/24	permit
@@ -388,11 +402,31 @@
 64.207.219.143	permit
 64.233.160.0/19	permit
 65.52.80.137	permit
+65.54.51.64/26	permit
+65.54.61.64/26	permit
+65.54.121.120/29	permit
+65.54.190.0/24	permit
+65.54.241.0/24	permit
 65.55.29.77	permit
+65.55.33.64/28	permit
+65.55.34.0/24	permit
 65.55.42.224/28	permit
+65.55.52.224/27	permit
+65.55.78.128/25	permit
+65.55.81.48/28	permit
+65.55.90.0/24	permit
+65.55.94.0/25	permit
+65.55.111.0/24	permit
+65.55.113.64/26	permit
+65.55.116.0/25	permit
+65.55.126.0/25	permit
+65.55.174.0/25	permit
+65.55.178.128/27	permit
+65.55.234.192/26	permit
 65.110.161.77	permit
 65.123.29.213	permit
 65.123.29.220	permit
+65.154.166.0/24	permit
 65.212.180.36	permit
 66.102.0.0/20	permit
 66.119.150.192/26	permit
@@ -509,6 +543,7 @@
 69.169.224.0/20	permit
 69.171.232.0/24	permit
 69.171.244.0/23	permit
+70.37.151.128/25	permit
 70.42.149.35	permit
 72.3.185.0/24	permit
 72.14.192.0/18	permit
@@ -605,6 +640,7 @@
 74.208.4.220	permit
 74.208.4.221	permit
 74.209.250.0/24	permit
+75.2.70.75	permit
 76.223.128.0/19	permit
 76.223.176.0/20	permit
 77.238.176.0/24	permit
@@ -700,6 +736,8 @@
 91.198.2.0/24	permit
 91.211.240.0/22	permit
 94.236.119.0/26	permit
+94.245.112.0/27	permit
+94.245.112.10/31	permit
 95.131.104.0/21	permit
 95.217.114.154	permit
 96.43.144.0/20	permit
@@ -1192,8 +1230,11 @@
 98.139.245.208/30	permit
 98.139.245.212/31	permit
 99.78.197.208/28	permit
+99.83.190.102	permit
 103.9.96.0/22	permit
 103.28.42.0/24	permit
+103.84.217.238	permit
+103.89.75.238	permit
 103.151.192.0/23	permit
 103.168.172.128/27	permit
 103.237.104.0/22	permit
@@ -1337,6 +1378,11 @@
 108.179.144.0/20	permit
 109.224.244.0/24	permit
 109.237.142.0/24	permit
+111.221.23.128/25	permit
+111.221.26.0/27	permit
+111.221.66.0/25	permit
+111.221.69.128/25	permit
+111.221.112.0/21	permit
 112.19.199.64/29	permit
 112.19.242.64/29	permit
 116.214.12.47	permit
@@ -1354,6 +1400,9 @@
 117.120.16.0/21	permit
 119.42.242.52/31	permit
 119.42.242.156	permit
+121.244.91.48	permit
+121.244.91.52	permit
+122.15.156.182	permit
 123.126.78.64/29	permit
 124.108.96.24/31	permit
 124.108.96.28/31	permit
@@ -1381,7 +1430,6 @@
 128.245.248.0/21	permit
 129.41.77.70	permit
 129.41.169.249	permit
-129.77.16.0/20	permit
 129.80.5.164	permit
 129.80.64.36	permit
 129.80.67.121	permit
@@ -1398,7 +1446,6 @@
 129.153.194.228	permit
 129.154.255.129	permit
 129.158.56.255	permit
-129.158.62.153	permit
 129.159.22.159	permit
 129.159.87.137	permit
 129.213.195.191	permit
@@ -1419,8 +1466,21 @@
 134.170.141.64/26	permit
 134.170.143.0/24	permit
 134.170.174.0/24	permit
+135.84.80.0/24	permit
+135.84.81.0/24	permit
+135.84.82.0/24	permit
+135.84.83.0/24	permit
 135.84.216.0/22	permit
-136.146.128.0/20	permit
+136.143.160.0/24	permit
+136.143.161.0/24	permit
+136.143.162.0/24	permit
+136.143.176.0/24	permit
+136.143.177.0/24	permit
+136.143.178.49	permit
+136.143.182.0/23	permit
+136.143.184.0/24	permit
+136.143.188.0/24	permit
+136.143.190.0/23	permit
 136.147.128.0/20	permit
 136.147.135.0/24	permit
 136.147.176.0/20	permit
@@ -1435,10 +1495,9 @@
 139.138.46.219	permit
 139.138.57.55	permit
 139.138.58.119	permit
+139.167.79.86	permit
 139.180.17.0/24	permit
 140.238.148.191	permit
-141.148.55.217	permit
-141.148.91.244	permit
 141.148.159.229	permit
 141.193.32.0/23	permit
 141.193.184.32/27	permit
@@ -1484,7 +1543,6 @@
 149.72.234.184	permit
 149.72.248.236	permit
 149.97.173.180	permit
-150.136.21.199	permit
 150.230.98.160	permit
 151.145.38.14	permit
 152.67.105.195	permit
@@ -1494,7 +1552,20 @@
 155.248.220.138	permit
 155.248.234.149	permit
 155.248.237.141	permit
+157.55.0.192/26	permit
+157.55.1.128/26	permit
+157.55.2.0/25	permit
+157.55.9.128/25	permit
+157.55.11.0/25	permit
+157.55.49.0/25	permit
+157.55.61.0/24	permit
+157.55.157.128/25	permit
+157.55.225.0/25	permit
+157.56.24.0/25	permit
 157.56.120.128/26	permit
+157.56.232.0/21	permit
+157.56.240.0/20	permit
+157.56.248.0/21	permit
 157.58.30.128/25	permit
 157.58.196.96/29	permit
 157.58.249.3	permit
@@ -1544,12 +1615,12 @@
 163.114.135.16	permit
 163.116.128.0/17	permit
 163.192.116.87	permit
-163.192.125.176	permit
-163.192.196.146	permit
-163.192.204.161	permit
 164.152.23.32	permit
 164.152.25.241	permit
 164.177.132.168/30	permit
+165.173.128.0/24	permit
+165.173.180.250/31	permit
+165.173.182.250/31	permit
 166.78.68.0/22	permit
 166.78.68.221	permit
 166.78.69.169	permit
@@ -1579,12 +1650,25 @@
 168.245.12.252	permit
 168.245.46.9	permit
 168.245.127.231	permit
-170.9.232.254	permit
+169.148.129.0/24	permit
+169.148.131.0/24	permit
+169.148.138.0/24	permit
+169.148.142.10	permit
+169.148.142.33	permit
+169.148.144.0/25	permit
+169.148.144.10	permit
+169.148.146.0/23	permit
+169.148.175.3	permit
+169.148.188.0/24	permit
+169.148.188.182	permit
 170.10.128.0/24	permit
 170.10.129.0/24	permit
 170.10.132.56/29	permit
 170.10.132.64/29	permit
 170.10.133.0/24	permit
+172.217.32.0/20	permit
+172.253.56.0/21	permit
+172.253.112.0/20	permit
 173.0.84.0/29	permit
 173.0.84.224/27	permit
 173.0.94.244/30	permit
@@ -1728,7 +1812,6 @@
 194.97.212.12	permit
 194.106.220.0/23	permit
 194.113.24.0/22	permit
-194.113.42.0/26	permit
 194.154.193.192/27	permit
 195.4.92.0/23	permit
 195.54.172.0/23	permit
@@ -1742,7 +1825,6 @@
 198.61.254.21	permit
 198.61.254.231	permit
 198.178.234.57	permit
-198.202.211.1	permit
 198.244.48.0/20	permit
 198.244.56.107	permit
 198.244.56.108	permit
@@ -1764,7 +1846,16 @@
 199.16.156.0/22	permit
 199.33.145.1	permit
 199.33.145.32	permit
+199.34.22.36	permit
 199.59.148.0/22	permit
+199.67.80.2	permit
+199.67.80.20	permit
+199.67.82.2	permit
+199.67.82.20	permit
+199.67.84.0/24	permit
+199.67.86.0/24	permit
+199.67.88.0/24	permit
+199.67.90.0/24	permit
 199.101.161.130	permit
 199.101.162.0/25	permit
 199.122.120.0/21	permit
@@ -1817,9 +1908,12 @@
 204.14.232.64/28	permit
 204.14.234.64/28	permit
 204.75.142.0/24	permit
+204.79.197.212	permit
 204.92.114.187	permit
 204.92.114.203	permit
 204.92.114.204/31	permit
+204.141.32.0/23	permit
+204.141.42.0/23	permit
 204.216.164.202	permit
 204.220.160.0/21	permit
 204.220.168.0/21	permit
@@ -1842,13 +1936,24 @@
 206.165.246.80/29	permit
 206.191.224.0/19	permit
 206.246.157.1	permit
+207.46.4.128/25	permit
 207.46.22.35	permit
 207.46.50.72	permit
 207.46.50.82	permit
+207.46.50.192/26	permit
+207.46.50.224	permit
 207.46.52.71	permit
 207.46.52.79	permit
+207.46.58.128/25	permit
+207.46.116.128/29	permit
+207.46.117.0/24	permit
+207.46.132.128/27	permit
+207.46.198.0/25	permit
+207.46.200.0/27	permit
 207.67.38.0/24	permit
 207.67.98.192/27	permit
+207.68.176.0/26	permit
+207.68.176.96/27	permit
 207.97.204.96/29	permit
 207.126.144.0/20	permit
 207.171.160.0/19	permit
@@ -2003,6 +2108,8 @@
 213.199.128.145	permit
 213.199.138.181	permit
 213.199.138.191	permit
+213.199.161.128/27	permit
+213.199.177.0/26	permit
 216.17.150.242	permit
 216.17.150.251	permit
 216.24.224.0/20	permit
@@ -2030,6 +2137,7 @@
 216.39.62.60/31	permit
 216.39.62.136/29	permit
 216.39.62.144/31	permit
+216.58.192.0/19	permit
 216.66.217.240/29	permit
 216.71.138.33	permit
 216.71.152.207	permit
@@ -2093,6 +2201,9 @@
 2603:1030:20e:3::23c	permit
 2603:1030:b:3::152	permit
 2603:1030:c02:8::14	permit
+2607:13c0:0001:0000:0000:0000:0000:7000/116	permit
+2607:13c0:0002:0000:0000:0000:0000:1000/116	permit
+2607:13c0:0004:0000:0000:0000:0000:0000/116	permit
 2607:f8b0:4000::/36	permit
 2620:109:c003:104::/64	permit
 2620:109:c003:104::215	permit

data/conf/redis/redis-conf.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-
-cat <<EOF > /redis.conf
-requirepass $REDISPASS
-user quota_notify on nopass ~QW_* -@all +get +hget +ping
-EOF
-
-if [ -n "$REDISMASTERPASS" ]; then
-  echo "masterauth $REDISMASTERPASS" >> /redis.conf
-fi
-
-exec redis-server /redis.conf

data/conf/rspamd/dynmaps/aliasexp.php

@@ -22,10 +22,10 @@ catch (PDOException $e) {
   exit;
 }
 
-// Init Redis
-$redis = new Redis();
-$redis->connect('redis-mailcow', 6379);
-$redis->auth(getenv("REDISPASS"));
+// Init Valkey
+$valkey = new Redis();
+$valkey->connect('valkey-mailcow', 6379);
+$valkey->auth(getenv("VALKEYPASS"));
 
 function parse_email($email) {
   if(!filter_var($email, FILTER_VALIDATE_EMAIL)) return false;
@@ -60,7 +60,7 @@ $rcpt_final_mailboxes = array();
 
 // Skip if not a mailcow handled domain
 try {
-  if (!$redis->hGet('DOMAIN_MAP', $parsed_rcpt['domain'])) {
+  if (!$valkey->hGet('DOMAIN_MAP', $parsed_rcpt['domain'])) {
     exit;
   }
 }
@@ -122,7 +122,7 @@ try {
       }
       else {
         $parsed_goto = parse_email($goto);
-        if (!$redis->hGet('DOMAIN_MAP', $parsed_goto['domain'])) {
+        if (!$valkey->hGet('DOMAIN_MAP', $parsed_goto['domain'])) {
           error_log("ALIAS EXPANDER:" . $goto . " is not a mailcow handled mailbox or alias address" . PHP_EOL);
         }
         else {

data/conf/rspamd/dynmaps/forwardinghosts.php

@@ -2,9 +2,9 @@
 header('Content-Type: text/plain');
 ini_set('error_reporting', 0);
 
-$redis = new Redis();
-$redis->connect('redis-mailcow', 6379);
-$redis->auth(getenv("REDISPASS"));
+$valkey = new Redis();
+$valkey->connect('valkey-mailcow', 6379);
+$valkey->auth(getenv("VALKEYPASS"));
 
 function in_net($addr, $net) {
   $net = explode('/', $net);
@@ -31,7 +31,7 @@ function in_net($addr, $net) {
 
 if (isset($_GET['host'])) {
   try {
-    foreach ($redis->hGetAll('WHITELISTED_FWD_HOST') as $host => $source) {
+    foreach ($valkey->hGetAll('WHITELISTED_FWD_HOST') as $host => $source) {
       if (in_net($_GET['host'], $host)) {
         echo '200 PERMIT';
         exit;
@@ -46,7 +46,7 @@ if (isset($_GET['host'])) {
 } else {
   try {
     echo '240.240.240.240' . PHP_EOL;
-    foreach ($redis->hGetAll('WHITELISTED_FWD_HOST') as $host => $source) {
+    foreach ($valkey->hGetAll('WHITELISTED_FWD_HOST') as $host => $source) {
       echo $host . PHP_EOL;
     }
   }

data/conf/rspamd/lua/rspamd.local.lua

@@ -146,171 +146,8 @@ rspamd_config:register_symbol({
       return false
     end
 
-    -- Helper function to parse IPv6 into 8 segments
-    local function ipv6_to_segments(ip_str)
-      -- Remove zone identifier if present (e.g., %eth0)
-      ip_str = ip_str:gsub("%%.*$", "")
-      
-      local segments = {}
-      
-      -- Handle :: compression
-      if ip_str:find('::') then
-        local before, after = ip_str:match('^(.*)::(.*)$')
-        before = before or ''
-        after = after or ''
-        
-        local before_parts = {}
-        local after_parts = {}
-        
-        if before ~= '' then
-          for seg in before:gmatch('[^:]+') do
-            table.insert(before_parts, tonumber(seg, 16) or 0)
-          end
-        end
-        
-        if after ~= '' then
-          for seg in after:gmatch('[^:]+') do
-            table.insert(after_parts, tonumber(seg, 16) or 0)
-          end
-        end
-        
-        -- Add before segments
-        for _, seg in ipairs(before_parts) do
-          table.insert(segments, seg)
-        end
-        
-        -- Add compressed zeros
-        local zeros_needed = 8 - #before_parts - #after_parts
-        for i = 1, zeros_needed do
-          table.insert(segments, 0)
-        end
-        
-        -- Add after segments
-        for _, seg in ipairs(after_parts) do
-          table.insert(segments, seg)
-        end
-      else
-        -- No compression
-        for seg in ip_str:gmatch('[^:]+') do
-          table.insert(segments, tonumber(seg, 16) or 0)
-        end
-      end
-      
-      -- Ensure we have exactly 8 segments
-      while #segments < 8 do
-        table.insert(segments, 0)
-      end
-      
-      return segments
-    end
-
-    -- Generate all common IPv6 notations
-    local function get_ipv6_variants(ip_str)
-      local variants = {}
-      local seen = {}
-      
-      local function add_variant(v)
-        if v and not seen[v] then
-          table.insert(variants, v)
-          seen[v] = true
-        end
-      end
-      
-      -- For IPv4, just return the original
-      if not ip_str:find(':') then
-        add_variant(ip_str)
-        return variants
-      end
-      
-      local segments = ipv6_to_segments(ip_str)
-      
-      -- 1. Fully expanded form (all zeros shown as 0000)
-      local expanded_parts = {}
-      for _, seg in ipairs(segments) do
-        table.insert(expanded_parts, string.format('%04x', seg))
-      end
-      add_variant(table.concat(expanded_parts, ':'))
-      
-      -- 2. Standard form (no leading zeros, but all segments present)
-      local standard_parts = {}
-      for _, seg in ipairs(segments) do
-        table.insert(standard_parts, string.format('%x', seg))
-      end
-      add_variant(table.concat(standard_parts, ':'))
-      
-      -- 3. Find all possible :: compressions
-      -- RFC 5952: compress the longest run of consecutive zeros
-      -- But we need to check all possibilities since Redis might have any form
-      
-      -- Find all zero runs
-      local zero_runs = {}
-      local in_run = false
-      local run_start = 0
-      local run_length = 0
-      
-      for i = 1, 8 do
-        if segments[i] == 0 then
-          if not in_run then
-            in_run = true
-            run_start = i
-            run_length = 1
-          else
-            run_length = run_length + 1
-          end
-        else
-          if in_run then
-            if run_length >= 1 then  -- Allow single zero compression too
-              table.insert(zero_runs, {start = run_start, length = run_length})
-            end
-            in_run = false
-          end
-        end
-      end
-      
-      -- Don't forget the last run
-      if in_run and run_length >= 1 then
-        table.insert(zero_runs, {start = run_start, length = run_length})
-      end
-      
-      -- Generate variant for each zero run compression
-      for _, run in ipairs(zero_runs) do
-        local parts = {}
-        
-        -- Before compression
-        for i = 1, run.start - 1 do
-          table.insert(parts, string.format('%x', segments[i]))
-        end
-        
-        -- The compression
-        if run.start == 1 then
-          table.insert(parts, '')
-          table.insert(parts, '')
-        elseif run.start + run.length - 1 == 8 then
-          table.insert(parts, '')
-          table.insert(parts, '')
-        else
-          table.insert(parts, '')
-        end
-        
-        -- After compression
-        for i = run.start + run.length, 8 do
-          table.insert(parts, string.format('%x', segments[i]))
-        end
-        
-        local compressed = table.concat(parts, ':'):gsub('::+', '::')
-        add_variant(compressed)
-      end
-      
-      return variants
-    end
-
     local from_ip_string = tostring(ip)
-    local ip_check_table = {}
-    
-    -- Add all variants of the exact IP
-    for _, variant in ipairs(get_ipv6_variants(from_ip_string)) do
-      table.insert(ip_check_table, variant)
-    end
+    ip_check_table = {from_ip_string}
 
     local maxbits = 128
     local minbits = 32
@@ -318,18 +155,10 @@ rspamd_config:register_symbol({
         maxbits = 32
         minbits = 8
     end
-    
-    -- Add all CIDR notations with variants
     for i=maxbits,minbits,-1 do
-      local masked_ip = ip:apply_mask(i)
-      local cidr_base = masked_ip:to_string()
-      
-      for _, variant in ipairs(get_ipv6_variants(cidr_base)) do
-        local cidr = variant .. "/" .. i
-        table.insert(ip_check_table, cidr)
-      end
+      local nip = ip:apply_mask(i):to_string() .. "/" .. i
+      table.insert(ip_check_table, nip)
     end
-    
     local function keep_spam_cb(err, data)
       if err then
         rspamd_logger.infox(rspamd_config, "keep_spam query request for ip %s returned invalid or empty data (\"%s\") or error (\"%s\")", ip, data, err)
@@ -337,15 +166,12 @@ rspamd_config:register_symbol({
       else
         for k,v in pairs(data) do
           if (v and v ~= userdata and v == '1') then
-            rspamd_logger.infox(rspamd_config, "found ip %s (checked as: %s) in keep_spam map, setting pre-result accept", from_ip_string, ip_check_table[k])
+            rspamd_logger.infox(rspamd_config, "found ip in keep_spam map, setting pre-result")
             task:set_pre_result('accept', 'ip matched with forward hosts', 'keep_spam')
-            task:set_flag('no_stat')
-            return
           end
         end
       end
     end
-    
     table.insert(ip_check_table, 1, 'KEEP_SPAM')
     local redis_ret_user = rspamd_redis_make_request(task,
       redis_params, -- connect params
@@ -384,7 +210,6 @@ rspamd_config:register_symbol({
 rspamd_config:register_symbol({
   name = 'TAG_MOO',
   type = 'postfilter',
-  flags = 'ignore_passthrough',
   callback = function(task)
     local util = require("rspamd_util")
     local rspamd_logger = require "rspamd_logger"
@@ -393,6 +218,9 @@ rspamd_config:register_symbol({
     local rcpts = task:get_recipients('smtp')
     local lua_util = require "lua_util"
 
+    local tagged_rcpt = task:get_symbol("TAGGED_RCPT")
+    local mailcow_domain = task:get_symbol("RCPT_MAILCOW_DOMAIN")
+
     local function remove_moo_tag()
       local moo_tag_header = task:get_header('X-Moo-Tag', false)
       if moo_tag_header then
@@ -403,149 +231,101 @@ rspamd_config:register_symbol({
       return true
     end
 
-    -- Check if we have exactly one recipient
-    if not (rcpts and #rcpts == 1) then
-      rspamd_logger.infox("TAG_MOO: not exactly one rcpt (%s), removing moo tag", rcpts and #rcpts or 0)
-      remove_moo_tag()
-      return
-    end
+    if tagged_rcpt and tagged_rcpt[1].options and mailcow_domain then
+      local tag = tagged_rcpt[1].options[1]
+      rspamd_logger.infox("found tag: %s", tag)
+      local action = task:get_metric_action('default')
+      rspamd_logger.infox("metric action now: %s", action)
 
-    local rcpt_addr = rcpts[1]['addr']
-    local rcpt_user = rcpts[1]['user']
-    local rcpt_domain = rcpts[1]['domain']
-
-    -- Check if recipient has a tag (contains '+')
-    local tag = nil
-    if rcpt_user:find('%+') then
-      local base_user, tag_part = rcpt_user:match('^(.-)%+(.+)$')
-      if base_user and tag_part then
-        tag = tag_part
-        rspamd_logger.infox("TAG_MOO: found tag in recipient: %s (base: %s, tag: %s)", rcpt_addr, base_user, tag)
+      if action ~= 'no action' and action ~= 'greylist' then
+        rspamd_logger.infox("skipping tag handler for action: %s", action)
+        remove_moo_tag()
+        return true
       end
-    end
 
-    if not tag then
-      rspamd_logger.infox("TAG_MOO: no tag found in recipient %s, removing moo tag", rcpt_addr)
-      remove_moo_tag()
-      return
-    end
+      local function http_callback(err_message, code, body, headers)
+        if body ~= nil and body ~= "" then
+          rspamd_logger.infox(rspamd_config, "expanding rcpt to \"%s\"", body)
 
-    -- Optional: Check if domain is a mailcow domain
-    -- When KEEP_SPAM is active, RCPT_MAILCOW_DOMAIN might not be set
-    -- If the mail is being delivered, we can assume it's valid
-    local mailcow_domain = task:get_symbol("RCPT_MAILCOW_DOMAIN")
-    if not mailcow_domain then
-      rspamd_logger.infox("TAG_MOO: RCPT_MAILCOW_DOMAIN not set (possibly due to pre-result), proceeding anyway for domain %s", rcpt_domain)
-    end
+          local function tag_callback_subject(err, data)
+            if err or type(data) ~= 'string' then
+              rspamd_logger.infox(rspamd_config, "subject tag handler rcpt %s returned invalid or empty data (\"%s\") or error (\"%s\") - trying subfolder tag handler...", body, data, err)
 
-    local action = task:get_metric_action('default')
-    rspamd_logger.infox("TAG_MOO: metric action: %s", action)
+              local function tag_callback_subfolder(err, data)
+                if err or type(data) ~= 'string' then
+                  rspamd_logger.infox(rspamd_config, "subfolder tag handler for rcpt %s returned invalid or empty data (\"%s\") or error (\"%s\")", body, data, err)
+                  remove_moo_tag()
+                else
+                  rspamd_logger.infox("Add X-Moo-Tag header")
+                  task:set_milter_reply({
+                    add_headers = {['X-Moo-Tag'] = 'YES'}
+                  })
+                end
+              end
+
+              local redis_ret_subfolder = rspamd_redis_make_request(task,
+                redis_params, -- connect params
+                body, -- hash key
+                false, -- is write
+                tag_callback_subfolder, --callback
+                'HGET', -- command
+                {'RCPT_WANTS_SUBFOLDER_TAG', body} -- arguments
+              )
+              if not redis_ret_subfolder then
+                rspamd_logger.infox(rspamd_config, "cannot make request to load tag handler for rcpt")
+                remove_moo_tag()
+              end
+
+            else
+              rspamd_logger.infox("user wants subject modified for tagged mail")
+              local sbj = task:get_header('Subject')
+              new_sbj = '=?UTF-8?B?' .. tostring(util.encode_base64('[' .. tag .. '] ' .. sbj)) .. '?='
+              task:set_milter_reply({
+                remove_headers = {
+                  ['Subject'] = 1,
+                  ['X-Moo-Tag'] = 0
+                },
+                add_headers = {['Subject'] = new_sbj}
+              })
+            end
+          end
+
+          local redis_ret_subject = rspamd_redis_make_request(task,
+            redis_params, -- connect params
+            body, -- hash key
+            false, -- is write
+            tag_callback_subject, --callback
+            'HGET', -- command
+            {'RCPT_WANTS_SUBJECT_TAG', body} -- arguments
+          )
+          if not redis_ret_subject then
+            rspamd_logger.infox(rspamd_config, "cannot make request to load tag handler for rcpt")
+            remove_moo_tag()
+          end
 
-    -- Check if we have a pre-result (e.g., from KEEP_SPAM or POSTMASTER_HANDLER)
-    local allow_processing = false
-    
-    if task.has_pre_result then
-      local has_pre, pre_action = task:has_pre_result()
-      if has_pre then
-        rspamd_logger.infox("TAG_MOO: pre-result detected: %s", tostring(pre_action))
-        if pre_action == 'accept' then
-          allow_processing = true
-          rspamd_logger.infox("TAG_MOO: pre-result is accept, will process")
         end
       end
-    end
 
-    -- Allow processing for mild actions or when we have pre-result accept
-    if not allow_processing and action ~= 'no action' and action ~= 'greylist' then
-      rspamd_logger.infox("TAG_MOO: skipping tag handler for action: %s", action)
-      remove_moo_tag()
-      return true
-    end
-
-    rspamd_logger.infox("TAG_MOO: processing allowed")
-
-    local function http_callback(err_message, code, body, headers)
-      if body ~= nil and body ~= "" then
-        rspamd_logger.infox(rspamd_config, "TAG_MOO: expanding rcpt to \"%s\"", body)
-
-        local function tag_callback_subject(err, data)
-          if err or type(data) ~= 'string' or data == '' then
-            rspamd_logger.infox(rspamd_config, "TAG_MOO: subject tag handler rcpt %s returned invalid or empty data (\"%s\") or error (\"%s\") - trying subfolder tag handler...", body, data, err)
-
-            local function tag_callback_subfolder(err, data)
-              if err or type(data) ~= 'string' or data == '' then
-                rspamd_logger.infox(rspamd_config, "TAG_MOO: subfolder tag handler for rcpt %s returned invalid or empty data (\"%s\") or error (\"%s\")", body, data, err)
-                remove_moo_tag()
-              else
-                rspamd_logger.infox("TAG_MOO: User wants subfolder tag, adding X-Moo-Tag header")
-                task:set_milter_reply({
-                  add_headers = {['X-Moo-Tag'] = 'YES'}
-                })
-              end
-            end
-
-            local redis_ret_subfolder = rspamd_redis_make_request(task,
-              redis_params, -- connect params
-              body, -- hash key
-              false, -- is write
-              tag_callback_subfolder, --callback
-              'HGET', -- command
-              {'RCPT_WANTS_SUBFOLDER_TAG', body} -- arguments
-            )
-            if not redis_ret_subfolder then
-              rspamd_logger.infox(rspamd_config, "TAG_MOO: cannot make request to load tag handler for rcpt")
+      if rcpts and #rcpts == 1 then
+        for _,rcpt in ipairs(rcpts) do
+          local rcpt_split = rspamd_str_split(rcpt['addr'], '@')
+          if #rcpt_split == 2 then
+            if rcpt_split[1] == 'postmaster' then
+              rspamd_logger.infox(rspamd_config, "not expanding postmaster alias")
               remove_moo_tag()
+            else
+              rspamd_http.request({
+                task=task,
+                url='http://nginx:8081/aliasexp.php',
+                body='',
+                callback=http_callback,
+                headers={Rcpt=rcpt['addr']},
+              })
             end
-
-          else
-            rspamd_logger.infox("TAG_MOO: user wants subject modified for tagged mail")
-            local sbj = task:get_header('Subject') or ''
-            new_sbj = '=?UTF-8?B?' .. tostring(util.encode_base64('[' .. tag .. '] ' .. sbj)) .. '?='
-            task:set_milter_reply({
-              remove_headers = {
-                ['Subject'] = 1,
-                ['X-Moo-Tag'] = 0
-              },
-              add_headers = {['Subject'] = new_sbj}
-            })
           end
         end
-
-        local redis_ret_subject = rspamd_redis_make_request(task,
-          redis_params, -- connect params
-          body, -- hash key
-          false, -- is write
-          tag_callback_subject, --callback
-          'HGET', -- command
-          {'RCPT_WANTS_SUBJECT_TAG', body} -- arguments
-        )
-        if not redis_ret_subject then
-          rspamd_logger.infox(rspamd_config, "TAG_MOO: cannot make request to load tag handler for rcpt")
-          remove_moo_tag()
-        end
-      else
-        rspamd_logger.infox("TAG_MOO: alias expansion returned empty body")
-        remove_moo_tag()
-      end
-    end
-
-    local rcpt_split = rspamd_str_split(rcpt_addr, '@')
-    if #rcpt_split == 2 then
-      if rcpt_split[1]:match('^postmaster') then
-        rspamd_logger.infox(rspamd_config, "TAG_MOO: not expanding postmaster alias")
-        remove_moo_tag()
-      else
-        rspamd_logger.infox("TAG_MOO: requesting alias expansion for %s", rcpt_addr)
-        rspamd_http.request({
-          task=task,
-          url='http://nginx:8081/aliasexp.php',
-          body='',
-          callback=http_callback,
-          headers={Rcpt=rcpt_addr},
-        })
       end
     else
-      rspamd_logger.infox("TAG_MOO: invalid rcpt format")
       remove_moo_tag()
     end
   end,
@@ -555,7 +335,6 @@ rspamd_config:register_symbol({
 rspamd_config:register_symbol({
   name = 'BCC',
   type = 'postfilter',
-  flags = 'ignore_passthrough',
   callback = function(task)
     local util = require("rspamd_util")
     local rspamd_http = require "rspamd_http"
@@ -584,13 +363,11 @@ rspamd_config:register_symbol({
       local email_content = tostring(task:get_content())
       email_content = string.gsub(email_content, "\r\n%.", "\r\n..")
       -- send mail
-      local from_smtp = task:get_from('smtp')
-      local from_addr = (from_smtp and from_smtp[1] and from_smtp[1].addr) or 'mailer-daemon@localhost'
       lua_smtp.sendmail({
         task = task,
         host = os.getenv("IPV4_NETWORK") .. '.253',
         port = 591,
-        from = from_addr,
+        from = task:get_from(stp)[1].addr,
         recipients = bcc_dest,
         helo = 'bcc',
         timeout = 20,
@@ -620,41 +397,27 @@ rspamd_config:register_symbol({
     end
 
     local action = task:get_metric_action('default')
-    rspamd_logger.infox("BCC: metric action: %s", action)
-
-    -- Check for pre-result accept (e.g., from KEEP_SPAM)
-    local allow_bcc = false
-    if task.has_pre_result then
-      local has_pre, pre_action = task:has_pre_result()
-      if has_pre and pre_action == 'accept' then
-        allow_bcc = true
-        rspamd_logger.infox("BCC: pre-result accept detected, will send BCC")
-      end
-    end
-
-    -- Allow BCC for mild actions or when we have pre-result accept
-    if not allow_bcc and action ~= 'no action' and action ~= 'add header' and action ~= 'rewrite subject' then
-      rspamd_logger.infox("BCC: skipping for action: %s", action)
-      return
-    end
+    rspamd_logger.infox("metric action now: %s", action)
 
     local function rcpt_callback(err_message, code, body, headers)
       if err_message == nil and code == 201 and body ~= nil then
-        rspamd_logger.infox("BCC: sending BCC to %s for rcpt match", body)
-        send_mail(task, body)
+        if action == 'no action' or action == 'add header' or action == 'rewrite subject' then
+          send_mail(task, body)
+        end
       end
     end
 
     local function from_callback(err_message, code, body, headers)
       if err_message == nil and code == 201 and body ~= nil then
-        rspamd_logger.infox("BCC: sending BCC to %s for from match", body)
-        send_mail(task, body)
+        if action == 'no action' or action == 'add header' or action == 'rewrite subject' then
+          send_mail(task, body)
+        end
       end
     end
 
     if rcpt_table then
       for _,e in ipairs(rcpt_table) do
-        rspamd_logger.infox(rspamd_config, "BCC: checking bcc for rcpt address %s", e)
+        rspamd_logger.infox(rspamd_config, "checking bcc for rcpt address %s", e)
         rspamd_http.request({
           task=task,
           url='http://nginx:8081/bcc.php',
@@ -667,7 +430,7 @@ rspamd_config:register_symbol({
 
     if from_table then
       for _,e in ipairs(from_table) do
-        rspamd_logger.infox(rspamd_config, "BCC: checking bcc for from address %s", e)
+        rspamd_logger.infox(rspamd_config, "checking bcc for from address %s", e)
         rspamd_http.request({
           task=task,
           url='http://nginx:8081/bcc.php',
@@ -678,7 +441,7 @@ rspamd_config:register_symbol({
       end
     end
 
-    -- Don't return true to avoid symbol being logged
+    return true
   end,
   priority = 20
 })
@@ -945,4 +708,4 @@ rspamd_config:register_symbol({
     return true
   end,
   priority = 1
-})
+})

data/conf/rspamd/meta_exporter/pipe.php

@@ -21,10 +21,10 @@ catch (PDOException $e) {
   http_response_code(501);
   exit;
 }
-// Init Redis
-$redis = new Redis();
-$redis->connect('redis-mailcow', 6379);
-$redis->auth(getenv("REDISPASS"));
+// Init Valkey
+$valkey = new Redis();
+$valkey->connect('valkey-mailcow', 6379);
+$valkey->auth(getenv("VALKEYPASS"));
 
 // Functions
 function parse_email($email) {
@@ -74,16 +74,16 @@ if ($fuzzy == 'unknown') {
 }
 
 try {
-  $max_size = (int)$redis->Get('Q_MAX_SIZE');
+  $max_size = (int)$valkey->Get('Q_MAX_SIZE');
   if (($max_size * 1048576) < $raw_size) {
     error_log(sprintf("QUARANTINE: Message too large: %d b exceeds %d b", $raw_size, ($max_size * 1048576)) . PHP_EOL);
     http_response_code(505);
     exit;
   }
-  if ($exclude_domains = $redis->Get('Q_EXCLUDE_DOMAINS')) {
+  if ($exclude_domains = $valkey->Get('Q_EXCLUDE_DOMAINS')) {
     $exclude_domains = json_decode($exclude_domains, true);
   }
-  $retention_size = (int)$redis->Get('Q_RETENTION_SIZE');
+  $retention_size = (int)$valkey->Get('Q_RETENTION_SIZE');
 }
 catch (RedisException $e) {
   error_log("QUARANTINE: " . $e . PHP_EOL);
@@ -103,7 +103,7 @@ foreach (json_decode($rcpts, true) as $rcpt) {
 
   // Skip if not a mailcow handled domain
   try {
-    if (!$redis->hGet('DOMAIN_MAP', $parsed_rcpt['domain'])) {
+    if (!$valkey->hGet('DOMAIN_MAP', $parsed_rcpt['domain'])) {
       continue;
     }
   }
@@ -171,7 +171,7 @@ foreach (json_decode($rcpts, true) as $rcpt) {
         }
         else {
           $parsed_goto = parse_email($goto);
-          if (!$redis->hGet('DOMAIN_MAP', $parsed_goto['domain'])) {
+          if (!$valkey->hGet('DOMAIN_MAP', $parsed_goto['domain'])) {
             error_log("RCPT RESOVLER:" . $goto . " is not a mailcow handled mailbox or alias address" . PHP_EOL);
           }
           else {

data/conf/rspamd/meta_exporter/pipe_rl.php

@@ -5,16 +5,16 @@ header('Content-Type: text/plain');
 require_once "vars.inc.php";
 // Do not show errors, we log to using error_log
 ini_set('error_reporting', 0);
-// Init Redis
-$redis = new Redis();
+// Init Valkey
+$valkey = new Redis();
 try {
-  if (!empty(getenv('REDIS_SLAVEOF_IP'))) {
-    $redis->connect(getenv('REDIS_SLAVEOF_IP'), getenv('REDIS_SLAVEOF_PORT'));
+  if (!empty(getenv('VALKEY_SLAVEOF_IP'))) {
+    $valkey->connect(getenv('VALKEY_SLAVEOF_IP'), getenv('VALKEY_SLAVEOF_PORT'));
   }
   else {
-    $redis->connect('redis-mailcow', 6379);
+    $valkey->connect('valkey-mailcow', 6379);
   }
-  $redis->auth(getenv("REDISPASS"));
+  $valkey->auth(getenv("VALKEYPASS"));
 }
 catch (Exception $e) {
   exit;
@@ -44,6 +44,6 @@ $data['message_id'] = $raw_data_decoded['message_id'];
 $data['header_subject'] = implode(' ', $raw_data_decoded['header_subject']);
 $data['header_from'] = implode(', ', $raw_data_decoded['header_from']);
 
-$redis->lpush('RL_LOG', json_encode($data));
+$valkey->lpush('RL_LOG', json_encode($data));
 exit;
 

data/conf/rspamd/meta_exporter/pushover.php

@@ -21,10 +21,10 @@ catch (PDOException $e) {
   http_response_code(501);
   exit;
 }
-// Init Redis
-$redis = new Redis();
-$redis->connect('redis-mailcow', 6379);
-$redis->auth(getenv("REDISPASS"));
+// Init Valkey
+$valkey = new Redis();
+$valkey->connect('valkey-mailcow', 6379);
+$valkey->auth(getenv("VALKEYPASS"));
 
 // Functions
 function parse_email($email) {
@@ -94,7 +94,7 @@ foreach (json_decode($rcpts, true) as $rcpt) {
 
   // Skip if not a mailcow handled domain
   try {
-    if (!$redis->hGet('DOMAIN_MAP', $parsed_rcpt['domain'])) {
+    if (!$valkey->hGet('DOMAIN_MAP', $parsed_rcpt['domain'])) {
       continue;
     }
   }
@@ -156,7 +156,7 @@ foreach (json_decode($rcpts, true) as $rcpt) {
         }
         else {
           $parsed_goto = parse_email($goto);
-          if (!$redis->hGet('DOMAIN_MAP', $parsed_goto['domain'])) {
+          if (!$valkey->hGet('DOMAIN_MAP', $parsed_goto['domain'])) {
             error_log("RCPT RESOVLER:" . $goto . " is not a mailcow handled mailbox or alias address" . PHP_EOL);
           }
           else {

data/conf/sogo/sogo.conf

@@ -86,12 +86,6 @@
     SOGoMaximumFailedLoginInterval = 900;
     SOGoFailedLoginBlockInterval = 900;
 
-    // Enable SOGo URL Description for GDPR compliance, this may cause some issues with calendars and contacts. Also uncomment the encryption key below to use it.
-    //SOGoURLEncryptionEnabled = NO;
-
-    // Set a 16 character encryption key for SOGo URL Description, change this to your own value
-    //SOGoURLPathEncryptionKey = "SOGoSuperSecret0";
-
     GCSChannelCollectionTimer = 60;
     GCSChannelExpireAge = 60;
 

data/conf/valkey/valkey-conf.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+cat <<EOF > /valkey.conf
+requirepass $VALKEYPASS
+user quota_notify on nopass ~QW_* -@all +get +hget +ping
+EOF
+
+if [ -n "$VALKEYMASTERPASS" ]; then
+  echo "masterauth $VALKEYMASTERPASS" >> /valkey.conf
+fi
+
+exec "$@"

data/web/_rspamderror.php

@@ -1,13 +1,13 @@
 <?php
-$redis = new Redis();
+$valkey = new Redis();
 try {
-  if (!empty(getenv('REDIS_SLAVEOF_IP'))) {
-    $redis->connect(getenv('REDIS_SLAVEOF_IP'), getenv('REDIS_SLAVEOF_PORT'));
+  if (!empty(getenv('VALKEY_SLAVEOF_IP'))) {
+    $valkey->connect(getenv('VALKEY_SLAVEOF_IP'), getenv('VALKEY_SLAVEOF_PORT'));
   }
   else {
-    $redis->connect('redis-mailcow', 6379);
+    $valkey->connect('valkey-mailcow', 6379);
   }
-  $redis->auth(getenv("REDISPASS"));
+  $valkey->auth(getenv("VALKEYPASS"));
 }
 catch (Exception $e) {
   exit;
@@ -15,4 +15,4 @@ catch (Exception $e) {
 header('Content-Type: application/json');
 echo '{"error":"Unauthorized"}';
 error_log("Rspamd UI: Invalid password by " . $_SERVER['REMOTE_ADDR']);
-$redis->publish("F2B_CHANNEL", "Rspamd UI: Invalid password by " . $_SERVER['REMOTE_ADDR']);
+$valkey->publish("F2B_CHANNEL", "Rspamd UI: Invalid password by " . $_SERVER['REMOTE_ADDR']);