#!/usr/bin/env bash
#
# rhel8-setup.sh
# -----------------------------------------------------------------------------
# Unbeaufsichtigte Nachkonfiguration eines frisch installierten RHEL8-Systems
# zur Vorbereitung einer abas-ERP-Installation. Alle Optionen werden im
# KONFIGURATIONS-Block (unten) gesetzt.
#
# Aufruf (nach der RHEL-Grundinstallation, als root):
#   wget -O rhel8-setup.sh <URL>
#   # Konfig-Block anpassen, dann:
#   chmod +x rhel8-setup.sh
#   ./rhel8-setup.sh
#
# Idempotent: ein zweiter Lauf überspringt bereits erledigte Schritte.
# Mit DRY_RUN=1 ./rhel8-setup.sh werden destruktive Befehle nur
# angezeigt, nicht ausgeführt.
# -----------------------------------------------------------------------------

set -u

# #############################################################################
# ##############################  KONFIGURATION  ##############################
# #############################################################################

# ---- Feature-Schalter (yes/no) ---------------------------------------------
ENABLE_EPEL=yes
ENABLE_PACKAGES=yes
ENABLE_DISKS=yes
ENABLE_JAVA8=yes
ENABLE_JAVA17=yes            # ab abas2024.Q3
ENABLE_WEBMIN=yes
ENABLE_VMTOUCH=yes
ENABLE_DOCKER=yes
ENABLE_XINETD=yes
ENABLE_SERVICES_FILE=yes     # /etc/services ergänzen
ENABLE_LIMITS=yes
ENABLE_LIBLINKS=yes          # Kompat-Links für ältere abas-Versionen
ENABLE_SSH=yes               # PermitRootLogin yes / StrictModes no
ENABLE_REDROOT=yes           # roter root-Prompt
ENABLE_SYSCTL=yes
ENABLE_HOSTS=yes
ENABLE_SELINUX=yes           # SELinux deaktivieren
ENABLE_SERVICE_STATE=yes     # firewalld/smartd aus, samba an
AUTO_REBOOT=no               # am Ende automatisch neu starten

# ---- abas-Basispfad (für Java-Symlinks) ------------------------------------
ABAS_BASE="/mnt1"

# ---- Docker ----------------------------------------------------------------
DOCKER_COMPOSE_STANDALONE=yes  # legacy docker-compose-Binary (von abas benötigt)
DOCKER_COMPOSE_VERSION=""      # leer = immer neueste; sonst z.B. v5.1.2 zum Pinnen

# ---- Datenplatten ----------------------------------------------------------
# Pro Platte ein Eintrag:  "GERÄT|VG|LV|MOUNTPOINT|FS"
#   GERÄT     : /dev/sdb  ODER  eine Größe wie "200G" (erste freie Platte dieser Größe)
#   FS        : xfs | ext4
# Beispiele:
DATA_DISKS=(
    "200G|abas1|abas-data|/mnt1|xfs"
    # "500G|abas2|abas-backup|/backup|xfs"
    # "/dev/sdc|abas3|abas-data2|/mnt2|ext4"
)

# #############################################################################
# ##########################  AB HIER NICHTS ÄNDERN  ##########################
# #############################################################################

C_R='\033[01;31m'; C_G='\033[01;32m'; C_Y='\033[01;33m'; C_B='\033[01;34m'; C_0='\033[00m'
log()  { echo -e "${C_G}[*]${C_0} $*"; }
warn() { echo -e "${C_Y}[!]${C_0} $*" >&2; }
err()  { echo -e "${C_R}[x]${C_0} $*" >&2; }
die()  { err "$*"; exit 1; }
hr()   { echo -e "${C_B}--------------------------------------------------------------${C_0}"; }
on()   { [ "${!1:-no}" = "yes" ]; }

DRY_RUN="${DRY_RUN:-0}"
run() {
    if [ "$DRY_RUN" = "1" ]; then echo -e "${C_Y}DRY-RUN:${C_0} $*"; else "$@"; fi
}

preflight() {
    [ "$(id -u)" -eq 0 ] || die "Bitte als root ausführen."
    if [ -r /etc/redhat-release ] && ! grep -qiE 'release 8' /etc/redhat-release; then
        warn "Dies scheint kein RHEL 8 zu sein: $(cat /etc/redhat-release)"
    fi
    [ "$DRY_RUN" = "1" ] && warn "DRY-RUN aktiv – es werden KEINE Änderungen vorgenommen."
}

# ============================ EPEL ===========================================
enable_epel() {
    hr; log "EPEL-Repository aktivieren"
    run subscription-manager repos --enable "codeready-builder-for-rhel-8-$(arch)-rpms" \
        || warn "CodeReady-Repo konnte nicht aktiviert werden."
    if ! rpm -q epel-release >/dev/null 2>&1; then
        run yum -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm \
            || warn "epel-release konnte nicht installiert werden."
    else
        log "epel-release bereits installiert."
    fi
}

# ============================ Pakete =========================================
ABAS_PACKAGES=(
    net-tools ntsysv gdb cpp glibc mc nano screen xinetd Xvfb jq numad git lsof
    mlocate incron glibc.i686 vim-common time iotop htop pigz sysstat rsync
    perl-Net-SSLeay 'krb*' 'pdf*' 'guten*' 'hpli*' 'compat*' gcc parallel
    'cups-lpd*' 'cups-pdf*' 'cups-dev*' 'cups-pk*' 'psutils*' 'samba*' cifs-utils
    open-vm-tools acpid wget ncdu make gzip nmap zip libtool openvpn btop
    network-scripts moreutils langpacks-en glibc-all-langpacks python3 python3-pip
    bpytop fail2ban xorriso nfs-utils kernel-devel squashfs-tools sudo nload
    automake autoconf ghostscript poppler-utils netpbm netpbm-progs glibc-devel
    libXtst.x86_64 ncurses-compat-libs bc gawk cups cups-filters samba-client perl
    'perl(Digest::MD5)' bind-utils strace readline-devel ncurses-devel
    cyrus-sasl-devel pam-devel e2fsprogs-devel libacl-devel openldap-devel gcc-c++
    libuuid-devel net-snmp net-snmp-utils langpacks-de chrony yum-utils psmisc lvm2
    stunnel realmd sssd-ad samba-winbind samba-winbind-clients sssd-winbind-idmap
    sssd-tools sendEmail sqlite yamllint rsyslog pdftk telnet tmux fpart
)
install_packages() {
    hr; log "Standard-Pakete installieren (das dauert ein paar Minuten)"
    run yum -y update || warn "yum update meldete Fehler – fahre fort."
    run yum -y install --skip-broken "${ABAS_PACKAGES[@]}" \
        || warn "Einige Pakete konnten nicht installiert werden (siehe oben)."
}

# ============================ Datenplatten ===================================
disk_protected() {
    local d="$1"
    lsblk -nr -o MOUNTPOINT "/dev/$d" 2>/dev/null | grep -q . && return 0
    lsblk -nr -o FSTYPE "/dev/$d" 2>/dev/null | grep -qi 'swap' && return 0
    pvs --noheadings -o pv_name 2>/dev/null | grep -q "/dev/${d}" && return 0
    return 1
}

first_partition() {
    local d="$1" p
    p=$(lsblk -nr -o NAME,TYPE "/dev/$d" | awk '$2=="part"{print $1; exit}')
    [ -n "$p" ] && echo "/dev/$p"
}

# Löst GERÄT-Spezifikation auf: /dev/... direkt, sonst Größe -> erste freie Platte.
resolve_disk() {
    local spec="$1"
    if [[ "$spec" == /dev/* ]]; then
        local d="${spec#/dev/}"
        if disk_protected "$d"; then err "Platte $spec ist in Benutzung."; return 1; fi
        echo "$d"; return 0
    fi
    # nach Größe suchen (genaue lsblk-SIZE-Anzeige, z.B. "200G")
    local d
    while read -r d; do
        if [ "$(lsblk -dn -o SIZE "/dev/$d")" = "$spec" ] && ! disk_protected "$d"; then
            if ! lsblk -nr -o NAME "/dev/$d" | grep -qv "^${d}$"; then  # keine vorhandenen Partitionen
                echo "$d"; return 0
            fi
        fi
    done < <(lsblk -dn -o NAME,TYPE | awk '$2=="disk"{print $1}')
    err "Keine freie unpartitionierte Platte mit Größe '$spec' gefunden."
    return 1
}

setup_data_disk() {  # dev mountpoint fs vg lv
    local dev="$1" mp="$2" fs="$3" vg="$4" lv="$5"
    log "Konfiguriere /dev/$dev -> $mp ($fs, VG=$vg LV=$lv)"
    if vgs "$vg" >/dev/null 2>&1; then
        warn "Volume Group '$vg' existiert bereits – überspringe."; return
    fi
    run parted -s "/dev/$dev" mklabel gpt mkpart primary 0% 100% || die "parted fehlgeschlagen."
    run partprobe "/dev/$dev"; run udevadm settle; sleep 1
    local part; part=$(first_partition "$dev")
    [ -n "$part" ] || die "Konnte Partition auf /dev/$dev nicht ermitteln."
    run pvcreate -y "$part"               || die "pvcreate fehlgeschlagen."
    run vgcreate "$vg" "$part"            || die "vgcreate fehlgeschlagen."
    run lvcreate -y -n "$lv" -l 100%FREE "$vg" || die "lvcreate fehlgeschlagen."
    local lvpath="/dev/$vg/$lv"
    if [ "$fs" = "ext4" ]; then run mkfs.ext4 -F "$lvpath" || die "mkfs.ext4 fehlgeschlagen."
    else                        run mkfs.xfs  -f "$lvpath" || die "mkfs.xfs fehlgeschlagen."; fi
    run mkdir -p "$mp"
    run mount "$lvpath" "$mp" || die "mount fehlgeschlagen."
    if [ "$DRY_RUN" != "1" ]; then
        local uuid; uuid=$(blkid -s UUID -o value "$lvpath")
        if ! grep -q "$uuid" /etc/fstab 2>/dev/null; then
            cp -a /etc/fstab "/etc/fstab.bak.$(date +%s)"
            printf '\n# abas Daten (%s)\nUUID=%s  %s  %s  defaults  0 2\n' "$lv" "$uuid" "$mp" "$fs" >> /etc/fstab
            log "fstab-Eintrag für $mp ergänzt."
        fi
    fi
}

configure_disks() {
    hr; log "Datenplatten konfigurieren"
    local entry dev vg lv mp fs spec
    for entry in "${DATA_DISKS[@]}"; do
        IFS='|' read -r spec vg lv mp fs <<< "$entry"
        [ "$fs" = "ext4" ] || fs="xfs"
        dev=$(resolve_disk "$spec") || { warn "Überspringe Eintrag: $entry"; continue; }
        setup_data_disk "$dev" "$mp" "$fs" "$vg" "$lv"
    done
}

# ============================ Java ===========================================
install_java() {  # version
    local ver="$1"
    hr; log "Java $ver (OpenJDK) installieren"
    if [ "$ver" = "17" ]; then
        run yum -y install java-17-openjdk.x86_64 java-17-openjdk-devel || warn "Java 17 Install-Fehler."
        run ln -sfn /usr/lib/jvm/java-17-openjdk "${ABAS_BASE}/java17"
    else
        run yum -y install java-1.8.0-openjdk.x86_64 java-1.8.0-openjdk-devel || warn "Java 8 Install-Fehler."
        run ln -sfn /usr/lib/jvm/java-1.8.0-openjdk "${ABAS_BASE}/java8"
    fi
}

# ============================ Webmin / vmtouch ===============================
install_webmin() {
    hr; log "Webmin installieren"
    if rpm -q webmin >/dev/null 2>&1; then log "Webmin bereits installiert."; return; fi
    run bash -c 'curl -fsSL -o /tmp/setup-repos.sh https://raw.githubusercontent.com/webmin/webmin/master/setup-repos.sh && yes | sh /tmp/setup-repos.sh' \
        || warn "Webmin-Repo-Setup fehlgeschlagen."
    run yum -y install webmin || warn "Webmin-Installation fehlgeschlagen."
}
install_vmtouch() {
    hr; log "vmtouch installieren"
    if command -v vmtouch >/dev/null 2>&1; then log "vmtouch bereits installiert."; return; fi
    run bash -c 'cd /tmp && rm -rf vmtouch && git clone https://github.com/hoytech/vmtouch.git && cd vmtouch && make && make install && cd /tmp && rm -rf vmtouch' \
        || warn "vmtouch-Installation fehlgeschlagen."
}

# ============================ Docker (RHEL) ==================================
configure_docker_daemon() {
    log "Docker daemon.json (abas-Empfehlung) schreiben"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/docker/daemon.json schreiben"; return; }
    mkdir -p /etc/docker
    [ -f /etc/docker/daemon.json ] && cp -a /etc/docker/daemon.json "/etc/docker/daemon.json.bak.$(date +%s)"
    cat > /etc/docker/daemon.json <<'EOF'
{
  "bip": "172.31.0.1/24",
  "default-address-pools": [
    {"base":"172.31.1.0/16","size":24}
  ],
  "log-driver": "json-file",
  "log-opts": {"max-size":"50m","max-file":"5"}
}
EOF
    systemctl restart docker 2>/dev/null || warn "docker-Neustart fehlgeschlagen."
}

install_docker() {
    hr; log "Docker installieren (RHEL)"
    if command -v docker >/dev/null 2>&1; then
        log "docker-Binary bereits vorhanden – überspringe Installation."
    else
        run bash -c 'dnf -y remove docker docker-client docker-client-latest docker-common \
            docker-latest docker-latest-logrotate docker-logrotate docker-engine podman runc 2>/dev/null' || true
        run dnf -y install dnf-plugins-core || warn "dnf-plugins-core Install-Fehler."
        run dnf config-manager --add-repo https://download.docker.com/linux/rhel/docker-ce.repo \
            || warn "Docker-Repo konnte nicht hinzugefügt werden."
        run dnf -y install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin \
            || warn "Docker-Installation fehlgeschlagen."
        run systemctl enable --now docker || warn "docker-Dienst nicht aktivierbar."
    fi
    configure_docker_daemon

    if on DOCKER_COMPOSE_STANDALONE; then
        local arch url
        arch=$(uname -m)
        if [ -n "$DOCKER_COMPOSE_VERSION" ]; then
            url="https://github.com/docker/compose/releases/download/${DOCKER_COMPOSE_VERSION}/docker-compose-linux-${arch}"
        else
            # GitHub-Weiterleitung auf das jeweils neueste Release-Asset
            url="https://github.com/docker/compose/releases/latest/download/docker-compose-linux-${arch}"
        fi
        run bash -c "curl -fsSL '${url}' -o /usr/bin/docker-compose && chmod +x /usr/bin/docker-compose" \
            && { [ "$DRY_RUN" = "1" ] || log "docker-compose installiert: $(docker-compose version 2>/dev/null | head -1)"; } \
            || warn "docker-compose Standalone Download fehlgeschlagen."
    fi
}

# ============================ Dienst-/System-Konfig ==========================
configure_xinetd() {
    hr; log "xinetd konfigurieren"
    local f=/etc/xinetd.conf
    [ -f "$f" ] || { warn "$f fehlt (xinetd installiert?)."; return; }
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde $f anpassen"; return; }
    cp -a "$f" "${f}.bak.$(date +%s)"
    _set_xinetd() {
        local k="$1" v="$2"
        if grep -qE "^[[:space:]]*#?[[:space:]]*${k}[[:space:]]*=" "$f"; then
            sed -i -E "s|^([[:space:]]*)#?[[:space:]]*${k}[[:space:]]*=.*|\1${k} = ${v}|" "$f"
        else
            sed -i "0,/{/s//{\n\t${k} = ${v}/" "$f"
        fi
    }
    _set_xinetd "max_load" ""; _set_xinetd "cps" "10000 1"; _set_xinetd "instances" "UNLIMITED"; _set_xinetd "per_source" "UNLIMITED"
    run systemctl restart xinetd || warn "xinetd-Neustart fehlgeschlagen."
}

configure_services() {
    hr; log "/etc/services ergänzen"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/services ergänzen"; return; }
    if ! grep -q "^datmod" /etc/services; then
        cp -a /etc/services "/etc/services.bak.$(date +%s)"
        cat >> /etc/services <<'EOF'

# ABAS Konfiguration
datmod      48392/tcp   datmod   # Hilfsprogramm zum Starten des Anwendungsservers
edp_s3      6550/tcp    edp      # EDP-Server fuer alle Mandanten im HOMEDIR
EOF
        log "abas-Ports ergänzt."
    else
        log "abas-Ports bereits vorhanden."
    fi
}

configure_limits() {
    hr; log "Systemlimits setzen (/etc/security/limits.conf)"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/security/limits.conf ergänzen"; return; }
    # evtl. früher angelegtes Drop-in entfernen (Limits stehen jetzt direkt in limits.conf)
    if [ -f /etc/security/limits.d/50-abas.conf ]; then
        rm -f /etc/security/limits.d/50-abas.conf
        log "Altes Drop-in limits.d/50-abas.conf entfernt."
    fi
    local f=/etc/security/limits.conf
    if grep -q '# abas limits' "$f" 2>/dev/null; then
        log "abas-Limits bereits in limits.conf vorhanden."; return
    fi
    cp -a "$f" "${f}.bak.$(date +%s)"
    # Block vor "# End of file" einfügen, sonst am Dateiende anhängen
    awk '
        /^# End of file/ && !done {
            print "# abas limits"
            print "*   soft   core      unlimited"
            print "*   -      rss       unlimited"
            print "*   -      nofile    32768"
            print ""
            done=1
        }
        { print }
        END { if (!done) {
            print ""; print "# abas limits"
            print "*   soft   core      unlimited"
            print "*   -      rss       unlimited"
            print "*   -      nofile    32768"
        }}
    ' "$f" > "${f}.tmp" && cat "${f}.tmp" > "$f" && rm -f "${f}.tmp"
    log "abas-Limits in limits.conf ergänzt."
}

configure_libs() {
    hr; log "Kompatibilitäts-Library-Links setzen"
    make_compat_link() {
        local base="$1" old="$2" real
        real=$(find /usr/lib64 -maxdepth 1 -name "${base}.[0-9]*" -printf '%f\n' 2>/dev/null | sort -V | tail -1)
        if [ -n "$real" ]; then run ln -sf "$real" "/usr/lib64/${base}.${old}"; log "  ${base}.${old} -> ${real}"
        else warn "  Keine Datei für ${base} gefunden."; fi
    }
    make_compat_link "libncurses.so" 5
    make_compat_link "libtinfo.so"   5
    make_compat_link "libnsl.so"     1
    make_compat_link "libcurl.so"    3
}

configure_ssh() {
    hr; log "SSH konfigurieren (PermitRootLogin yes, StrictModes no)"
    warn "Hinweis: für die abas-INSTALLATION gedacht – danach ggf. wieder härten."
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde sshd_config anpassen"; return; }
    local f=/etc/ssh/sshd_config
    cp -a "$f" "${f}.bak.$(date +%s)"
    _set_ssh() {
        local k="$1" v="$2"
        if grep -qE "^[[:space:]]*#?[[:space:]]*${k}[[:space:]]+" "$f"; then
            sed -i -E "s|^[[:space:]]*#?[[:space:]]*${k}[[:space:]]+.*|${k} ${v}|" "$f"
        else echo "${k} ${v}" >> "$f"; fi
    }
    _set_ssh "PermitRootLogin" "yes"; _set_ssh "StrictModes" "no"
    run systemctl restart sshd || warn "sshd-Neustart fehlgeschlagen."
}

configure_redroot() {
    hr; log "Roten root-Prompt einrichten"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde profile.d/redrootprompt.sh schreiben"; return; }
    cat > /etc/profile.d/redrootprompt.sh <<'EOF'
## Custom root color
force_color_prompt=yes
if [ "$LOGNAME" = root ] || [ "$(id -u)" -eq 0 ]; then
    PS1='\[\033[01;31m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[01;34m\]#\[\033[00m\] '
else
    PS1='\u@\h:\w\$ '
fi
EOF
    log "redrootprompt.sh geschrieben."
}

configure_sysctl() {
    hr; log "sysctl für abas setzen"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde sysctl.d/50-abas.conf schreiben"; return; }
    cat > /etc/sysctl.d/50-abas.conf <<'EOF'
# sysctl-config for abas
fs.protected_hardlinks = 0
fs.suid_dumpable = 1
kernel.pid_max = 65534
kernel.core_pattern = core.%p
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1
EOF
    run sysctl -p /etc/sysctl.d/50-abas.conf || warn "sysctl -p meldete Fehler."
}

configure_hosts() {
    hr; log "/etc/hosts anpassen"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/hosts anpassen"; return; }
    local ip fqdn short
    ip=$(hostname -I 2>/dev/null | awk '{print $1}')
    fqdn=$(hostname -f 2>/dev/null || hostname)
    short=$(hostname -s 2>/dev/null || hostname)
    cp -a /etc/hosts "/etc/hosts.bak.$(date +%s)"
    sed -i -E 's/^(::1[[:space:]].*)/#\1/' /etc/hosts
    if [ -n "$ip" ] && ! grep -q "$short" /etc/hosts; then
        echo "$ip $short $fqdn" >> /etc/hosts
    fi
    log "/etc/hosts angepasst (IP=$ip, Host=$fqdn)."
}

configure_selinux() {
    hr; log "SELinux deaktivieren"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde SELinux deaktivieren"; return; }
    if [ -f /etc/selinux/config ]; then
        cp -a /etc/selinux/config "/etc/selinux/config.bak.$(date +%s)"
        sed -i -E 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config
        setenforce 0 2>/dev/null || true
        log "SELinux=disabled (greift nach Reboot)."
    fi
}

configure_services_state() {
    hr; log "Dienste aktivieren/deaktivieren"
    run systemctl disable --now firewalld 2>/dev/null || warn "firewalld nicht deaktivierbar."
    run systemctl disable --now smartd    2>/dev/null || warn "smartd nicht deaktivierbar."
    run systemctl enable  --now smb       2>/dev/null || warn "smb nicht aktivierbar."
    run systemctl enable  --now nmb       2>/dev/null || warn "nmb nicht aktivierbar."
}

# ============================ Hauptablauf ====================================
main() {
    preflight
    hr; echo -e "${C_G}senapsa RHEL8 / abas Setup (konfig-gesteuert)${C_0}"; hr

    on ENABLE_EPEL           && enable_epel
    on ENABLE_PACKAGES       && install_packages
    on ENABLE_DISKS          && configure_disks
    on ENABLE_JAVA8          && install_java 8
    on ENABLE_JAVA17         && install_java 17
    on ENABLE_WEBMIN         && install_webmin
    on ENABLE_VMTOUCH        && install_vmtouch
    on ENABLE_DOCKER         && install_docker
    on ENABLE_XINETD         && configure_xinetd
    on ENABLE_SERVICES_FILE  && configure_services
    on ENABLE_LIMITS         && configure_limits
    on ENABLE_LIBLINKS       && configure_libs
    on ENABLE_SSH            && configure_ssh
    on ENABLE_REDROOT        && configure_redroot
    on ENABLE_SYSCTL         && configure_sysctl
    on ENABLE_HOSTS          && configure_hosts
    on ENABLE_SELINUX        && configure_selinux
    on ENABLE_SERVICE_STATE  && configure_services_state

    hr; log "Konfiguration abgeschlossen."
    echo
    echo -e "${C_Y}==============================================================${C_0}"
    echo -e "${C_Y} WICHTIG:${C_0} Bitte den Server NEU STARTEN, damit alle Änderungen"
    echo -e "          (u.a. SELinux, sysctl, Mounts) vollumfänglich wirksam werden."
    echo -e "${C_Y}==============================================================${C_0}"
    echo "Verifikation nach Reboot:  getenforce ; df -h"
    if on AUTO_REBOOT; then log "AUTO_REBOOT=yes -> Neustart..."; run reboot; fi
}

main "$@"