diff --git a/bin/podman_shared b/bin/podman_shared
index 70e6f6a2..b2eb6aa3 100644
--- a/bin/podman_shared
+++ b/bin/podman_shared
@@ -1,268 +1,277 @@
 #!/bin/bash
 
 PODMAN=podman
 
 
 podman__build() {
     path=$1
     shift
     name=$1
     shift
     if [[ "$CACHE_REGISTRY" != "" ]]; then
         CACHE_ARGS="--layers --cache-from=$CACHE_REGISTRY/$name --cache-to=$CACHE_REGISTRY/$name --cache-ttl=24h"
     fi
     podman build $@ $CACHE_ARGS $path -t $name
 }
 
 podman__build_base() {
     podman__build docker/base/ apheleia/almalinux9 -f almalinux9
     podman__build docker/swoole apheleia/swoole
 }
 
 podman__build_webapp() {
     podman__build docker/webapp kolab-webapp --ulimit nofile=65535:65535 \
         ${KOLAB_GIT_REMOTE:+"--build-arg=GIT_REMOTE=$KOLAB_GIT_REMOTE"} \
         ${KOLAB_GIT_REF:+"--build-arg=GIT_REF=$KOLAB_GIT_REF"}
 }
 
 podman__build_meet() {
     podman__build docker/meet kolab-meet --ulimit nofile=65535:65535 \
         ${KOLAB_GIT_REMOTE:+"--build-arg=GIT_REMOTE=$KOLAB_GIT_REMOTE"} \
         ${KOLAB_GIT_REF:+"--build-arg=GIT_REF=$KOLAB_GIT_REF"}
 }
 
 podman__build_roundcube() {
     podman__build docker/roundcube roundcube --ulimit nofile=65535:65535 \
         ${GIT_REMOTE_ROUNDCUBEMAIL:+"--build-arg=GIT_REMOTE_ROUNDCUBEMAIL=$GIT_REMOTE_ROUNDCUBEMAIL"} \
         ${GIT_REF_ROUNDCUBEMAIL:+"--build-arg=GIT_REF_ROUNDCUBEMAIL=$GIT_REF_ROUNDCUBEMAIL"} \
         ${GIT_REMOTE_ROUNDCUBEMAIL_PLUGINS:+"--build-arg=GIT_REMOTE_ROUNDCUBEMAIL_PLUGINS=$GIT_REMOTE_ROUNDCUBEMAIL_PLUGINS"} \
         ${GIT_REF_ROUNDCUBEMAIL_PLUGINS:+"--build-arg=GIT_REF_ROUNDCUBEMAIL_PLUGINS=$GIT_REF_ROUNDCUBEMAIL_PLUGINS"} \
         ${GIT_REMOTE_CHWALA:+"--build-arg=GIT_REMOTE_CHWALA=$GIT_REMOTE_CHWALA"} \
         ${GIT_REF_CHWALA:+"--build-arg=GIT_REF_CHWALA=$GIT_REF_CHWALA"} \
         ${GIT_REMOTE_SYNCROTON:+"--build-arg=GIT_REMOTE_SYNCROTON=$GIT_REMOTE_SYNCROTON"} \
         ${GIT_REF_SYNCROTON:+"--build-arg=GIT_REF_SYNCROTON=$GIT_REF_SYNCROTON"} \
         ${GIT_REMOTE_AUTOCONF:+"--build-arg=GIT_REMOTE_AUTOCONF=$GIT_REMOTE_AUTOCONF"} \
         ${GIT_REF_AUTOCONF:+"--build-arg=GIT_REF_AUTOCONF=$GIT_REF_AUTOCONF"} \
         ${GIT_REMOTE_IRONY:+"--build-arg=GIT_REMOTE_IRONY=$GIT_REMOTE_IRONY"} \
         ${GIT_REF_IRONY:+"--build-arg=GIT_REF_IRONY=$GIT_REF_IRONY"} \
         ${GIT_REMOTE_FREEBUSY:+"--build-arg=GIT_REMOTE_FREEBUSY=$GIT_REMOTE_FREEBUSY"} \
         ${GIT_REF_FREEBUSY:+"--build-arg=GIT_REF_FREEBUSY=$GIT_REF_FREEBUSY"}
 }
 
 podman__build_postfix() {
     podman__build docker/postfix kolab-postfix
 }
 
 podman__build_all() {
     podman__build_base
     podman__build_webapp
     podman__build_meet
     podman build docker/postfix -t kolab-postfix
     podman build docker/imap -t kolab-imap
         ${IMAP_GIT_REMOTE:+"--build-arg=GIT_REMOTE=$IMAP_GIT_REMOTE"} \
         ${IMAP_GIT_REF:+"--build-arg=GIT_REF=$IMAP_GIT_REF"}
     podman build docker/amavis -t kolab-amavis
     podman build docker/collabora -t kolab-collabora --build-arg=REPOSITORY="https://www.collaboraoffice.com/repos/CollaboraOnline/23.05-CODE/CODE-rpm/"
     podman build docker/mariadb -t mariadb
     podman build docker/redis -t redis
     podman build docker/proxy -t kolab-proxy
     podman build docker/coturn -t kolab-coturn
     podman build docker/utils -t kolab-utils
     podman build docker/fluentbit -t fluentbit
     podman__build_roundcube
 }
 
 kolab__validate() {
     POD=$1
     $PODMAN exec $POD-imap testsaslauthd -u cyrus-admin -p simple123
     $PODMAN exec $POD-imap testsaslauthd -u "john@kolab.org" -p simple123
     # Ensure the inbox is created
     FOUND=false
     for i in {1..60}; do
         if $PODMAN exec $POD-imap bash -c 'echo "lm" | cyradm --auth PLAIN -u cyrus-admin -w simple123 --port 11143 localhost | grep "user/john@kolab.org"'; then
             echo "Found mailbox";
             FOUND=true
             break
         else
             echo "Waiting for mailbox";
             sleep 1;
         fi
     done
     if ! $FOUND; then
         echo "Failed to find the inbox for john@kolab.org"
         exit 1
     fi
 }
 
+podman__is_ready() {
+    if [[ "$(timeout 5 podman wait --condition running $1)" != "-1" ]]; then
+        echo "Container $1 is not running"
+        return 1
+    fi
+    # We can only wait for healthy if healthcheck is available
+    return 0
+}
+
 podman__healthcheck() {
     for CONTAINER in $@; do
         echo "Waiting for ${CONTAINER} become healthy "
         while [ $(podman healthcheck run ${CONTAINER}) ]; do
             echo -n "."; sleep 5;
         done
     done
 }
 
 podman__run_proxy() {
     $PODMAN run -dt --pod $POD --name $POD-proxy --replace \
         -v $CERTS_PATH:/etc/certs:ro \
         -e APP_WEBSITE_DOMAIN \
         -e SSL_CERTIFICATE="/etc/certs/imap.hosted.com.cert" \
         -e SSL_CERTIFICATE_KEY="/etc/certs/imap.hosted.com.key" \
         -e WEBAPP_BACKEND="http://localhost:8000" \
         -e MEET_BACKEND="https://localhost:12443" \
         -e ROUNDCUBE_BACKEND="http://localhost:8080" \
         -e DAV_BACKEND="http://localhost:11080/dav" \
         -e COLLABORA_BACKEND="http://localhost:9980" \
         -e MATRIX_BACKEND="http://localhost:8008" \
         -e ELEMENT_BACKEND="http://localhost:8880" \
         -e SIEVE_BACKEND="localhost:4190" \
         kolab-proxy:latest
 }
 
 podman__run_roundcube() {
     $PODMAN run -dt --pod $POD --name $POD-roundcube --replace \
         -v ./ext:/src.orig:ro \
         -e APP_DOMAIN \
         -e DES_KEY \
         -e DB_HOST \
         -e DB_RC_DATABASE="roundcube" \
         -e DB_RC_USERNAME="roundcube" \
         -e DB_RC_PASSWORD="${DB_PASSWORD:?"missing env variable"}" \
         -e IMAP_HOST \
         -e IMAP_PORT \
         -e IMAP_ADMIN_LOGIN \
         -e IMAP_ADMIN_PASSWORD \
         -e MAIL_HOST \
         -e MAIL_PORT \
         -e IMAP_DEBUG \
         -e KOLAB_FILES_SERVER_URL=http://localhost:8080/chwala \
         -e FILEAPI_WOPI_OFFICE=http://localhost:9980 \
         -e FILEAPI_KOLABFILES_BASEURI=http://localhost:8000/api \
         -e FILE_API_SERVER_URL=http://localhost:8080/chwala/api/ \
         -e KOLAB_ADDRESSBOOK_CARDDAV_SERVER=http://localhost:11080/dav \
         -e CALENDAR_CALDAV_SERVER=http://localhost:11080/dav \
         -e TASKLIST_CALDAV_SERVER=http://localhost:11080/dav \
         roundcube:latest
 }
 
 podman__run_mariadb() {
     $PODMAN run -dt --pod $POD --name $POD-mariadb --replace \
          $MARIADB_STORAGE \
         -e MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD:?"missing env variable"} \
         -e TZ="+02:00" \
         -e DB_HKCCP_DATABASE="kolabdev" \
         -e DB_HKCCP_USERNAME="kolabdev" \
         -e DB_HKCCP_PASSWORD=${DB_PASSWORD:?"missing env variable"} \
         -e DB_KOLAB_DATABASE="kolab" \
         -e DB_KOLAB_USERNAME="kolab" \
         -e DB_KOLAB_PASSWORD=${DB_PASSWORD:?"missing env variable"} \
         -e DB_RC_DATABASE="roundcube" \
         -e DB_RC_USERNAME="roundcube" \
         -e DB_RC_PASSWORD=${DB_PASSWORD:?"missing env variable"} \
         --health-cmd "mysqladmin -u root ping && test -e /tmp/initialized" \
         mariadb:latest
 }
 
 podman__run_redis() {
     $PODMAN run -dt --pod $POD --name $POD-redis --replace \
         $REDIS_STORAGE \
         --health-cmd "redis-cli ping || exit 1" \
         redis:latest
 }
 
 podman__run_minio() {
     $PODMAN run -dt --pod $POD --name $POD-minio --replace \
         $MINIO_STORAGE \
         -e MINIO_ROOT_USER=${MINIO_USER:?"missing env variable"} \
         -e MINIO_ROOT_PASSWORD=${MINIO_PASSWORD:?"missing env variable"} \
         --health-cmd "mc ready local || exit 1" \
         --entrypoint sh \
         quay.io/minio/minio:latest -c 'mkdir -p /data/kolab && minio server /data --console-address ":9001"'
 }
 
 podman__run_webapp() {
     # We run with a fixed config.demo overlay and override the environment with ci/env
     $PODMAN run -dt --pod $POD --name $POD-webapp --replace \
         --env-file=$1 \
         -v ./src:/src/kolabsrc.orig:ro \
         -v ./$2/src:/src/overlay:ro \
         -e NOENVFILE=true \
         -e APP_SERVICES_ALLOWED_DOMAINS="webapp,localhost,services.$HOST" \
         -e KOLAB_ROLE=combined \
         -e PASSPORT_PRIVATE_KEY="$PASSPORT_PRIVATE_KEY" \
         -e PASSPORT_PUBLIC_KEY="$PASSPORT_PUBLIC_KEY" \
         -e MINIO_ENDPOINT="http://localhost:9000" \
         --health-cmd "./artisan octane:status || exit 1" \
         kolab-webapp:latest
 }
 
 podman__run_imap() {
     $PODMAN run -dt --pod $POD --name $POD-imap --replace \
         $IMAP_SPOOL_STORAGE \
         $IMAP_LIB_STORAGE \
         -e APP_SERVICES_DOMAIN="localhost" \
         -e SERVICES_PORT=8000 \
         -e IMAP_ADMIN_LOGIN \
         -e IMAP_ADMIN_PASSWORD \
         --health-cmd "test -e /run/saslauthd/mux && kill -0 \$(cat /var/run/master.pid)" \
         kolab-imap:latest
 }
 
 podman__run_postfix() {
     $PODMAN run -dt --pod $POD --name $POD-postfix --replace \
         --privileged \
         $POSTFIX_SPOOL_STORAGE \
         $POSTFIX_LIB_STORAGE \
         -v $CERTS_PATH:/etc/certs:ro \
         -e SSL_CERTIFICATE="$KOLAB_SSL_CERTIFICATE" \
         -e SSL_CERTIFICATE_FULLCHAIN="$KOLAB_SSL_CERTIFICATE_FULLCHAIN" \
         -e SSL_CERTIFICATE_KEY="$KOLAB_SSL_CERTIFICATE_KEY" \
         -e APP_DOMAIN \
         -e APP_SERVICES_DOMAIN="localhost" \
         -e SERVICES_PORT=8000 \
         -e AMAVIS_HOST=127.0.0.1 \
         -e DB_HOST=127.0.0.1 \
         -e DB_USERNAME \
         -e DB_PASSWORD \
         -e DB_DATABASE \
         -e LMTP_DESTINATION="localhost:11024" \
         --health-cmd "test -e /run/saslauthd/mux && kill -0 \$(cat /var/spool/postfix/pid/master.pid)" \
         kolab-postfix:latest
 }
 
 podman__run_amavis() {
     $PODMAN run -dt --pod $POD --name $POD-amavis --replace \
         -e DB_HOST=localhost \
         -e DB_USERNAME \
         -e DB_PASSWORD \
         -e DB_DATABASE \
         kolab-amavis:latest
 }
 
 podman__run_collabora() {
     $PODMAN run -dt --pod $POD --name $POD-collabora --replace \
         --privileged \
         -e ALLOWED_HOSTS=${APP_DOMAIN} \
         kolab-collabora:latest
 }
 
 podman__run_meet() {
     $PODMAN run -dt --pod $POD --name $POD-meet --replace \
         -v ./meet/server:/src/meet:ro \
         -v $CERTS_PATH/meet.${APP_DOMAIN}.cert:/etc/pki/tls/certs/meet.${APP_DOMAIN}.cert \
         -v $CERTS_PATH/meet.${APP_DOMAIN}.key:/etc/pki/tls/private/meet.${APP_DOMAIN}.key \
         -e WEBRTC_LISTEN_IP=127.0.0.1 \
         -e WEBRTC_ANNOUNCED_ADDRESS=127.0.0.1 \
         -e PUBLIC_DOMAIN=$APP_DOMAIN \
         -e LISTENING_HOST=127.0.0.1 \
         -e LISTENING_PORT=12443 \
         -e DEBUG="*" \
         -e TURN_SERVER=none \
         -e AUTH_TOKEN=${MEET_SERVER_TOKEN} \
         -e WEBHOOK_TOKEN=${MEET_WEBHOOK_TOKEN} \
         -e WEBHOOK_URL=$APP_DOMAIN/api/webhooks/meet \
         -e SSL_CERT=/etc/pki/tls/certs/meet.$APP_DOMAIN.cert \
         -e SSL_KEY=/etc/pki/tls/private/meet.$APP_DOMAIN.key \
         kolab-meet:latest
 }
diff --git a/kolabctl b/kolabctl
index 43f98f6c..175a0edf 100755
--- a/kolabctl
+++ b/kolabctl
@@ -1,401 +1,412 @@
 #!/bin/bash
 
 set -e
 
 CONFIG=${CONFIG:-"config.prod"}
 export HOST=${HOST:-"kolab.local"}
 OPENEXCHANGERATES_API_KEY=${OPENEXCHANGERATES_API_KEY}
 FIREBASE_API_KEY=${FIREBASE_API_KEY}
 PUBLIC_IP=${PUBLIC_IP}
 
 export CERTS_PATH=./docker/certs
 
 export POD=kolab-prod
 export IMAP_SPOOL_STORAGE="--mount=type=volume,src=$POD-imap-spool,destination=/var/spool/imap,U=true"
 export IMAP_LIB_STORAGE="--mount=type=volume,src=$POD-imap-lib,destination=/var/lib/imap,U=true"
 export POSTFIX_SPOOL_STORAGE="--mount=type=volume,src=$POD-postfix-spool,destination=/var/spool/imap,U=true"
 export POSTFIX_LIB_STORAGE="--mount=type=volume,src=$POD-postfix-lib,destination=/var/lib/imap,U=true"
 export MARIADB_STORAGE="--mount=type=volume,src=$POD-mariadb-data,destination=/var/lib/mysql,U=true"
 export REDIS_STORAGE="--mount=type=volume,src=$POD-redis-data,destination=/var/lib/redis,U=true"
 export MINIO_STORAGE="--mount=type=volume,src=$POD-minio-data,destination=/data,U=true"
 
 export PODMAN_IGNORE_CGROUPSV1_WARNING=true
 
 source bin/podman_shared
 
 
 __export_env() {
     source src/.env
     export APP_WEBSITE_DOMAIN
     export APP_DOMAIN
     export DB_HOST
     export IMAP_HOST
     export IMAP_PORT
     export IMAP_ADMIN_LOGIN
     export IMAP_ADMIN_PASSWORD
     export MAIL_HOST
     export MAIL_PORT
     export IMAP_DEBUG
     export FILEAPI_WOPI_OFFICE
     export CALENDAR_CALDAV_SERVER
     export KOLAB_ADDRESSBOOK_CARDDAV_SERVER
     export DB_ROOT_PASSWORD
     export DB_USERNAME
     export DB_PASSWORD
     export DB_DATABASE
     export MINIO_USER
     export MINIO_PASSWORD
     export PASSPORT_PRIVATE_KEY
     export PASSPORT_PUBLIC_KEY
     export DES_KEY
     export MEET_SERVER_TOKEN
     export MEET_WEBHOOK_TOKEN
     export KOLAB_SSL_CERTIFICATE
     export KOLAB_SSL_CERTIFICATE_FULLCHAIN
     export KOLAB_SSL_CERTIFICATE_KEY
 }
 
 kolab__configure() {
     if [[ "$1" == "--force" ]]; then
         rm src/.env
     fi
 
     # Generate the .env once with all the necessary secrets
     if [[ -f src/.env ]]; then
         echo "src/.env already exists, not regenerating"
         return
     fi
 
     cp "$CONFIG/src/.env" src/.env
 
     if [[ -z $ADMIN_PASSWORD ]]; then
         echo "Please enter your new admin password for the admin@$HOST user:"
         read -r ADMIN_PASSWORD
     fi
 
     if [[ -z $PUBLIC_IP ]]; then
         PUBLIC_IP=$(ip -o route get to 8.8.8.8 | sed -n 's/.*src \([0-9.]\+\).*/\1/p')
     fi
 
     # Generate random secrets
     if ! grep -q "COTURN_STATIC_SECRET" src/.env; then
         COTURN_STATIC_SECRET=$(openssl rand -hex 32);
         echo "COTURN_STATIC_SECRET=${COTURN_STATIC_SECRET}" >> src/.env
     fi
 
     if ! grep -q "MEET_WEBHOOK_TOKEN" src/.env; then
         MEET_WEBHOOK_TOKEN=$(openssl rand -hex 32);
         echo "MEET_WEBHOOK_TOKEN=${MEET_WEBHOOK_TOKEN}" >> src/.env
     fi
 
     if ! grep -q "MEET_SERVER_TOKEN" src/.env; then
         MEET_SERVER_TOKEN=$(openssl rand -hex 32);
         echo "MEET_SERVER_TOKEN=${MEET_SERVER_TOKEN}" >> src/.env
     fi
 
     if ! grep -q "APP_KEY=base64:" src/.env; then
         APP_KEY=$(openssl rand -base64 32);
         echo "APP_KEY=base64:${APP_KEY}" >> src/.env
     fi
 
     if ! grep -q "PASSPORT_PROXY_OAUTH_CLIENT_ID=" src/.env; then
         PASSPORT_PROXY_OAUTH_CLIENT_ID=$(uuidgen);
         echo "PASSPORT_PROXY_OAUTH_CLIENT_ID=${PASSPORT_PROXY_OAUTH_CLIENT_ID}" >> src/.env
     fi
 
     if ! grep -q "PASSPORT_PROXY_OAUTH_CLIENT_SECRET=" src/.env; then
         PASSPORT_PROXY_OAUTH_CLIENT_SECRET=$(openssl rand -base64 32);
         echo "PASSPORT_PROXY_OAUTH_CLIENT_SECRET=${PASSPORT_PROXY_OAUTH_CLIENT_SECRET}" >> src/.env
     fi
 
     if ! grep -q "PASSPORT_PUBLIC_KEY=|PASSPORT_PRIVATE_KEY=" src/.env; then
         PASSPORT_PRIVATE_KEY=$(openssl genrsa 4096);
         echo "PASSPORT_PRIVATE_KEY=\"${PASSPORT_PRIVATE_KEY}\"" >> src/.env
 
         PASSPORT_PUBLIC_KEY=$(echo "$PASSPORT_PRIVATE_KEY" | openssl rsa -pubout 2>/dev/null)
         echo "PASSPORT_PUBLIC_KEY=\"${PASSPORT_PUBLIC_KEY}\"" >> src/.env
     fi
 
     if ! grep -q "DES_KEY=" src/.env; then
         DES_KEY=$(openssl rand -base64 24);
         echo "DES_KEY=${DES_KEY}" >> src/.env
     fi
 
     # Customize configuration
     sed -i \
         -e "s/{{ host }}/${HOST}/g" \
         -e "s/{{ openexchangerates_api_key }}/${OPENEXCHANGERATES_API_KEY}/g" \
         -e "s/{{ firebase_api_key }}/${FIREBASE_API_KEY}/g" \
         -e "s/{{ public_ip }}/${PUBLIC_IP}/g" \
         -e "s/{{ admin_password }}/${ADMIN_PASSWORD}/g" \
         src/.env
 
     if [ -f /etc/letsencrypt/live/${HOST}/cert.pem ]; then
         echo "Using the available letsencrypt certificate for ${HOST}"
         cat >> src/.env << EOF
 KOLAB_SSL_CERTIFICATE=/etc/letsencrypt/live/${HOST}/cert.pem
 KOLAB_SSL_CERTIFICATE_FULLCHAIN=/etc/letsencrypt/live/${HOST}/fullchain.pem
 KOLAB_SSL_CERTIFICATE_KEY=/etc/letsencrypt/live/${HOST}/privkey.pem
 PROXY_SSL_CERTIFICATE=/etc/letsencrypt/live/${HOST}/fullchain.pem
 PROXY_SSL_CERTIFICATE_KEY=/etc/letsencrypt/live/${HOST}/privkey.pem
 EOF
     fi
 }
 
 kolab__deploy() {
     if [[ -z $ADMIN_PASSWORD ]]; then
         echo "Please enter your new admin password for the admin@$HOST user:"
         read -r ADMIN_PASSWORD
     fi
     echo "Deploying $CONFIG on $HOST"
 
     if [[ ! -f src/.env ]]; then
         echo "Missing src/.env file, run 'kolabctl configure' to generate"
         exit 1
     fi
 
     if [[ "$1" == "--reset" ]]; then
         kolab__reset --force
     fi
 
     __export_env
 
     podman volume create $POD-imap-spool --ignore -l=kolab
     podman volume create $POD-imap-lib --ignore -l=kolab
     podman volume create $POD-postfix-spool --ignore -l=kolab
     podman volume create $POD-postfix-lib --ignore -l=kolab
     podman volume create $POD-mariadb-data --ignore -l=kolab
     podman volume create $POD-redis-data --ignore -l=kolab
     podman volume create $POD-minio-data --ignore -l=kolab
 
     kolab__build
 
     # Create the pod first
     $PODMAN pod create \
         --replace \
         --add-host=$HOST:127.0.0.1 \
         --publish "443:6443" \
         --publish "465:6465" \
         --publish "587:6587" \
         --publish "143:6143" \
         --publish "993:6993" \
         --publish "44444:44444/udp" \
         --publish "44444:44444/tcp" \
         --name $POD
 
     podman__run_mariadb
     podman__run_redis
 
     podman__healthcheck $POD-mariadb $POD-redis
 
     # Make imap available to the webapp seeder, but don't expect it to be healthy until it can authenticate against the webapp
     podman__run_imap
 
     podman__run_webapp src/.env $CONFIG
     podman__healthcheck $POD-webapp
 
     podman__healthcheck $POD-imap
 
     # Ensure all commands are processed
     echo "Flushing work queue"
     $PODMAN exec -ti $POD-webapp ./artisan queue:work --stop-when-empty
 
     if [[ -n $ADMIN_PASSWORD ]]; then
         podman exec $POD-webapp ./artisan user:password "admin@$APP_DOMAIN" "$ADMIN_PASSWORD"
     fi
 
     podman__run_minio
     podman__healthcheck $POD-minio
 
     podman__run_meet
 
     podman__run_roundcube
     podman__run_postfix
     podman__run_amavis
     podman__run_collabora
     podman__run_proxy
 }
 
 kolab__reset() {
     if [[ "$1" == "--force" ]]; then
         REPLY="y"
     else
         read -p "Are you sure? This will delete the pod including all data. Type y to confirm." -n 1 -r
         echo
     fi
     if [[ "$REPLY" =~ ^[Yy]$ ]];
     then
         podman pod rm --force $POD
         volumes=($(podman volume ls -f name=$POD | awk '{if (NR > 1) print $2}'))
         for v in "${volumes[@]}"
         do
             podman volume rm --force $v
         done
     fi
 }
 
 kolab__start() {
     podman pod start $POD
 }
 
 kolab__stop() {
     podman pod stop $POD
 }
 
 kolab__update() {
     kolab__stop
 
     podman pull quay.io/sclorg/mariadb-105-c9s
     podman pull minio/minio:latest
     podman pull almalinux:9
 
     kolab__build
 
     kolab__start
 }
 
 kolab__backup() {
     backup_path="$(pwd)/backup/"
     mkdir -p "$backup_path"
 
     echo "Stopping containers"
     kolab__stop
 
     echo "Backing up volumes"
     volumes=($(podman volume ls -f name=$POD | awk '{if (NR > 1) print $2}'))
     for v in "${volumes[@]}"
     do
         podman export -o="$backup_path/$v.tar"
     done
 
     echo "Restarting containers"
     kolab__start
 }
 
 kolab__restore() {
     backup_path="$(pwd)/backup/"
 
     echo "Stopping containers"
     kolab__stop
 
     # We currently expect the volumes to exist.
     # We could alternatively create volumes form existing tar files
     # for f in backup/*.tar; do
     #     echo "$(basename $f .tar)" ;
     # done
 
     echo "Restoring volumes"
     volumes=($(podman volume ls -f name=$POD | awk '{if (NR > 1) print $2}'))
     for v in "${volumes[@]}"
     do
         podman import $v "$backup_path/$v.tar"
     done
     echo "Restarting containers"
     kolab__start
 }
 
 kolab__selfcheck() {
     set -e
     set -x
 
     APP_DOMAIN=$(grep APP_DOMAIN src/.env | tail -n1 | sed "s/APP_DOMAIN=//")
     if [ -z "$ADMIN_PASSWORD" ]; then
         ADMIN_PASSWORD="simple123"
     fi
     if [ -z "$ADMIN_USER" ]; then
         ADMIN_USER="admin@$APP_DOMAIN"
     fi
 
+    podman__is_ready $POD-imap
+    podman__is_ready $POD-mariadb
+    podman__is_ready $POD-redis
+    podman__is_ready $POD-webapp
+    podman__is_ready $POD-minio
+    podman__is_ready $POD-meet
+    podman__is_ready $POD-roundcube
+    podman__is_ready $POD-postfix
+    podman__is_ready $POD-collabora
+    podman__is_ready $POD-proxy
+
     # We skip mollie and openexchange
     podman exec $POD-webapp ./artisan status:health --check DB --check Redis --check IMAP --check Roundcube --check Meet --check DAV
     podman exec $POD-postfix testsaslauthd -u "$ADMIN_USER" -p "$ADMIN_PASSWORD"
     podman exec $POD-imap testsaslauthd -u "$ADMIN_USER" -p "$ADMIN_PASSWORD"
 
     # podman run -ti --rm utils ./mailtransporttest.py --sender-username "$ADMIN_USER" --sender-password "$ADMIN_PASSWORD" --sender-host "127.0.0.1" --recipient-username "$ADMIN_USER" --recipient-password "$ADMIN_PASSWORD" --recipient-host "127.0.0.1" --recipient-port "11143"
 
     # podman run -ti --rm  utils ./kolabendpointtester.py --verbose --host "$APP_DOMAIN" --dav "https://$APP_DOMAIN/dav/" --imap "$APP_DOMAIN" --activesync "$APP_DOMAIN"  --user "$ADMIN_USER" --password "$ADMIN_PASSWORD"
 
     echo "All tests have passed!"
 }
 
 kolab__ps() {
     command podman pod $POD ps
 }
 
 kolab__exec() {
     container=$1
     shift
     command podman exec -ti $POD-$container $@
 }
 
 kolab__run() {
     __export_env
     podman__run_$1
 }
 
 kolab__build() {
     if [[ $1 != "" ]]; then
         podman__build_$1
     else
         podman__build_base
         podman__build_webapp
         podman__build_meet
 
         podman__build docker/imap kolab-imap
         podman__build docker/mariadb mariadb
         podman__build docker/redis redis
         podman__build docker/proxy kolab-proxy
         podman__build_roundcube
 
         podman__build docker/utils utils
         podman__build docker/postfix kolab-postfix
         podman__build docker/amavis kolab-amavis
         podman__build docker/collabora kolab-collabora --build-arg=REPOSITORY="https://www.collaboraoffice.com/repos/CollaboraOnline/23.05-CODE/CODE-rpm/"
         env CERT_DIR=docker/certs APP_DOMAIN=$HOST bin/regen-certs
     fi
 }
 
 kolab__cyradm() {
     # command podman exec -ti $POD-imap cyradm --auth PLAIN -u admin@kolab.local -w simple123  --port 11143 localhost
     if [[ "$@" ]]; then
         command podman exec -ti $POD-imap echo "$@" | cyradm --auth PLAIN -u $(grep IMAP_ADMIN_LOGIN src/.env | cut -d '=' -f 2 ) -w $(grep IMAP_ADMIN_PASSWORD src/.env | cut -d '=' -f 2 )  --port 11143 localhost
     else
         command podman exec -ti $POD-imap cyradm --auth PLAIN -u $(grep IMAP_ADMIN_LOGIN src/.env | cut -d '=' -f 2 ) -w $(grep IMAP_ADMIN_PASSWORD src/.env | cut -d '=' -f 2 )  --port 11143 localhost
     fi
 }
 
 kolab__shell() {
     kolab__exec $1 /bin/bash
 }
 
 kolab__logs() {
     command podman logs -f $POD-$1
 }
 
 kolab__help() {
     cat <<EOF
   This is the kolab commandline utility.
 
   The following commands are available:
     deploy: Deploy kolab
     start: Start all containers
     stop: Stop all containers
     update: This will update all containers.
     backup: Create a backup in backup/
     restore: Restore a backup from backup/
     selfcheck: Run a selfcheck to ensure kolab is functional
 EOF
 }
 
 cmdname=$1
 shift
 
 # make sure we actually *did* get passed a valid function name
 if declare -f "kolab__$cmdname" >/dev/null 2>&1; then
     "kolab__$cmdname" "${@:1}"
 else
     echo "Function $cmdname not recognized" >&2
     kolab__help
     exit 1
 fi