#!/usr/bin/env bash
#
# Management of a Rezervovator stack with one container per customer.
# See README.md in this directory.

set -euo pipefail

DEPLOY_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENV_FILE="$DEPLOY_DIR/.env"
CUSTOMERS_DIR="$DEPLOY_DIR/customers"
BACKUPS_DIR="$DEPLOY_DIR/backups"

usage() {
    cat <<USAGE
Usage: $(basename "$0") <command> [arguments]

  init                         Create .env; then start the shared services and check the setup
  add <name> <domain> [from]   Create a customer: database, config, volume, container.
                               [from] is the sender address of e-mails, default noreply@<domain>
  import <name> <domain> <database> [data-dir] [from]
                               Create a customer from an existing installation: copies its
                               database and the files from its data directory. The source is
                               only read.
  list                         List customers and the state of their containers
  upgrade <name>...|--all      Recreate containers from REZERVATOR_IMAGE, one by one.
                               Backs up first, rolls back and stops when one fails.
  backup <name>...|--all       Dump the database and the data volume to backups/<name>/
  restore <name> <timestamp>   Restore a customer from backups/<name>/<timestamp>-*
  remove <name> [--purge]      Stop and remove the container. With --purge also the database,
                               the data volume and the config (asks for confirmation).

<name> is lowercase letters, digits and dashes, starting with a letter.
USAGE
}

die() {
    echo "Error: $*" >&2
    exit 1
}

info() {
    echo "==> $*"
}

random_string() {
    # $1 = number of bytes, output is twice as many hex characters
    openssl rand -hex "$1"
}

load_env() {
    [ -f "$ENV_FILE" ] || die "$ENV_FILE not found, run '$(basename "$0") init' first"
    set -a
    # shellcheck disable=SC1090
    . "$ENV_FILE"
    set +a

    PREFIX="${REZERVATOR_PREFIX:-rezervator}"
    IMAGE="${REZERVATOR_IMAGE:-rezervator:latest}"
    TLS="${REZERVATOR_TLS:-true}"
    PROXY="${REZERVATOR_PROXY:-traefik}"
    POSTGRES="${REZERVATOR_POSTGRES:-container}"
    PG_CONTAINER="$PREFIX-postgres"
    PG_PORT="${PG_PORT:-5432}"
    NETWORK="$PREFIX"
    CUSTOMER_MAX_CONNECTIONS="${CUSTOMER_MAX_CONNECTIONS:-5}"
    BASE_PORT="${BASE_PORT:-3100}"

    case "$PROXY" in traefik|nginx) ;; *) die "REZERVATOR_PROXY must be traefik or nginx" ;; esac
    case "$POSTGRES" in container|host) ;; *) die "REZERVATOR_POSTGRES must be container or host" ;; esac

    if [ "$POSTGRES" = "host" ]; then
        # Address of the Docker host as the containers see it
        DB_HOST="${PG_HOST:-host.docker.internal}"
        # How to run psql and pg_dump as the PostgreSQL superuser; may be empty
        PG_ADMIN="${PG_ADMIN-sudo -u postgres}"
    else
        DB_HOST="$PG_CONTAINER"
    fi
}

compose() {
    docker compose --project-directory "$DEPLOY_DIR" --env-file "$ENV_FILE" "$@"
}

# Starts the shared services that run as containers in this setup, if any
compose_up() {
    local profiles=()
    if [ "$PROXY" = "traefik" ]; then profiles+=(--profile traefik); fi
    if [ "$POSTGRES" = "container" ]; then profiles+=(--profile postgres); fi

    docker network inspect "$NETWORK" >/dev/null 2>&1 || docker network create "$NETWORK" >/dev/null
    if [ "${#profiles[@]}" -gt 0 ]; then
        compose "${profiles[@]}" up --detach
    fi
}

check_name() {
    [[ "$1" =~ ^[a-z][a-z0-9-]{0,30}$ ]] || die "Invalid customer name '$1'"
}

container_name() { echo "$PREFIX-app-$1"; }
volume_name() { echo "$PREFIX-data-$1"; }
# Database and role have the same name
db_name() { echo "rz_${1//-/_}"; }

customer_exists() {
    [ -f "$CUSTOMERS_DIR/$1/customer.env" ]
}

require_customer() {
    check_name "$1"
    customer_exists "$1" || die "Unknown customer '$1'"
}

all_customers() {
    [ -d "$CUSTOMERS_DIR" ] || return 0
    for dir in "$CUSTOMERS_DIR"/*/; do
        if [ -f "${dir}customer.env" ]; then basename "$dir"; fi
    done
    return 0
}

# Reads a value from the customer's customer.env. $1 = name, $2 = variable
customer_value() {
    sed -n "s/^$2=//p" "$CUSTOMERS_DIR/$1/customer.env" | head -n 1
}

# psql as the PostgreSQL superuser, on the host or in the container
psql_admin() {
    if [ "$POSTGRES" = "host" ]; then
        # shellcheck disable=SC2086
        $PG_ADMIN psql -v ON_ERROR_STOP=1 -q "$@"
    else
        docker exec -i "$PG_CONTAINER" psql -U postgres -v ON_ERROR_STOP=1 -q "$@"
    fi
}

pg_dump_admin() {
    if [ "$POSTGRES" = "host" ]; then
        # shellcheck disable=SC2086
        $PG_ADMIN pg_dump "$@"
    else
        docker exec "$PG_CONTAINER" pg_dump -U postgres "$@"
    fi
}

wait_for_postgres() {
    if [ "$POSTGRES" = "host" ]; then
        psql_admin -tAc "SELECT 1" >/dev/null 2>&1 \
            || die "Cannot run psql as the PostgreSQL superuser (PG_ADMIN='$PG_ADMIN')"
        return 0
    fi
    for _ in $(seq 1 60); do
        # Over TCP: while the image initializes a new cluster, its temporary server listens on the socket only
        if docker exec "$PG_CONTAINER" pg_isready -h 127.0.0.1 -U postgres -q 2>/dev/null; then
            return 0
        fi
        sleep 1
    done
    die "PostgreSQL in container $PG_CONTAINER is not ready"
}

# With PostgreSQL on the host, the containers must be able to reach it over the Docker network
check_db_reachable() {
    [ "$POSTGRES" = "host" ] || return 0
    docker run --rm --network "$NETWORK" --add-host "host.docker.internal:host-gateway" \
        --entrypoint bash "$IMAGE" -c "exec 3<>/dev/tcp/$DB_HOST/$PG_PORT" 2>/dev/null \
        || die "Containers cannot reach PostgreSQL at $DB_HOST:$PG_PORT. Check listen_addresses, pg_hba.conf and the firewall, see README.md."
}

# First free port for a customer container behind nginx
next_port() {
    local port="$BASE_PORT" name used
    for name in $(all_customers); do
        used="$(customer_value "$name" PORT)"
        if [ -n "$used" ] && [ "$used" -ge "$port" ]; then
            port=$((used + 1))
        fi
    done
    echo "$port"
}

# Writes the nginx server block of a customer to customers/<name>/nginx.conf
write_nginx_conf() {
    local name="$1" domain port
    domain="$(customer_value "$name" DOMAIN)"
    port="$(customer_value "$name" PORT)"
    cat > "$CUSTOMERS_DIR/$name/nginx.conf" <<NGINX
# Rezervovator, customer '$name'. Generated by rezervator.sh.
# Install it into nginx and add TLS, e.g.:
#   sudo cp $CUSTOMERS_DIR/$name/nginx.conf /etc/nginx/conf.d/$PREFIX-$name.conf
#   sudo nginx -t && sudo systemctl reload nginx
#   sudo certbot --nginx -d $domain
server {
    listen 80;
    listen [::]:80;
    server_name $domain;

    # Banner images are uploaded through the application
    client_max_body_size 20m;

    location / {
        proxy_pass http://127.0.0.1:$port;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }
}
NGINX
}

# Starts the container of a customer. $1 = name, $2 = image, $3 = initial admin password (optional)
run_container() {
    local name="$1" image="$2" admin_password="${3:-}"
    local container router domain port
    container="$(container_name "$name")"
    router="$PREFIX-$name"
    domain="$(customer_value "$name" DOMAIN)"
    port="$(customer_value "$name" PORT)"

    local args=(
        --detach
        --name "$container"
        --restart unless-stopped
        --network "$NETWORK"
        --volume "$CUSTOMERS_DIR/$name/config.toml:/app/config/config.toml:ro"
        --volume "$(volume_name "$name"):/app/data"
        --label "rezervator.stack=$PREFIX"
        --label "rezervator.customer=$name"
        --label "rezervator.domain=$domain"
    )

    if [ "$POSTGRES" = "host" ]; then
        args+=(--add-host "host.docker.internal:host-gateway")
    fi

    if [ "$PROXY" = "nginx" ]; then
        [ -n "$port" ] || die "Customer '$name' has no PORT in customer.env"
        # Only the nginx on this host may reach the container
        args+=(--publish "127.0.0.1:$port:3000")
    elif [ "$TLS" = "true" ]; then
        args+=(
            --label "traefik.enable=true"
            --label "traefik.http.services.$router.loadbalancer.server.port=3000"
            --label "traefik.http.routers.$router.rule=Host(\`$domain\`)"
            --label "traefik.http.routers.$router.entrypoints=websecure"
            --label "traefik.http.routers.$router.tls.certresolver=le"
            --label "traefik.http.routers.$router-http.rule=Host(\`$domain\`)"
            --label "traefik.http.routers.$router-http.entrypoints=web"
            --label "traefik.http.routers.$router-http.middlewares=$router-https"
            --label "traefik.http.middlewares.$router-https.redirectscheme.scheme=https"
        )
    else
        args+=(
            --label "traefik.enable=true"
            --label "traefik.http.services.$router.loadbalancer.server.port=3000"
            --label "traefik.http.routers.$router.rule=Host(\`$domain\`)"
            --label "traefik.http.routers.$router.entrypoints=web"
        )
    fi

    if [ -n "$admin_password" ]; then
        args+=(--env "REZERVATOR_ADMIN_PASSWORD=$admin_password")
    fi

    docker run "${args[@]}" "$image" >/dev/null
}

# Waits until the container reports healthy. Returns 1 when it stops or stays unhealthy.
wait_healthy() {
    local container="$1" status
    for _ in $(seq 1 90); do
        status="$(docker inspect --format '{{.State.Status}} {{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$container" 2>/dev/null || echo "missing")"
        case "$status" in
            "running healthy")
                # Traefik picks a new container up a moment after it turns healthy
                if [ "$PROXY" = "traefik" ]; then sleep 3; fi
                return 0 ;;
            # Image without a health check: running for a while is the best we can tell
            "running none") sleep 5
                [ "$(docker inspect --format '{{.State.Status}}' "$container" 2>/dev/null)" = "running" ] && return 0
                return 1 ;;
            "running starting") ;;
            "running unhealthy") return 1 ;;
            running*) ;;
            *) return 1 ;;
        esac
        sleep 2
    done
    return 1
}

cmd_init() {
    command -v docker >/dev/null || die "docker not found"
    command -v openssl >/dev/null || die "openssl not found"

    if [ ! -f "$ENV_FILE" ]; then
        sed "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$(random_string 24)/" "$DEPLOY_DIR/.env.example" > "$ENV_FILE"
        chmod 600 "$ENV_FILE"
        info "Created $ENV_FILE. Review it (proxy, PostgreSQL, image) and run init again."
        exit 0
    fi

    load_env
    if [ "$PROXY" = "traefik" ] && [ "$TLS" = "true" ] && [ -z "${ACME_EMAIL:-}" ]; then
        die "REZERVATOR_TLS=true needs ACME_EMAIL in $ENV_FILE"
    fi

    mkdir -p "$CUSTOMERS_DIR" "$BACKUPS_DIR"
    chmod 700 "$CUSTOMERS_DIR" "$BACKUPS_DIR"
    compose_up
    wait_for_postgres
    if docker image inspect "$IMAGE" >/dev/null 2>&1; then
        check_db_reachable
    else
        info "Image $IMAGE is not on this host yet, build or pull it before adding customers"
    fi
    info "Ready (proxy: $PROXY, PostgreSQL: $POSTGRES)"
}

# Validates the input and creates everything a customer needs except the running container:
# database and role, config, data volume. $1 = name, $2 = domain, $3 = sender address
prepare_customer() {
    local name="$1" domain="$2" mail_from="$3"
    check_name "$name"
    [[ "$domain" =~ ^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$ ]] || die "Invalid domain '$domain'"
    [[ "$mail_from" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+$ ]] || die "Invalid sender address '$mail_from'"
    if customer_exists "$name"; then die "Customer '$name' already exists"; fi
    docker image inspect "$IMAGE" >/dev/null 2>&1 || die "Image $IMAGE not found, build or pull it first"
    wait_for_postgres
    check_db_reachable

    local db db_password dir
    db="$(db_name "$name")"
    db_password="$(random_string 24)"
    dir="$CUSTOMERS_DIR/$name"

    if [ "$(psql_admin -tAc "SELECT 1 FROM pg_database WHERE datname = '$db'")" = "1" ]; then
        die "Database $db already exists"
    fi
    if [ "$(psql_admin -tAc "SELECT 1 FROM pg_roles WHERE rolname = '$db'")" = "1" ]; then
        die "Database role $db already exists"
    fi

    info "Creating database $db"
    psql_admin <<SQL
CREATE ROLE "$db" LOGIN PASSWORD '$db_password';
CREATE DATABASE "$db" OWNER "$db";
REVOKE ALL ON DATABASE "$db" FROM PUBLIC;
SQL

    info "Writing config to $dir"
    mkdir -p "$dir"
    chmod 700 "$dir"
    sed -e "s|@SESSION_KEY@|$(random_string 48)|" \
        -e "s|@DB_USER@|$db|" \
        -e "s|@DB_PASSWORD@|$db_password|" \
        -e "s|@DB_NAME@|$db|" \
        -e "s|@DB_HOST@|$DB_HOST|" \
        -e "s|@DB_PORT@|$PG_PORT|" \
        -e "s|@MAX_CONNECTIONS@|$CUSTOMER_MAX_CONNECTIONS|" \
        -e "s|@MAIL_FROM@|$mail_from|" \
        "$DEPLOY_DIR/config.template.toml" > "$dir/config.toml"
    # The directory is closed to other users; the application in the container must be able to read the file
    chmod 644 "$dir/config.toml"

    if [ "$PROXY" = "nginx" ]; then
        # Computed before customer.env exists, so the new customer is not counted
        local port
        port="$(next_port)"
        printf 'DOMAIN=%s\nPORT=%s\n' "$domain" "$port" > "$dir/customer.env"
        write_nginx_conf "$name"
    else
        printf 'DOMAIN=%s\n' "$domain" > "$dir/customer.env"
    fi

    docker volume create "$(volume_name "$name")" >/dev/null
}

# Starts a prepared customer and waits for it. $1 = name, $2 = initial admin password (optional)
start_new_customer() {
    local name="$1" admin_password="${2:-}"
    info "Starting container $(container_name "$name")"
    run_container "$name" "$IMAGE" "$admin_password"

    if ! wait_healthy "$(container_name "$name")"; then
        docker logs --tail 20 "$(container_name "$name")" >&2 || true
        die "Container $(container_name "$name") did not become healthy. Fix the problem and run 'remove $name --purge' before creating it again."
    fi
}

print_address() {
    local name="$1" domain
    domain="$(customer_value "$name" DOMAIN)"
    echo
    if [ "$PROXY" = "nginx" ]; then
        echo "Customer '$name' is running on 127.0.0.1:$(customer_value "$name" PORT)."
        echo "To publish it at $domain, install $CUSTOMERS_DIR/$name/nginx.conf"
        echo "into nginx; the commands are at the top of that file."
    elif [ "$TLS" = "true" ]; then
        echo "Customer '$name' is running at https://$domain"
    else
        echo "Customer '$name' is running at http://$domain"
    fi
}

cmd_add() {
    [ $# -ge 2 ] || die "Usage: add <name> <domain> [from]"
    local name="$1" domain="$2" mail_from="${3:-noreply@$2}" admin_password
    load_env
    prepare_customer "$name" "$domain" "$mail_from"
    admin_password="$(random_string 9)"
    start_new_customer "$name" "$admin_password"

    print_address "$name"
    cat <<MSG

  Admin login:    admin
  Admin password: $admin_password

The password is shown only now. Hand it over and have it changed after the first login.
MSG
}

cmd_import() {
    [ $# -ge 3 ] || die "Usage: import <name> <domain> <database> [data-dir] [from]"
    local name="$1" domain="$2" source_db="$3" data_dir="${4:-}" mail_from="${5:-noreply@$2}"
    local dir timestamp
    load_env
    [[ "$source_db" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || die "Invalid database name '$source_db'"
    if [ -n "$data_dir" ] && [ ! -d "$data_dir" ]; then
        die "Data directory '$data_dir' not found"
    fi
    wait_for_postgres
    [ "$(psql_admin -tAc "SELECT 1 FROM pg_database WHERE datname = '$source_db'")" = "1" ] \
        || die "Source database '$source_db' not found"

    prepare_customer "$name" "$domain" "$mail_from"

    # The copy goes through the same files as a backup, so it can be restored again later
    dir="$BACKUPS_DIR/$name"
    timestamp="$(date -u +%Y%m%dT%H%M%SZ)"
    mkdir -p "$dir"
    chmod 700 "$dir"
    info "Copying database $source_db"
    pg_dump_admin --no-owner --no-privileges "$source_db" | gzip > "$dir/$timestamp-db.sql.gz"
    if [ -n "$data_dir" ]; then
        info "Copying files from $data_dir"
        # Old installations kept the config file with passwords next to the uploads
        tar czf "$dir/$timestamp-data.tar.gz" --exclude='*.toml' -C "$data_dir" .
    else
        tar czf "$dir/$timestamp-data.tar.gz" --files-from /dev/null
    fi
    restore_customer "$name" "$timestamp"

    # The accounts come with the database, so no initial admin password
    start_new_customer "$name"
    print_address "$name"
    echo
    echo "Accounts and passwords were taken over from database $source_db."
    if docker logs "$(container_name "$name")" 2>&1 | grep -q "still uses the default password"; then
        echo "WARNING: the account 'admin' still has the default password 'admin'. Change it now."
    fi
    echo "The source database and files were not changed. Stop the old installation before"
    echo "switching the domain over, otherwise bookings made there in the meantime are lost."
}

cmd_list() {
    load_env
    printf '%-20s %-34s %-7s %-18s %s\n' "CUSTOMER" "DOMAIN" "PORT" "STATE" "IMAGE"
    local name domain port state image
    for name in $(all_customers); do
        domain="$(customer_value "$name" DOMAIN)"
        port="$(customer_value "$name" PORT)"
        state="$(docker inspect --format '{{.State.Status}}{{if .State.Health}}/{{.State.Health.Status}}{{end}}' "$(container_name "$name")" 2>/dev/null || echo "no container")"
        image="$(docker inspect --format '{{.Image}}' "$(container_name "$name")" 2>/dev/null || true)"
        if [ -n "$image" ]; then
            # Tag of the image when it still has one, otherwise the short id
            image="$(docker image inspect --format '{{if .RepoTags}}{{index .RepoTags 0}}{{else}}{{slice .Id 7 19}}{{end}}' "$image" 2>/dev/null || echo "${image:7:12}")"
        else
            image="-"
        fi
        printf '%-20s %-34s %-7s %-18s %s\n' "$name" "$domain" "${port:--}" "$state" "$image"
    done
}

# Dumps the database and the data volume. $1 = name. Prints the timestamp of the backup.
backup_customer() {
    local name="$1" db dir timestamp
    db="$(db_name "$name")"
    dir="$BACKUPS_DIR/$name"
    timestamp="$(date -u +%Y%m%dT%H%M%SZ)"
    mkdir -p "$dir"
    chmod 700 "$dir"

    pg_dump_admin --no-owner --no-privileges "$db" | gzip > "$dir/$timestamp-db.sql.gz"
    # Any image with tar would do; the application image is certainly present
    docker run --rm --volume "$(volume_name "$name"):/data:ro" --entrypoint tar "$IMAGE" \
        czf - -C /data . > "$dir/$timestamp-data.tar.gz"

    # An empty or truncated dump must not pass for a backup
    gzip -t "$dir/$timestamp-db.sql.gz" && gzip -t "$dir/$timestamp-data.tar.gz"
    [ "$(gzip -dc "$dir/$timestamp-db.sql.gz" | wc -c)" -gt 0 ] || die "Database dump of '$name' is empty"

    echo "$timestamp"
}

cmd_backup() {
    [ $# -ge 1 ] || die "Usage: backup <name>...|--all"
    load_env
    wait_for_postgres
    local names=("$@") name timestamp
    if [ "$1" = "--all" ]; then
        # shellcheck disable=SC2207
        names=($(all_customers))
    fi
    [ "${#names[@]}" -gt 0 ] || { info "No customers"; return 0; }
    for name in "${names[@]}"; do
        require_customer "$name"
        timestamp="$(backup_customer "$name")"
        info "Backup of '$name': $BACKUPS_DIR/$name/$timestamp-db.sql.gz, $timestamp-data.tar.gz"
    done
}

# Replaces the database and the data volume by a backup. The container must be stopped.
restore_customer() {
    local name="$1" timestamp="$2" db dir
    db="$(db_name "$name")"
    dir="$BACKUPS_DIR/$name"

    psql_admin <<SQL
DROP DATABASE IF EXISTS "$db" WITH (FORCE);
CREATE DATABASE "$db" OWNER "$db";
REVOKE ALL ON DATABASE "$db" FROM PUBLIC;
SQL
    # Loaded by the superuser acting as the customer's role, so that role owns everything
    { echo "SET ROLE \"$db\";"; gzip -dc "$dir/$timestamp-db.sql.gz"; } | psql_admin -d "$db" >/dev/null

    docker run --rm -i --volume "$(volume_name "$name"):/data" --entrypoint sh "$IMAGE" \
        -c 'find /data -mindepth 1 -delete && tar xzf - -C /data' < "$dir/$timestamp-data.tar.gz"
}

cmd_restore() {
    [ $# -eq 2 ] || die "Usage: restore <name> <timestamp>"
    local name="$1" timestamp="$2" container image
    load_env
    require_customer "$name"
    [ -f "$BACKUPS_DIR/$name/$timestamp-db.sql.gz" ] && [ -f "$BACKUPS_DIR/$name/$timestamp-data.tar.gz" ] \
        || die "Backup $timestamp of '$name' not found in $BACKUPS_DIR/$name"
    wait_for_postgres

    container="$(container_name "$name")"
    # Keep the image the customer runs now; the configured one may be newer than the backup
    image="$(docker inspect --format '{{.Image}}' "$container" 2>/dev/null || echo "$IMAGE")"

    info "Stopping $container"
    docker rm --force "$container" >/dev/null 2>&1 || true
    info "Restoring '$name' from backup $timestamp"
    restore_customer "$name" "$timestamp"
    run_container "$name" "$image"
    wait_healthy "$container" || die "Container $container is not healthy after the restore, see 'docker logs $container'"
    info "Customer '$name' restored and running"
}

cmd_upgrade() {
    [ $# -ge 1 ] || die "Usage: upgrade <name>...|--all"
    load_env
    docker image inspect "$IMAGE" >/dev/null 2>&1 || die "Image $IMAGE not found, build or pull it first"
    wait_for_postgres

    local names=("$@") name container old_image new_image timestamp
    if [ "$1" = "--all" ]; then
        # shellcheck disable=SC2207
        names=($(all_customers))
    fi
    [ "${#names[@]}" -gt 0 ] || { info "No customers"; return 0; }
    new_image="$(docker image inspect --format '{{.Id}}' "$IMAGE")"

    for name in "${names[@]}"; do
        require_customer "$name"
        container="$(container_name "$name")"
        old_image="$(docker inspect --format '{{.Image}}' "$container" 2>/dev/null || true)"

        if [ "$old_image" = "$new_image" ]; then
            info "'$name' already runs $IMAGE, skipping"
            continue
        fi

        info "Upgrading '$name'"
        timestamp="$(backup_customer "$name")"
        docker rm --force "$container" >/dev/null 2>&1 || true
        run_container "$name" "$IMAGE"

        if wait_healthy "$container"; then
            info "'$name' upgraded (backup before the upgrade: $timestamp)"
            continue
        fi

        echo "Upgrade of '$name' failed, last log lines of the new container:" >&2
        docker logs --tail 20 "$container" >&2 || true
        docker rm --force "$container" >/dev/null 2>&1 || true

        if [ -z "$old_image" ]; then
            die "'$name' had no container before, nothing to roll back to. Backup: $timestamp"
        fi

        # Migrations of the new version may have changed the database, so the old version
        # gets the database from before the upgrade
        info "Rolling '$name' back to the previous image and to backup $timestamp"
        restore_customer "$name" "$timestamp"
        run_container "$name" "$old_image"
        if wait_healthy "$container"; then
            die "'$name' was rolled back. Upgrade stopped, the remaining customers were not touched."
        fi
        die "'$name' is DOWN: the rollback did not become healthy either. Backup: $timestamp"
    done
}

cmd_remove() {
    [ $# -ge 1 ] || die "Usage: remove <name> [--purge]"
    local name="$1" purge="${2:-}" db answer
    load_env
    require_customer "$name"

    info "Removing container $(container_name "$name")"
    docker rm --force "$(container_name "$name")" >/dev/null 2>&1 || true

    if [ "$purge" != "--purge" ]; then
        info "Database, data volume and config of '$name' were kept. Start it again with 'upgrade $name'."
        return 0
    fi

    read -r -p "This deletes the database, uploaded files and config of '$name'. Type the name to confirm: " answer
    [ "$answer" = "$name" ] || die "Not confirmed, nothing else was deleted"

    wait_for_postgres
    db="$(db_name "$name")"
    psql_admin <<SQL
DROP DATABASE IF EXISTS "$db" WITH (FORCE);
DROP ROLE IF EXISTS "$db";
SQL
    docker volume rm "$(volume_name "$name")" >/dev/null 2>&1 || true
    rm -rf "${CUSTOMERS_DIR:?}/$name"
    info "Customer '$name' deleted. Backups in $BACKUPS_DIR/$name were kept."
    if [ "$PROXY" = "nginx" ]; then
        info "Remove its server block from nginx as well."
    fi
}

main() {
    [ $# -ge 1 ] || { usage; exit 1; }
    local command="$1"
    shift
    case "$command" in
        init) cmd_init "$@" ;;
        add) cmd_add "$@" ;;
        import) cmd_import "$@" ;;
        list) cmd_list "$@" ;;
        upgrade) cmd_upgrade "$@" ;;
        backup) cmd_backup "$@" ;;
        restore) cmd_restore "$@" ;;
        remove) cmd_remove "$@" ;;
        -h|--help|help) usage ;;
        *) usage; exit 1 ;;
    esac
}

main "$@"