Projektarbeit-MYP/backend/app/install_raspberry_pi.sh

#!/bin/bash

# ===================================================================
# Raspberry Pi Vollautomatische Installation - MYP Druckerverwaltung
# Für Debian 12 (Bookworm) auf Raspberry Pi
# Nach offizieller Raspberry Pi Kiosk-Anleitung optimiert
# ===================================================================

set -e  # Beende bei Fehlern

# Farben für Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Logging-Funktion
log() {
    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"
}

error() {
    echo -e "${RED}[FEHLER] $1${NC}"
    exit 1
}

warning() {
    echo -e "${YELLOW}[WARNUNG] $1${NC}"
}

info() {
    echo -e "${BLUE}[INFO] $1${NC}"
}

# Prüfe ob als Root ausgeführt
if [ "$EUID" -ne 0 ]; then
    error "Dieses Skript muss als Root ausgeführt werden. Verwende: sudo $0"
fi

log "=== MYP Druckerverwaltung - Raspberry Pi Installation ==="
log "Debian 12 (Bookworm) Kiosk-Modus nach offizieller Anleitung"
echo

# Konfigurationsvariablen
APP_USER="myp"
KIOSK_USER="kiosk"
APP_DIR="/opt/myp-druckerverwaltung"
SERVICE_NAME="myp-druckerverwaltung"
KIOSK_SERVICE_NAME="myp-kiosk"
KIOSK_URL="http://localhost"

# Bereinige unbenötigte Pakete (entsprechend offizieller Anleitung)
log "Entferne unbenötigte Pakete zur Speicheroptimierung..."
export DEBIAN_FRONTEND=noninteractive
apt-get purge -y wolfram-engine scratch scratch2 nuscratch sonic-pi idle3 smartsim java-common minecraft-pi libreoffice* || true
apt-get autoremove -y
apt-get clean

# Systemupdate
log "Aktualisiere Paketlisten und System..."
apt-get update -y
apt-get upgrade -y --allow-downgrades --allow-remove-essential --allow-change-held-packages

# Installiere erforderliche Pakete (nach offizieller Anleitung)
log "Installiere Systempakete für Kiosk-Modus..."
apt-get install -y \
    python3 \
    python3-pip \
    python3-venv \
    python3-dev \
    git \
    curl \
    wget \
    unzip \
    sqlite3 \
    nginx \
    supervisor \
    chromium-browser \
    xorg \
    openbox \
    lightdm \
    x11-xserver-utils \
    xdotool \
    unclutter \
    sed \
    build-essential \
    libssl-dev \
    libffi-dev \
    libjpeg-dev \
    zlib1g-dev \
    nodejs \
    npm \
    --no-install-recommends || true

# Erstelle Anwendungsbenutzer
log "Erstelle Anwendungsbenutzer '$APP_USER'..."
if ! id "$APP_USER" &>/dev/null; then
    useradd -m -s /bin/bash "$APP_USER"
    usermod -aG sudo "$APP_USER"
    log "Benutzer '$APP_USER' erstellt"
else
    log "Benutzer '$APP_USER' existiert bereits"
fi

# Erstelle Kiosk-Benutzer (nach offizieller Anleitung)
log "Erstelle Kiosk-Benutzer '$KIOSK_USER'..."
if ! id "$KIOSK_USER" &>/dev/null; then
    useradd -m -s /bin/bash "$KIOSK_USER"
    usermod -aG audio,video "$KIOSK_USER"
    log "Benutzer '$KIOSK_USER' erstellt"
else
    log "Benutzer '$KIOSK_USER' existiert bereits"
fi

# Erstelle Anwendungsverzeichnis
log "Erstelle Anwendungsverzeichnis..."
mkdir -p "$APP_DIR"
chown "$APP_USER:$APP_USER" "$APP_DIR"

# Kopiere Anwendung
if [ ! -d "$APP_DIR/.git" ]; then
    log "Kopiere Anwendung..."
    if [ -f "app.py" ]; then
        log "Kopiere lokale Anwendung..."
        cp -r . "$APP_DIR/"
        chown -R "$APP_USER:$APP_USER" "$APP_DIR"
    else
        error "Anwendungsdateien nicht gefunden. Führe das Skript im Anwendungsverzeichnis aus."
    fi
else
    log "Anwendung bereits vorhanden, aktualisiere..."
    cd "$APP_DIR"
    sudo -u "$APP_USER" git pull
fi

cd "$APP_DIR"

# Python Virtual Environment erstellen
log "Erstelle Python Virtual Environment..."
sudo -u "$APP_USER" python3 -m venv venv
sudo -u "$APP_USER" ./venv/bin/pip install --upgrade pip

# Installiere Python-Abhängigkeiten
log "Installiere Python-Abhängigkeiten..."
if [ -f "requirements.txt" ]; then
    sudo -u "$APP_USER" ./venv/bin/pip install -r requirements.txt
else
    # Fallback: Installiere grundlegende Pakete
    sudo -u "$APP_USER" ./venv/bin/pip install \
        flask \
        flask-login \
        flask-sqlalchemy \
        werkzeug \
        requests \
        python-dotenv \
        gunicorn
fi

# Node.js Abhängigkeiten installieren
if [ -f "package.json" ]; then
    log "Installiere Node.js Abhängigkeiten..."
    sudo -u "$APP_USER" npm install
    
    # Baue Frontend-Assets
    if [ -f "tailwind.config.js" ]; then
        log "Baue Frontend-Assets..."
        sudo -u "$APP_USER" npm run build || true
    fi
fi

# Datenbank initialisieren
log "Initialisiere Datenbank..."
if [ -f "init_db.py" ]; then
    sudo -u "$APP_USER" ./venv/bin/python init_db.py
else
    sudo -u "$APP_USER" touch database.db
fi

# Erstelle Konfigurationsdatei
log "Erstelle Anwendungskonfiguration..."
cat > "$APP_DIR/.env" << EOF
# MYP Druckerverwaltung Konfiguration
FLASK_ENV=production
SECRET_KEY=$(openssl rand -hex 32)
DATABASE_URL=sqlite:///database.db
HOST=0.0.0.0
PORT=5000
DEBUG=False

# Kiosk-Modus
KIOSK_MODE=true
AUTO_LOGIN=true
EOF

chown "$APP_USER:$APP_USER" "$APP_DIR/.env"

# Erstelle Kiosk-Skript (nach offizieller Anleitung)
log "Erstelle Kiosk-Skript..."
cat > "/home/$KIOSK_USER/kiosk.sh" << EOF
#!/bin/bash

# Warte auf System-Bereitschaft
sleep 5

# Setze Display-Umgebung
export DISPLAY=:0

# Deaktiviere Bildschirmschoner (nach offizieller Anleitung)
xset s noblank
xset s off
xset -dpms

# Verstecke Mauszeiger
unclutter -idle 0.5 -root &

# Bereinige Chromium-Präferenzen (verhindert Crash-Warnungen)
sed -i 's/"exited_cleanly":false/"exited_cleanly":true/' /home/$KIOSK_USER/.config/chromium/Default/Preferences 2>/dev/null || true
sed -i 's/"exit_type":"Crashed"/"exit_type":"Normal"/' /home/$KIOSK_USER/.config/chromium/Default/Preferences 2>/dev/null || true

# Warte auf Netzwerk und Anwendung
while ! curl -s http://localhost > /dev/null; do
    echo "Warte auf Anwendung..."
    sleep 2
done

# Starte Chromium im Kiosk-Modus (nach offizieller Anleitung)
/usr/bin/chromium-browser \\
    --noerrdialogs \\
    --disable-infobars \\
    --kiosk \\
    --no-sandbox \\
    --disable-web-security \\
    --disable-features=TranslateUI \\
    --disable-ipc-flooding-protection \\
    --disable-renderer-backgrounding \\
    --disable-backgrounding-occluded-windows \\
    --disable-background-timer-throttling \\
    --disable-background-networking \\
    --disable-breakpad \\
    --disable-component-extensions-with-background-pages \\
    --disable-dev-shm-usage \\
    --disable-extensions \\
    --disable-features=TranslateUI,BlinkGenPropertyTrees \\
    --disable-hang-monitor \\
    --disable-popup-blocking \\
    --disable-prompt-on-repost \\
    --disable-sync \\
    --disable-translate \\
    --force-color-profile=srgb \\
    --no-first-run \\
    --autoplay-policy=no-user-gesture-required \\
    --start-fullscreen \\
    $KIOSK_URL &

# Optional: Automatische Tab-Rotation (auskommentiert)
# while true; do
#     sleep 30
#     xdotool keydown ctrl+r; xdotool keyup ctrl+r;  # Seite neu laden
# done
EOF

chmod +x "/home/$KIOSK_USER/kiosk.sh"
chown "$KIOSK_USER:$KIOSK_USER" "/home/$KIOSK_USER/kiosk.sh"

# Konfiguriere LightDM für automatischen Login (nach offizieller Anleitung)
log "Konfiguriere automatischen Login..."
cat > "/etc/lightdm/lightdm.conf" << EOF
[Seat:*]
autologin-user=$KIOSK_USER
autologin-user-timeout=0
user-session=openbox
xserver-command=X -s 0 -dpms
EOF

# Erstelle Openbox-Konfiguration für Kiosk-Benutzer
log "Konfiguriere Openbox für Kiosk-Modus..."
mkdir -p "/home/$KIOSK_USER/.config/openbox"
cat > "/home/$KIOSK_USER/.config/openbox/autostart" << EOF
# Starte Kiosk-Anwendung automatisch
/home/$KIOSK_USER/kiosk.sh &
EOF

chown -R "$KIOSK_USER:$KIOSK_USER" "/home/$KIOSK_USER/.config"

# Erstelle Systemd-Service für die Anwendung
log "Erstelle Systemd-Service für Anwendung..."
cat > "/etc/systemd/system/$SERVICE_NAME.service" << EOF
[Unit]
Description=MYP Druckerverwaltung Flask Application
After=network.target

[Service]
Type=simple
User=$APP_USER
Group=$APP_USER
WorkingDirectory=$APP_DIR
Environment=PATH=$APP_DIR/venv/bin
ExecStart=$APP_DIR/venv/bin/python app.py
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

# Erstelle Systemd-Service für Kiosk (nach offizieller Anleitung)
log "Erstelle Systemd-Service für Kiosk..."
cat > "/etc/systemd/system/$KIOSK_SERVICE_NAME.service" << EOF
[Unit]
Description=MYP Chromium Kiosk
Wants=graphical.target
After=graphical.target $SERVICE_NAME.service

[Service]
Environment=DISPLAY=:0.0
Environment=XAUTHORITY=/home/$KIOSK_USER/.Xauthority
Type=simple
ExecStart=/bin/bash /home/$KIOSK_USER/kiosk.sh
Restart=on-abort
User=$KIOSK_USER
Group=$KIOSK_USER

[Install]
WantedBy=graphical.target
EOF

# Nginx-Konfiguration
log "Konfiguriere Nginx..."
cat > "/etc/nginx/sites-available/myp-druckerverwaltung" << EOF
server {
    listen 80 default_server;
    listen [::]:80 default_server;
    
    server_name _;
    
    location / {
        proxy_pass http://127.0.0.1:5000;
        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;
        
        # WebSocket-Support
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
    }
    
    # Statische Dateien direkt servieren
    location /static/ {
        alias $APP_DIR/static/;
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}
EOF

# Aktiviere Nginx-Site
rm -f /etc/nginx/sites-enabled/default
ln -sf /etc/nginx/sites-available/myp-druckerverwaltung /etc/nginx/sites-enabled/

# Erstelle Wartungsskript
log "Erstelle Wartungsskript..."
cat > "/usr/local/bin/myp-maintenance" << 'EOF'
#!/bin/bash

# MYP Druckerverwaltung Wartungsskript

case "$1" in
    start)
        echo "Starte MYP Druckerverwaltung..."
        systemctl start myp-druckerverwaltung
        systemctl start nginx
        systemctl start myp-kiosk
        ;;
    stop)
        echo "Stoppe MYP Druckerverwaltung..."
        systemctl stop myp-kiosk
        systemctl stop myp-druckerverwaltung
        systemctl stop nginx
        ;;
    restart)
        echo "Starte MYP Druckerverwaltung neu..."
        systemctl restart myp-druckerverwaltung
        systemctl restart nginx
        systemctl restart myp-kiosk
        ;;
    status)
        echo "=== MYP Druckerverwaltung Status ==="
        systemctl status myp-druckerverwaltung --no-pager
        echo
        echo "=== Nginx Status ==="
        systemctl status nginx --no-pager
        echo
        echo "=== Kiosk Status ==="
        systemctl status myp-kiosk --no-pager
        ;;
    logs)
        echo "=== Anwendungslogs ==="
        journalctl -u myp-druckerverwaltung -f
        ;;
    kiosk-logs)
        echo "=== Kiosk-Logs ==="
        journalctl -u myp-kiosk -f
        ;;
    update)
        echo "Aktualisiere MYP Druckerverwaltung..."
        cd /opt/myp-druckerverwaltung
        sudo -u myp git pull
        sudo -u myp ./venv/bin/pip install -r requirements.txt
        systemctl restart myp-druckerverwaltung
        ;;
    kiosk-restart)
        echo "Starte nur Kiosk neu..."
        systemctl restart myp-kiosk
        ;;
    *)
        echo "Verwendung: $0 {start|stop|restart|status|logs|kiosk-logs|update|kiosk-restart}"
        exit 1
        ;;
esac
EOF

chmod +x /usr/local/bin/myp-maintenance

# Erstelle Backup-Skript
log "Erstelle Backup-Skript..."
cat > "/usr/local/bin/myp-backup" << 'EOF'
#!/bin/bash

BACKUP_DIR="/opt/myp-backups"
DATE=$(date +%Y%m%d_%H%M%S)
APP_DIR="/opt/myp-druckerverwaltung"

mkdir -p "$BACKUP_DIR"

echo "Erstelle Backup: $DATE"

# Stoppe Anwendung
systemctl stop myp-druckerverwaltung

# Erstelle Backup
tar -czf "$BACKUP_DIR/myp_backup_$DATE.tar.gz" \
    -C "$APP_DIR" \
    database.db \
    .env \
    uploads/ \
    logs/ 2>/dev/null || true

# Starte Anwendung
systemctl start myp-druckerverwaltung

echo "Backup erstellt: $BACKUP_DIR/myp_backup_$DATE.tar.gz"

# Lösche alte Backups (älter als 30 Tage)
find "$BACKUP_DIR" -name "myp_backup_*.tar.gz" -mtime +30 -delete
EOF

chmod +x /usr/local/bin/myp-backup

# Erstelle Cron-Job für automatische Backups
echo "0 2 * * * root /usr/local/bin/myp-backup" > /etc/cron.d/myp-backup

# Aktiviere und starte Services
log "Aktiviere und starte Services..."
systemctl daemon-reload
systemctl enable "$SERVICE_NAME"
systemctl enable nginx
systemctl enable "$KIOSK_SERVICE_NAME"

# Starte Services
systemctl start "$SERVICE_NAME"
systemctl start nginx

# Warte kurz und prüfe Status
sleep 5

if systemctl is-active --quiet "$SERVICE_NAME"; then
    log "✅ MYP Druckerverwaltung Service läuft"
else
    warning "⚠️  MYP Druckerverwaltung Service nicht aktiv"
fi

if systemctl is-active --quiet nginx; then
    log "✅ Nginx läuft"
else
    warning "⚠️  Nginx nicht aktiv"
fi

# Konfiguriere Firewall (falls ufw installiert)
if command -v ufw &> /dev/null; then
    log "Konfiguriere Firewall..."
    ufw --force enable
    ufw allow 80/tcp
    ufw allow 22/tcp
fi

# Abschlussmeldung
log "=== Installation abgeschlossen! ==="
echo
info "🎉 MYP Druckerverwaltung wurde erfolgreich installiert!"
echo
info "📋 Wichtige Informationen:"
info "   • Anwendung läuft auf: http://$(hostname -I | awk '{print $1}')"
info "   • Anwendungsverzeichnis: $APP_DIR"
info "   • Anwendungsbenutzer: $APP_USER"
info "   • Kiosk-Benutzer: $KIOSK_USER"
info "   • Service-Name: $SERVICE_NAME"
info "   • Kiosk-Service: $KIOSK_SERVICE_NAME"
echo
info "🔧 Wartungskommandos:"
info "   • Status prüfen: myp-maintenance status"
info "   • Neustart: myp-maintenance restart"
info "   • Logs anzeigen: myp-maintenance logs"
info "   • Kiosk-Logs: myp-maintenance kiosk-logs"
info "   • Nur Kiosk neustarten: myp-maintenance kiosk-restart"
info "   • Update: myp-maintenance update"
info "   • Backup erstellen: myp-backup"
echo
info "🖥️  Kiosk-Modus (nach offizieller Raspberry Pi Anleitung):"
info "   • Automatischer Login als '$KIOSK_USER' Benutzer"
info "   • Chromium-Browser im Vollbild-Kiosk-Modus"
info "   • Automatische Anzeige von $KIOSK_URL"
info "   • Versteckter Mauszeiger"
info "   • Deaktivierte Bildschirmschoner"
echo
info "🔍 Zusätzliche Konfiguration:"
info "   • Kiosk-Skript: /home/$KIOSK_USER/kiosk.sh"
info "   • LightDM-Konfiguration: /etc/lightdm/lightdm.conf"
info "   • Openbox-Autostart: /home/$KIOSK_USER/.config/openbox/autostart"
echo
warning "⚠️  Wichtiger Hinweis:"
warning "   Starte das System neu, um den Kiosk-Modus zu aktivieren:"
warning "   sudo reboot"
echo
log "Installation erfolgreich abgeschlossen! 🚀"