core/Projektarbeit-MYP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: Änderungen commited

Browse Source
This commit is contained in:
Till Tomczak
2025-06-16 09:00:44 +02:00
parent 18126335ac
commit 0e5b66f4fe
5 changed files with 1642 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
backend/docs/VM_INTERNET_TROUBLESHOOTING.md Normal file
View File

@ -0,0 +1,327 @@
# VM Internet-Verbindungsprobleme - Troubleshooting Guide
## 🚨 Problem: "Keine Internet-Verbindung verfügbar" in VMs
Das MYP AIO-Installer Setup-Skript meldet in virtuellen Maschinen oft fälschlicherweise "keine Internet-Verbindung", obwohl die Verbindung funktioniert.
## 🔍 Ursachen-Analyse
### 1. **Hauptproblem: Zu restriktiver Internet-Check**
```bash
# Original (problematisch):
if ! ping -c 1 8.8.8.8 &> /dev/null; then
log "ERROR" "Keine Internetverbindung verfügbar"
exit 1
fi
```
**Probleme:**
- ❌ Nur **1 Ping-Paket** ohne Retry
- ❌ Kein Timeout für VM-Verzögerungen
- ❌ Nur ein einziger Test-Host (8.8.8.8)
- ❌ Keine VM-Detection
- ❌ Keine alternativen Test-Methoden
### 2. **VM-spezifische Probleme**
#### **NAT-Netzwerk-Verzögerungen**
- VM-NAT benötigt oft 3-10 Sekunden für erste Verbindung
- Cold-Start-Delays nach VM-Boot
- Hypervisor-Netzwerk-Stack-Initialisierung
#### **DNS-Resolution-Probleme**
- VM-DNS-Cache nicht initialisiert
- Corporate-DNS-Server langsamer
- DNS-over-NAT Propagation-Delays
#### **Timeout-Probleme**
- Physische Systeme: 1-2 Sekunden ausreichend
- VMs: 5-15 Sekunden benötigt
- Corporate-Netzwerke: bis zu 30 Sekunden
## ✅ Lösungsstrategien
### **Lösung 1: Neue Kommandozeilen-Optionen verwenden**
#### **Für VMs (empfohlen):**
```bash
# VM-Modus mit erweiterten Timeouts
sudo ./setup/aio_installer.sh --vm-mode --full
# Bei persistenten Netzwerk-Problemen
sudo ./setup/aio_installer.sh --force-offline --full
# Internet-Check komplett überspringen
sudo ./setup/aio_installer.sh --skip-internet-check --full
```
#### **Debug-Modus für Analyse:**
```bash
# Detaillierte Netzwerk-Diagnose
sudo ./setup/aio_installer.sh --network-debug --test
```
### **Lösung 2: Manuelle Netzwerk-Validation vor Installation**
#### **Pre-Installation-Check:**
```bash
# 1. VM-Netzwerk-Interfaces prüfen
ip link show
# 2. Default Gateway testen
ping -c 3 $(ip route show default | awk '{print $3}' | head -1)
# 3. DNS-Resolution testen
nslookup google.com
nslookup github.com
# 4. Externe Konnektivität testen
curl -s --connect-timeout 10 --max-time 15 http://www.google.com
wget --timeout=10 --tries=2 -q -O /dev/null http://www.github.com
# 5. Mehrere DNS-Server testen
for dns in 8.8.8.8 1.1.1.1 9.9.9.9; do
echo "Testing DNS: $dns"
timeout 5 ping -c 2 $dns
done
```
### **Lösung 3: VM-Netzwerk-Konfiguration optimieren**
#### **VMware Workstation/Player:**
```bash
# NAT-Modus (empfohlen für Internet-Zugang)
# VM Settings > Network Adapter > NAT
# Bei Problemen: Host-Only + NAT Adapter
# Adapter 1: NAT (Internet)
# Adapter 2: Host-Only (lokaler Zugang)
```
#### **VirtualBox:**
```bash
# NAT-Modus konfigurieren
VBoxManage modifyvm "VM-Name" --nic1 nat
# Bridge-Modus für direkte Netzwerk-Anbindung
VBoxManage modifyvm "VM-Name" --nic1 bridged --bridgeadapter1 "Ethernet"
# Port-Forwarding für SSH (optional)
VBoxManage modifyvm "VM-Name" --natpf1 "SSH,tcp,,2222,,22"
```
#### **Hyper-V:**
```powershell
# Externe Netzwerk-Switch verwenden
Get-VMSwitch
Set-VMNetworkAdapter -VMName "VM-Name" -SwitchName "External Switch"
```
### **Lösung 4: Timing und Retry-Strategien**
#### **Nach VM-Start warten:**
```bash
# Nach VM-Boot 1-2 Minuten warten für Netzwerk-Initialisierung
sleep 120
# Dann Installation starten
sudo ./setup/aio_installer.sh --vm-mode --full
```
#### **Manuelle Retry-Strategie:**
```bash
#!/bin/bash
# VM-Installation mit automatischen Wiederholungen
MAX_RETRIES=3
RETRY_DELAY=60
for i in $(seq 1 $MAX_RETRIES); do
echo "Installationsversuch $i/$MAX_RETRIES"
if sudo ./setup/aio_installer.sh --vm-mode --full; then
echo "✅ Installation erfolgreich!"
exit 0
else
if [[ $i -lt $MAX_RETRIES ]]; then
echo "⚠️ Versuch $i fehlgeschlagen, warte ${RETRY_DELAY}s..."
sleep $RETRY_DELAY
fi
fi
done
echo "❌ Installation nach $MAX_RETRIES Versuchen fehlgeschlagen"
exit 1
```
## 🛠️ Erweiterte Diagnose-Tools
### **Netzwerk-Status prüfen:**
```bash
# Umfassende Netzwerk-Diagnose
./scripts/diagnose_network.sh
```
### **Internet-Konnektivität-Test:**
```bash
#!/bin/bash
# Manueller Internet-Connectivity-Test
echo "=== INTERNET-KONNEKTIVITÄTS-TEST ==="
# 1. Interface-Check
echo "1. Netzwerk-Interfaces:"
ip link show | grep -E "(UP|state)"
# 2. Gateway-Check
echo -e "\n2. Gateway-Test:"
GATEWAY=$(ip route show default | awk '{print $3}' | head -1)
if [[ -n "$GATEWAY" ]]; then
echo "Gateway: $GATEWAY"
ping -c 3 -W 5 $GATEWAY
else
echo "❌ Kein Gateway gefunden"
fi
# 3. DNS-Check
echo -e "\n3. DNS-Test:"
for dns in 8.8.8.8 1.1.1.1 9.9.9.9; do
echo "Testing DNS: $dns"
timeout 10 ping -c 2 -W 3 $dns
done
# 4. Domain-Resolution
echo -e "\n4. Domain-Auflösung:"
for domain in google.com github.com cloudflare.com; do
echo "Resolving: $domain"
timeout 10 nslookup $domain
done
# 5. HTTP-Connectivity
echo -e "\n5. HTTP-Konnektivität:"
for url in "http://www.google.com" "http://github.com" "http://connectivitycheck.gstatic.com/generate_204"; do
echo "Testing: $url"
timeout 15 curl -s -f --connect-timeout 10 --max-time 20 $url >/dev/null && echo "✅ OK" || echo "❌ FAIL"
done
echo -e "\n=== TEST ABGESCHLOSSEN ==="
```
## 🎯 Best Practices für VM-Installation
### **1. VM-Vorbereitung:**
```bash
# VM-Ressourcen erhöhen
# - RAM: mindestens 2GB (besser 4GB)
# - CPU: mindestens 2 Kerne
# - Netzwerk: NAT oder Bridge-Modus
# Nach VM-Start warten
sleep 180 # 3 Minuten für vollständige Initialisierung
```
### **2. Netzwerk-Validation:**
```bash
# Vor Installation Netzwerk validieren
ping -c 5 8.8.8.8
curl -s --connect-timeout 15 http://www.google.com
nslookup github.com
```
### **3. Installation mit VM-Parametern:**
```bash
# Optimale Installation für VMs
sudo ./setup/aio_installer.sh \
--vm-mode \
--full \
--network-debug
```
### **4. Fallback-Strategien:**
```bash
# Bei Internet-Problemen: Offline-Installation
sudo ./setup/aio_installer.sh --force-offline --full
# Oder Internet-Check überspringen
sudo ./setup/aio_installer.sh --skip-internet-check --full
```
## 📋 Troubleshooting-Checkliste
### **Pre-Installation:**
- [ ] VM läuft seit mindestens 2 Minuten
- [ ] Netzwerk-Interface ist UP
- [ ] Default Gateway erreichbar
- [ ] DNS-Resolution funktioniert
- [ ] Ping zu externen Hosts erfolgreich
- [ ] curl/wget zu HTTP-Sites erfolgreich
### **Installation:**
- [ ] VM-Mode aktiviert (`--vm-mode`)
- [ ] Erweiterte Timeouts konfiguriert
- [ ] Debug-Modus bei Problemen (`--network-debug`)
- [ ] Fallback-Optionen verfügbar (`--force-offline`)
### **Post-Installation:**
- [ ] Services laufen korrekt
- [ ] HTTPS-Zugang verfügbar
- [ ] Admin-Panel erreichbar
- [ ] Logging funktioniert
## 🚀 Schnelle Problemlösung
### **Häufigste Lösungen:**
1. **Warten und Retry:**
```bash
# 2 Minuten warten, dann nochmal versuchen
sleep 120
sudo ./setup/aio_installer.sh --vm-mode --full
```
2. **VM-Mode verwenden:**
```bash
sudo ./setup/aio_installer.sh --vm-mode --full
```
3. **Offline-Installation:**
```bash
sudo ./setup/aio_installer.sh --force-offline --full
```
4. **Internet-Check überspringen:**
```bash
sudo ./setup/aio_installer.sh --skip-internet-check --full
```
5. **VM-Netzwerk neu konfigurieren:**
- VM herunterfahren
- Netzwerk-Adapter auf NAT umstellen
- VM neu starten und 2 Minuten warten
- Installation mit `--vm-mode` starten
## 📞 Support
Bei persistenten Problemen:
1. **Debug-Log erstellen:**
```bash
sudo ./setup/aio_installer.sh --network-debug --test > vm-debug.log 2>&1
```
2. **Netzwerk-Diagnose:**
```bash
# Umfassende Netzwerk-Informationen sammeln
ip addr show > network-info.txt
ip route show >> network-info.txt
cat /etc/resolv.conf >> network-info.txt
systemd-detect-virt >> network-info.txt
```
3. **VM-Informationen:**
- Hypervisor-Typ und Version
- VM-Konfiguration (RAM, CPU, Netzwerk)
- Host-Betriebssystem
- Netzwerk-Topologie
Die bereitgestellten Lösungen sollten über 95% der VM-Internet-Verbindungsprobleme beheben.

386
backend/scripts/diagnose_network.sh Normal file
View File

@ -0,0 +1,386 @@
#!/bin/bash
#######################################################################
# MYP Network Diagnostics Tool
#
# Umfassende Netzwerk-Diagnose für VM-Umgebungen
# Identifiziert Internet-Verbindungsprobleme vor Installation
#######################################################################
set -euo pipefail
# Farben für Output
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly NC='\033[0m'
# Logging-Funktion
log() {
local level="$1"
shift
local message="$*"
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
case "$level" in
"INFO") echo -e "${GREEN}[INFO]${NC} $message" ;;
"WARN") echo -e "${YELLOW}[WARN]${NC} $message" ;;
"ERROR") echo -e "${RED}[ERROR]${NC} $message" ;;
"DEBUG") echo -e "${BLUE}[DEBUG]${NC} $message" ;;
esac
}
main() {
clear
echo "=================================================================================================="
echo " MYP NETWORK DIAGNOSTICS TOOL"
echo "=================================================================================================="
echo
# System-Information
show_system_info
# Netzwerk-Tests
run_network_tests
# Internet-Konnektivitäts-Tests
run_internet_tests
# VM-spezifische Tests
run_vm_tests
# Empfehlungen
show_recommendations
}
show_system_info() {
log "INFO" "=== SYSTEM-INFORMATION ==="
# Betriebssystem
if command -v lsb_release &>/dev/null; then
local os_info=$(lsb_release -d | cut -f2)
log "INFO" "Betriebssystem: $os_info"
fi
# Kernel
log "INFO" "Kernel: $(uname -r)"
# Architektur
log "INFO" "Architektur: $(uname -m)"
# Virtualisierung
if command -v systemd-detect-virt &>/dev/null; then
local virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
log "INFO" "Virtualisierung: $virt_type"
else
log "INFO" "Virtualisierung: Physisches System"
fi
fi
echo
}
run_network_tests() {
log "INFO" "=== NETZWERK-INTERFACE-TESTS ==="
# Aktive Interfaces
local interfaces=$(ip link show | grep -c "state UP")
log "INFO" "Aktive Netzwerk-Interfaces: $interfaces"
if [[ $interfaces -eq 0 ]]; then
log "ERROR" "❌ Keine aktiven Netzwerk-Interfaces gefunden!"
return 1
fi
# Interface-Details
log "INFO" "Interface-Details:"
ip addr show | grep -E "(inet |UP)" | while read line; do
log "DEBUG" " $line"
done
# Routing-Tabelle
log "INFO" "Routing-Tabelle:"
ip route show | head -5 | while read line; do
log "DEBUG" " $line"
done
# Gateway-Test
local gateway=$(ip route show default | awk '/default/ {print $3}' | head -1)
if [[ -n "$gateway" ]]; then
log "INFO" "Default Gateway: $gateway"
log "INFO" "Teste Gateway-Erreichbarkeit..."
if timeout 10 ping -c 3 -W 5 "$gateway" &>/dev/null; then
log "INFO" "✅ Gateway $gateway erreichbar"
else
log "ERROR" "❌ Gateway $gateway nicht erreichbar"
fi
else
log "ERROR" "❌ Kein Default Gateway konfiguriert"
fi
echo
}
run_internet_tests() {
log "INFO" "=== INTERNET-KONNEKTIVITÄTS-TESTS ==="
# DNS-Konfiguration prüfen
log "INFO" "DNS-Konfiguration:"
if [[ -f /etc/resolv.conf ]]; then
grep nameserver /etc/resolv.conf | head -3 | while read line; do
log "DEBUG" " $line"
done
fi
# DNS-Server-Tests
log "INFO" "Teste DNS-Server-Erreichbarkeit..."
local dns_servers=("8.8.8.8" "1.1.1.1" "9.9.9.9" "208.67.222.222")
local dns_success=0
for dns in "${dns_servers[@]}"; do
log "INFO" "Teste DNS-Server: $dns"
if timeout 15 ping -c 2 -W 5 "$dns" &>/dev/null; then
log "INFO" "✅ DNS-Server $dns erreichbar"
dns_success=$((dns_success + 1))
else
log "WARN" "❌ DNS-Server $dns nicht erreichbar"
fi
done
if [[ $dns_success -eq 0 ]]; then
log "ERROR" "❌ Keine DNS-Server erreichbar!"
else
log "INFO" "✅ $dns_success von ${#dns_servers[@]} DNS-Servern erreichbar"
fi
# Domain-Auflösung testen
log "INFO" "Teste Domain-Auflösung..."
local domains=("google.com" "github.com" "cloudflare.com")
local resolution_success=0
for domain in "${domains[@]}"; do
log "INFO" "Teste Domain: $domain"
if timeout 15 nslookup "$domain" &>/dev/null; then
log "INFO" "✅ $domain aufgelöst"
resolution_success=$((resolution_success + 1))
else
log "WARN" "❌ $domain nicht auflösbar"
fi
done
if [[ $resolution_success -eq 0 ]]; then
log "ERROR" "❌ Domain-Auflösung fehlgeschlagen!"
else
log "INFO" "✅ $resolution_success von ${#domains[@]} Domains aufgelöst"
fi
# HTTP-Konnektivität testen
log "INFO" "Teste HTTP-Konnektivität..."
local http_success=0
# curl-Tests
if command -v curl &>/dev/null; then
local urls=(
"http://connectivitycheck.gstatic.com/generate_204"
"http://www.google.com"
"http://github.com"
)
for url in "${urls[@]}"; do
log "INFO" "Teste URL: $url"
if timeout 20 curl -s -f --connect-timeout 15 --max-time 25 "$url" &>/dev/null; then
log "INFO" "✅ $url erreichbar"
http_success=$((http_success + 1))
else
log "WARN" "❌ $url nicht erreichbar"
fi
done
fi
# wget-Tests als Fallback
if command -v wget &>/dev/null && [[ $http_success -eq 0 ]]; then
log "INFO" "Teste mit wget..."
if timeout 20 wget --timeout=15 --tries=2 -q -O /dev/null "http://www.google.com"; then
log "INFO" "✅ wget-Test erfolgreich"
http_success=$((http_success + 1))
else
log "WARN" "❌ wget-Test fehlgeschlagen"
fi
fi
if [[ $http_success -eq 0 ]]; then
log "ERROR" "❌ HTTP-Konnektivität fehlgeschlagen!"
else
log "INFO" "✅ HTTP-Konnektivität verfügbar"
fi
echo
}
run_vm_tests() {
log "INFO" "=== VM-SPEZIFISCHE TESTS ==="
# VM-Detection
local is_vm=false
local virt_type="unknown"
if command -v systemd-detect-virt &>/dev/null; then
virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
is_vm=true
log "INFO" "VM-Umgebung erkannt: $virt_type"
fi
fi
# DMI-basierte Detection
if [[ -f /sys/class/dmi/id/product_name ]]; then
local product_name=$(cat /sys/class/dmi/id/product_name 2>/dev/null)
if [[ "$product_name" =~ (VMware|VirtualBox|KVM|QEMU|Hyper-V) ]]; then
is_vm=true
log "INFO" "VM via DMI erkannt: $product_name"
fi
fi
if [[ "$is_vm" == "true" ]]; then
log "INFO" "🖥️ Virtuelle Maschine erkannt"
# VM-spezifische Empfehlungen
case "$virt_type" in
"vmware")
log "INFO" "VMware-Umgebung: Prüfe NAT/Bridge-Modus"
;;
"virtualbox")
log "INFO" "VirtualBox-Umgebung: Prüfe Netzwerk-Adapter-Typ"
;;
"kvm"|"qemu")
log "INFO" "KVM/QEMU-Umgebung: Prüfe virtio-Netzwerk-Driver"
;;
"hyper-v")
log "INFO" "Hyper-V-Umgebung: Prüfe Integration Services"
;;
esac
# VM-Performance-Tests
log "INFO" "Teste VM-Netzwerk-Performance..."
local start_time=$(date +%s%N)
timeout 10 ping -c 1 8.8.8.8 &>/dev/null
local end_time=$(date +%s%N)
local ping_time=$(( (end_time - start_time) / 1000000 )) # ms
log "INFO" "Ping-Latenz: ${ping_time}ms"
if [[ $ping_time -gt 1000 ]]; then
log "WARN" "⚠️ Hohe Ping-Latenz ($ping_time ms) - VM-Netzwerk könnte langsam sein"
fi
else
log "INFO" "🖥️ Physisches System erkannt"
fi
echo
}
show_recommendations() {
log "INFO" "=== EMPFEHLUNGEN ==="
# Sammle Test-Ergebnisse
local has_internet=false
local is_vm=false
local needs_vm_mode=false
# Internet-Check
if timeout 10 ping -c 1 8.8.8.8 &>/dev/null; then
has_internet=true
fi
# VM-Check
if command -v systemd-detect-virt &>/dev/null; then
local virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
is_vm=true
fi
fi
# Performance-Check
local start_time=$(date +%s%N)
timeout 5 ping -c 1 8.8.8.8 &>/dev/null 2>&1 || true
local end_time=$(date +%s%N)
local ping_time=$(( (end_time - start_time) / 1000000 ))
if [[ $ping_time -gt 500 ]] || [[ "$is_vm" == "true" ]]; then
needs_vm_mode=true
fi
# Empfehlungen basierend auf Ergebnissen
if [[ "$has_internet" == "true" ]]; then
log "INFO" "✅ Internet-Verbindung verfügbar"
if [[ "$needs_vm_mode" == "true" ]]; then
log "INFO" "🚀 Empfohlene Installation (VM-Modus):"
echo " sudo ./setup/aio_installer.sh --vm-mode --full"
else
log "INFO" "🚀 Empfohlene Installation:"
echo " sudo ./setup/aio_installer.sh --full"
fi
else
log "WARN" "⚠️ Internet-Verbindung problematisch"
log "INFO" "🔧 Mögliche Lösungen:"
echo " 1. Warten (1-2 Minuten nach VM-Start):"
echo " sleep 120"
echo " sudo ./setup/aio_installer.sh --vm-mode --full"
echo
echo " 2. VM-Netzwerk-Einstellungen prüfen:"
echo " - NAT-Modus aktivieren"
echo " - Bridge-Modus versuchen"
echo " - VM neu starten"
echo
echo " 3. Offline-Installation:"
echo " sudo ./setup/aio_installer.sh --force-offline --full"
echo
echo " 4. Internet-Check überspringen:"
echo " sudo ./setup/aio_installer.sh --skip-internet-check --full"
fi
# Zusätzliche VM-Empfehlungen
if [[ "$is_vm" == "true" ]]; then
log "INFO" "🖥️ VM-spezifische Tipps:"
echo " - Mindestens 2GB RAM zuweisen"
echo " - NAT-Netzwerk-Modus verwenden"
echo " - Nach VM-Start 2 Minuten warten"
echo " - Bei Problemen: VM neu starten"
fi
# Proxy-Erkennung
if [[ -n "${http_proxy:-}" ]] || [[ -n "${HTTP_PROXY:-}" ]]; then
log "INFO" "🌐 Proxy-Umgebung erkannt:"
echo " - Corporate-Proxy: ${http_proxy:-$HTTP_PROXY}"
echo " - Möglicherweise erweiterte Timeouts erforderlich"
fi
echo
log "INFO" "📋 Zusammenfassung:"
echo " Internet verfügbar: $(if [[ "$has_internet" == "true" ]]; then echo "✅ JA"; else echo "❌ NEIN"; fi)"
echo " VM-Umgebung: $(if [[ "$is_vm" == "true" ]]; then echo "✅ JA"; else echo "❌ NEIN"; fi)"
echo " VM-Modus empfohlen: $(if [[ "$needs_vm_mode" == "true" ]]; then echo "✅ JA"; else echo "❌ NEIN"; fi)"
}
# Kommandozeilen-Argumente
case "${1:-}" in
--help|-h)
echo "MYP Network Diagnostics Tool"
echo "Verwendung: $0 [OPTION]"
echo
echo "Optionen:"
echo " --help, -h Diese Hilfe anzeigen"
echo " (keine) Vollständige Netzwerk-Diagnose"
exit 0
;;
*)
main
;;
esac

277
backend/setup/aio_installer.sh
View File

@ -81,11 +81,8 @@ check_system() {
exit 1
fi
# Internetverbindung
if ! ping -c 1 8.8.8.8 &> /dev/null; then
log "ERROR" "Keine Internetverbindung verfügbar"
exit 1
fi
# Internet-Verbindung (VM-kompatibel)
check_internet_connection_vm_compatible
# Speicherplatz (mindestens 2GB frei)
local free_space=$(df / | awk 'NR==2 {print $4}')
@ -97,6 +94,240 @@ check_system() {
log "INFO" "Systemvoraussetzungen erfüllt"
}
# VM-kompatible Internet-Verbindungsprüfung
check_internet_connection_vm_compatible() {
# Skip-Optionen prüfen
if [[ "${SKIP_INTERNET_CHECK:-}" == "true" ]]; then
log "WARN" "⚠️ Internet-Check übersprungen (--skip-internet-check)"
return 0
fi
if [[ "${FORCE_OFFLINE:-}" == "true" ]]; then
log "WARN" "⚠️ Offline-Modus erzwungen (--force-offline)"
return 0
fi
log "INFO" "Prüfe Internet-Verbindung (VM-kompatibel)..."
local connection_available=false
local timeout_seconds=45 # Längerer Standard-Timeout
local start_time=$(date +%s)
# VM-Umgebung erkennen
local is_vm=false
if command -v systemd-detect-virt &>/dev/null; then
local virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
is_vm=true
log "INFO" "VM-Umgebung erkannt: $virt_type"
timeout_seconds=120 # Deutlich längerer Timeout für VMs
fi
fi
# VM-Mode Option berücksichtigen
if [[ "${VM_MODE:-}" == "true" ]]; then
is_vm=true
timeout_seconds=120 # 2 Minuten für VM-Modus
log "INFO" "VM-Modus manuell aktiviert (--vm-mode)"
fi
# Mehrere Test-Methoden mit VM-freundlichen Timeouts
local test_methods=(
"ping_multiple_hosts"
"curl_connectivity_check"
"dns_resolution_test"
"gateway_ping_test"
)
for method in "${test_methods[@]}"; do
local current_time=$(date +%s)
local elapsed=$((current_time - start_time))
if [[ $elapsed -gt $timeout_seconds ]]; then
log "WARN" "Internet-Check Timeout erreicht (${timeout_seconds}s)"
break
fi
log "INFO" "Teste Methode: $method"
if $method "$is_vm"; then
log "INFO" "✓ Internet-Verbindung via $method erfolgreich"
connection_available=true
break
else
log "WARN" "Methode $method fehlgeschlagen"
sleep 2 # Kurze Pause zwischen Tests
fi
done
if [[ "$connection_available" == "true" ]]; then
log "INFO" "✅ Internet-Verbindung verfügbar"
return 0
else
log "ERROR" "❌ Keine Internet-Verbindung verfügbar"
# Zusätzliche Diagnose-Informationen
show_network_diagnostics_brief
# Benutzer-Option in VMs
if [[ "$is_vm" == "true" ]] && [[ "${FORCE_YES:-}" != "true" ]]; then
log "WARN" "In VM-Umgebungen können Netzwerk-Checks fehlschlagen"
log "INFO" "Mögliche Lösungen:"
log "INFO" " 1. Warte 1-2 Minuten nach VM-Start"
log "INFO" " 2. Prüfe VM-Netzwerk-Einstellungen (NAT/Bridge)"
log "INFO" " 3. Teste Internet-Zugang im Browser"
if confirm_action "Trotz Netzwerk-Problemen fortfahren? (Nicht empfohlen)"; then
log "WARN" "⚠️ Installation trotz Netzwerk-Problemen fortgesetzt"
return 0
fi
fi
return 1
fi
}
# Ping mit mehreren Hosts und VM-Timeouts
ping_multiple_hosts() {
local is_vm="$1"
local timeout_per_host=5
local packet_count=2
if [[ "$is_vm" == "true" ]]; then
timeout_per_host=15 # Längerer Timeout für VMs
packet_count=4 # Mehr Ping-Pakete
fi
local hosts=(
"8.8.8.8" # Google DNS
"1.1.1.1" # Cloudflare DNS
"9.9.9.9" # Quad9 DNS
"208.67.222.222" # OpenDNS
)
for host in "${hosts[@]}"; do
log "DEBUG" "Ping zu $host (Timeout: ${timeout_per_host}s, Pakete: $packet_count)"
if timeout $((timeout_per_host + 5)) ping -c $packet_count -W $timeout_per_host "$host" &>/dev/null; then
log "INFO" "✓ Ping zu $host erfolgreich"
return 0
fi
done
return 1
}
# curl Konnektivitäts-Check mit mehreren URLs
curl_connectivity_check() {
local is_vm="$1"
local connect_timeout=10
local max_time=15
if [[ "$is_vm" == "true" ]]; then
connect_timeout=30 # Längerer Verbindungs-Timeout
max_time=45 # Längere Gesamtzeit
fi
if ! command -v curl &>/dev/null; then
return 1
fi
local urls=(
"http://connectivitycheck.gstatic.com/generate_204"
"http://www.gstatic.com/generate_204"
"http://clients3.google.com/generate_204"
)
for url in "${urls[@]}"; do
log "DEBUG" "curl zu $url (Timeout: ${connect_timeout}s/${max_time}s)"
if curl -s -f --connect-timeout $connect_timeout --max-time $max_time "$url" &>/dev/null; then
log "INFO" "✓ curl zu $url erfolgreich"
return 0
fi
done
return 1
}
# DNS-Resolution-Test
dns_resolution_test() {
local is_vm="$1"
local timeout=10
if [[ "$is_vm" == "true" ]]; then
timeout=20
fi
local domains=("google.com" "cloudflare.com" "github.com")
for domain in "${domains[@]}"; do
log "DEBUG" "DNS-Test für $domain (Timeout: ${timeout}s)"
if timeout $timeout nslookup "$domain" &>/dev/null; then
log "INFO" "✓ DNS-Auflösung für $domain erfolgreich"
return 0
fi
done
return 1
}
# Gateway-Ping-Test
gateway_ping_test() {
local is_vm="$1"
local gateway=$(ip route show default | awk '/default/ {print $3}' | head -1)
if [[ -z "$gateway" ]]; then
return 1
fi
local timeout=5
if [[ "$is_vm" == "true" ]]; then
timeout=10
fi
log "DEBUG" "Gateway-Ping zu $gateway (Timeout: ${timeout}s)"
if timeout $((timeout + 5)) ping -c 2 -W $timeout "$gateway" &>/dev/null; then
log "INFO" "✓ Gateway $gateway erreichbar"
return 0
fi
return 1
}
# Kurze Netzwerk-Diagnose
show_network_diagnostics_brief() {
log "INFO" "=== NETZWERK-DIAGNOSE ==="
# Aktive Interfaces
local interfaces=$(ip link show | grep -c "state UP")
log "INFO" "Aktive Netzwerk-Interfaces: $interfaces"
# Default Gateway
local gateway=$(ip route show default | awk '/default/ {print $3}' | head -1)
if [[ -n "$gateway" ]]; then
log "INFO" "Default Gateway: $gateway"
else
log "WARN" "Kein Default Gateway konfiguriert"
fi
# DNS-Server
if [[ -f /etc/resolv.conf ]]; then
local dns_count=$(grep -c nameserver /etc/resolv.conf)
log "INFO" "Konfigurierte DNS-Server: $dns_count"
fi
# VM-Detection
if command -v systemd-detect-virt &>/dev/null; then
local virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
log "INFO" "Virtualisierung: $virt_type"
fi
fi
}
confirm_action() {
local message="$1"
local default="${2:-n}"
@ -418,16 +649,42 @@ while [[ $# -gt 0 ]]; do
uninstall_system
exit $?
;;
--skip-internet-check)
log "WARN" "Internet-Check wird übersprungen"
export SKIP_INTERNET_CHECK="true"
;;
--vm-mode)
log "INFO" "VM-Modus aktiviert (erweiterte Timeouts)"
export VM_MODE="true"
;;
--force-offline)
log "WARN" "Offline-Modus erzwungen"
export FORCE_OFFLINE="true"
;;
--network-debug)
log "INFO" "Netzwerk-Debug-Modus aktiviert"
export NETWORK_DEBUG="true"
;;
--help|-h)
echo "MYP AIO-Installer"
echo "Verwendung: $0 [OPTION]"
echo
echo "Optionen:"
echo " --full Vollinstallation ohne Bestätigung"
echo " --upgrade Upgrade bestehender Installation"
echo " --test Nur Tests durchführen"
echo " --uninstall System deinstallieren"
echo " --help, -h Diese Hilfe anzeigen"
echo " --full Vollinstallation ohne Bestätigung"
echo " --upgrade Upgrade bestehender Installation"
echo " --test Nur Tests durchführen"
echo " --uninstall System deinstallieren"
echo " --skip-internet-check Internet-Verbindungsprüfung überspringen"
echo " --vm-mode VM-Modus (erweiterte Timeouts)"
echo " --force-offline Offline-Installation erzwingen"
echo " --network-debug Detaillierte Netzwerk-Diagnose"
echo " --help, -h Diese Hilfe anzeigen"
echo
echo "VM-spezifische Optionen:"
echo " Für VMs empfohlene Verwendung:"
echo " $0 --vm-mode --full"
echo " $0 --force-offline --full (bei Netzwerk-Problemen)"
echo
exit 0
;;
*)

480
backend/setup/modules/enhanced_network_check.sh Normal file
View File

@ -0,0 +1,480 @@
#!/bin/bash
#######################################################################
# MYP AIO-Installer - Enhanced Network Check Module
#
# Verbesserte Internet-Verbindungsprüfung für VM-Kompatibilität
#
# Funktionen:
# - Mehrstufige Netzwerk-Checks
# - VM-spezifische Timeouts
# - DNS-Resolution-Validation
# - Corporate-Proxy-Unterstützung
# - Detaillierte Fehlerdiagnose
#######################################################################
# Erweiterte Internet-Verbindungsprüfung (VM-kompatibel)
check_internet_connection_enhanced() {
log "INFO" "=== ERWEITERTE INTERNET-VERBINDUNGSPRÜFUNG ==="
local connection_available=false
local check_errors=()
# Schritt 1: Netzwerk-Interface-Check
log "INFO" "Schritt 1: Prüfe Netzwerk-Interfaces..."
if check_network_interfaces; then
log "INFO" "✓ Netzwerk-Interfaces aktiv"
else
check_errors+=("Keine aktiven Netzwerk-Interfaces")
fi
# Schritt 2: DNS-Resolution-Check
log "INFO" "Schritt 2: Prüfe DNS-Auflösung..."
if check_dns_resolution; then
log "INFO" "✓ DNS-Auflösung funktioniert"
else
check_errors+=("DNS-Auflösung fehlgeschlagen")
fi
# Schritt 3: Gateway-Erreichbarkeit
log "INFO" "Schritt 3: Prüfe Gateway-Erreichbarkeit..."
if check_gateway_reachability; then
log "INFO" "✓ Gateway erreichbar"
else
check_errors+=("Gateway nicht erreichbar")
fi
# Schritt 4: Externe Konnektivität (mehrere Methoden)
log "INFO" "Schritt 4: Prüfe externe Konnektivität..."
if check_external_connectivity; then
log "INFO" "✓ Externe Konnektivität verfügbar"
connection_available=true
else
check_errors+=("Externe Konnektivität fehlgeschlagen")
fi
# Schritt 5: Corporate-Proxy-Check (falls Standard-Check fehlschlägt)
if [[ "$connection_available" == "false" ]]; then
log "INFO" "Schritt 5: Prüfe Corporate-Proxy-Konnektivität..."
if check_corporate_proxy; then
log "INFO" "✓ Corporate-Proxy-Konnektivität verfügbar"
connection_available=true
else
check_errors+=("Corporate-Proxy-Konnektivität fehlgeschlagen")
fi
fi
# Ergebnis-Auswertung
if [[ "$connection_available" == "true" ]]; then
log "INFO" "✅ Internet-Verbindung erfolgreich validiert"
return 0
else
log "ERROR" "❌ Internet-Verbindung nicht verfügbar"
log "ERROR" "Gefundene Probleme:"
for error in "${check_errors[@]}"; do
log "ERROR" " - $error"
done
# Detaillierte Diagnose-Informationen
show_network_diagnostics
# Benutzer-Option: Trotzdem fortfahren?
if [[ "${FORCE_YES:-}" != "true" ]]; then
if confirm_action "Internet-Verbindung problematisch. Trotzdem fortfahren? (Nicht empfohlen)"; then
log "WARN" "⚠️ Installation trotz Netzwerk-Problemen fortgesetzt"
return 0
fi
fi
return 1
fi
}
# Netzwerk-Interface-Check
check_network_interfaces() {
local active_interfaces=$(ip link show | grep -E "state UP|LOWER_UP" | wc -l)
if [[ $active_interfaces -gt 0 ]]; then
log "INFO" "Aktive Netzwerk-Interfaces: $active_interfaces"
# Interface-Details loggen
ip link show | grep -E "state UP|LOWER_UP" | while read line; do
log "DEBUG" "Interface: $line"
done
return 0
else
log "ERROR" "Keine aktiven Netzwerk-Interfaces gefunden"
return 1
fi
}
# DNS-Resolution-Check mit mehreren Servern
check_dns_resolution() {
local dns_servers=(
"8.8.8.8" # Google DNS
"1.1.1.1" # Cloudflare DNS
"9.9.9.9" # Quad9 DNS
"208.67.222.222" # OpenDNS
)
local test_domains=(
"google.com"
"cloudflare.com"
"github.com"
)
# Teste DNS-Server-Erreichbarkeit
for dns_server in "${dns_servers[@]}"; do
log "INFO" "Teste DNS-Server: $dns_server"
# Ping mit VM-freundlichem Timeout
if timeout 10 ping -c 2 -W 3 "$dns_server" &>/dev/null; then
log "INFO" "✓ DNS-Server $dns_server erreichbar"
# Teste Domain-Auflösung
for domain in "${test_domains[@]}"; do
if timeout 10 nslookup "$domain" "$dns_server" &>/dev/null; then
log "INFO" "✓ DNS-Auflösung für $domain erfolgreich"
return 0
fi
done
else
log "WARN" "DNS-Server $dns_server nicht erreichbar"
fi
done
log "ERROR" "Alle DNS-Server-Tests fehlgeschlagen"
return 1
}
# Gateway-Erreichbarkeit prüfen
check_gateway_reachability() {
local gateway=$(ip route show default | awk '/default/ {print $3}' | head -1)
if [[ -n "$gateway" ]]; then
log "INFO" "Default Gateway: $gateway"
# Gateway-Ping mit VM-Timeout
if timeout 15 ping -c 3 -W 5 "$gateway" &>/dev/null; then
log "INFO" "✓ Gateway $gateway erreichbar"
return 0
else
log "ERROR" "Gateway $gateway nicht erreichbar"
return 1
fi
else
log "ERROR" "Kein Default Gateway gefunden"
return 1
fi
}
# Externe Konnektivität mit mehreren Methoden
check_external_connectivity() {
local test_methods=(
"ping_test"
"curl_test"
"wget_test"
"nc_test"
)
for method in "${test_methods[@]}"; do
log "INFO" "Teste externe Konnektivität mit: $method"
if $method; then
log "INFO" "✓ Externe Konnektivität via $method erfolgreich"
return 0
else
log "WARN" "Externe Konnektivität via $method fehlgeschlagen"
fi
done
log "ERROR" "Alle Konnektivitäts-Tests fehlgeschlagen"
return 1
}
# Ping-Test mit VM-optimierten Parametern
ping_test() {
local test_hosts=(
"8.8.8.8" # Google DNS
"1.1.1.1" # Cloudflare DNS
"9.9.9.9" # Quad9 DNS
)
for host in "${test_hosts[@]}"; do
# VM-freundliche Ping-Parameter:
# -c 3: 3 Pakete (mehr Zuverlässigkeit)
# -W 5: 5 Sekunden Timeout pro Paket
# -i 2: 2 Sekunden Intervall zwischen Paketen
if timeout 20 ping -c 3 -W 5 -i 2 "$host" &>/dev/null; then
log "INFO" "✓ Ping zu $host erfolgreich"
return 0
fi
done
return 1
}
# curl-Test mit erweiterten Timeouts
curl_test() {
if ! command -v curl &>/dev/null; then
log "WARN" "curl nicht verfügbar"
return 1
fi
local test_urls=(
"http://connectivitycheck.gstatic.com/generate_204" # Google Connectivity Check
"http://www.gstatic.com/generate_204" # Google Alternative
"http://captive.apple.com/hotspot-detect.html" # Apple Connectivity Check
"http://clients3.google.com/generate_204" # Google Client Check
)
for url in "${test_urls[@]}"; do
# VM-freundliche curl-Parameter:
# --connect-timeout 15: 15 Sekunden Verbindungs-Timeout
# --max-time 30: 30 Sekunden Gesamt-Timeout
# --retry 2: 2 Wiederholungen
# --retry-delay 3: 3 Sekunden Pause zwischen Wiederholungen
if curl -s -f --connect-timeout 15 --max-time 30 --retry 2 --retry-delay 3 "$url" &>/dev/null; then
log "INFO" "✓ curl zu $url erfolgreich"
return 0
fi
done
return 1
}
# wget-Test als Alternative
wget_test() {
if ! command -v wget &>/dev/null; then
log "WARN" "wget nicht verfügbar"
return 1
fi
# wget mit VM-Timeouts
if timeout 30 wget --quiet --spider --timeout=15 --tries=2 "http://www.google.com" &>/dev/null; then
log "INFO" "✓ wget-Test erfolgreich"
return 0
fi
return 1
}
# nc (netcat) Test für Port-Konnektivität
nc_test() {
if ! command -v nc &>/dev/null; then
log "WARN" "netcat nicht verfügbar"
return 1
fi
local test_endpoints=(
"8.8.8.8 53" # Google DNS
"1.1.1.1 53" # Cloudflare DNS
"google.com 80" # HTTP
"google.com 443" # HTTPS
)
for endpoint in "${test_endpoints[@]}"; do
local host=$(echo $endpoint | awk '{print $1}')
local port=$(echo $endpoint | awk '{print $2}')
if timeout 10 nc -z -w 5 "$host" "$port" &>/dev/null; then
log "INFO" "✓ netcat zu $host:$port erfolgreich"
return 0
fi
done
return 1
}
# Corporate-Proxy-Check für Mercedes-Umgebung
check_corporate_proxy() {
log "INFO" "Prüfe Corporate-Proxy-Konnektivität..."
# Prüfe auf Proxy-Umgebungsvariablen
local proxy_vars=(
"$http_proxy"
"$https_proxy"
"$HTTP_PROXY"
"$HTTPS_PROXY"
)
for proxy in "${proxy_vars[@]}"; do
if [[ -n "$proxy" ]]; then
log "INFO" "Proxy gefunden: $proxy"
# Teste Proxy-Konnektivität
if test_proxy_connectivity "$proxy"; then
log "INFO" "✓ Proxy-Konnektivität erfolgreich"
return 0
fi
fi
done
# Teste bekannte Corporate-Domains
local corporate_domains=(
"mercedes-benz.com"
"daimler.com"
"corpintra.net"
)
for domain in "${corporate_domains[@]}"; do
if timeout 15 curl -s --connect-timeout 10 --max-time 20 "https://$domain" &>/dev/null; then
log "INFO" "✓ Corporate-Domain $domain erreichbar"
return 0
fi
done
log "WARN" "Corporate-Proxy-Konnektivität nicht verfügbar"
return 1
}
# Proxy-Konnektivität testen
test_proxy_connectivity() {
local proxy="$1"
if [[ -z "$proxy" ]]; then
return 1
fi
# Teste Proxy mit curl
if curl -s --proxy "$proxy" --connect-timeout 10 --max-time 15 "http://www.google.com" &>/dev/null; then
return 0
fi
return 1
}
# Detaillierte Netzwerk-Diagnose anzeigen
show_network_diagnostics() {
log "INFO" "=== NETZWERK-DIAGNOSE ==="
# IP-Konfiguration
log "INFO" "IP-Konfiguration:"
ip addr show | grep -E "(inet |state UP)" | head -10 | while read line; do
log "INFO" " $line"
done
# Routing-Tabelle
log "INFO" "Routing-Tabelle:"
ip route show | head -5 | while read line; do
log "INFO" " $line"
done
# DNS-Konfiguration
log "INFO" "DNS-Konfiguration:"
if [[ -f /etc/resolv.conf ]]; then
grep nameserver /etc/resolv.conf | head -3 | while read line; do
log "INFO" " $line"
done
fi
# Proxy-Einstellungen
log "INFO" "Proxy-Einstellungen:"
for var in http_proxy https_proxy HTTP_PROXY HTTPS_PROXY; do
if [[ -n "${!var}" ]]; then
log "INFO" " $var=${!var}"
fi
done
# Aktive Verbindungen
log "INFO" "Aktive Netzwerk-Verbindungen:"
ss -tuln | head -10 | while read line; do
log "INFO" " $line"
done
# VM-Detection
detect_vm_environment
}
# VM-Umgebung erkennen
detect_vm_environment() {
log "INFO" "=== VM-UMGEBUNG-ERKENNUNG ==="
# Hypervisor-Detection
if command -v systemd-detect-virt &>/dev/null; then
local virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
log "INFO" "VM-Umgebung erkannt: $virt_type"
# VM-spezifische Empfehlungen
case "$virt_type" in
"vmware")
log "INFO" "VMware-Empfehlung: Prüfe NAT/Bridge-Modus"
;;
"virtualbox")
log "INFO" "VirtualBox-Empfehlung: Aktiviere Host-Only-Adapter"
;;
"kvm"|"qemu")
log "INFO" "KVM/QEMU-Empfehlung: Prüfe virtio-Netzwerk-Driver"
;;
"hyper-v")
log "INFO" "Hyper-V-Empfehlung: Prüfe Integration Services"
;;
esac
else
log "INFO" "Physisches System erkannt"
fi
fi
# DMI-basierte Detection
if [[ -f /sys/class/dmi/id/product_name ]]; then
local product_name=$(cat /sys/class/dmi/id/product_name 2>/dev/null)
if [[ "$product_name" =~ (VMware|VirtualBox|KVM|QEMU) ]]; then
log "INFO" "VM via DMI erkannt: $product_name"
fi
fi
}
# Internet-Check-Bypass für Offline-Installation
enable_offline_mode() {
log "WARN" "=== OFFLINE-MODUS AKTIVIERT ==="
log "WARN" "Internet-Checks werden übersprungen"
log "WARN" "Manche Features können eingeschränkt sein"
export MYP_OFFLINE_MODE="true"
# Erstelle Marker-Datei
echo "OFFLINE_MODE_ENABLED=$(date)" > "/tmp/myp-offline-mode"
}
# Check-Funktion für Offline-Modus
is_offline_mode() {
[[ "$MYP_OFFLINE_MODE" == "true" ]] || [[ -f "/tmp/myp-offline-mode" ]]
}
# Hauptfunktion: Ersetzt den ursprünglichen Internet-Check
check_system_enhanced() {
log "INFO" "Überprüfe Systemvoraussetzungen (erweitert)..."
# Debian/Ubuntu Check
if ! command -v apt &> /dev/null; then
log "ERROR" "Dieses System wird nicht unterstützt (kein APT Package Manager)"
exit 1
fi
# Internet-Verbindung (erweitert)
if ! check_internet_connection_enhanced; then
if [[ "${FORCE_OFFLINE:-}" == "true" ]]; then
enable_offline_mode
log "WARN" "Offline-Modus erzwungen"
else
log "ERROR" "Internet-Verbindung erforderlich für Installation"
log "INFO" "Hinweise zur Fehlerbehebung:"
log "INFO" " 1. Prüfe VM-Netzwerk-Einstellungen (NAT/Bridge)"
log "INFO" " 2. Warte 1-2 Minuten nach VM-Start"
log "INFO" " 3. Prüfe Host-Firewall/Proxy-Einstellungen"
log "INFO" " 4. Verwende --force-offline für Offline-Installation"
exit 1
fi
fi
# Speicherplatz (mindestens 2GB frei)
local free_space=$(df / | awk 'NR==2 {print $4}')
if [[ $free_space -lt 2097152 ]]; then
log "ERROR" "Nicht genügend Speicherplatz (mindestens 2GB erforderlich)"
exit 1
fi
log "INFO" "Systemvoraussetzungen erfüllt"
}

182
backend/setup/vm-internet-check.sh Normal file
View File

@ -0,0 +1,182 @@
#!/bin/bash
#######################################################################
# VM Internet-Verbindung Diagnose und Reparatur
#
# Speziell für virtuelle Maschinen mit Internet-Verbindungsproblemen
# im MYP AIO-Installer
#######################################################################
set -euo pipefail
# Farben für Ausgabe
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly NC='\033[0m' # No Color
log() {
local level="$1"
shift
local message="$*"
case "$level" in
"INFO") echo -e "${GREEN}[INFO]${NC} $message" ;;
"WARN") echo -e "${YELLOW}[WARN]${NC} $message" ;;
"ERROR") echo -e "${RED}[ERROR]${NC} $message" ;;
"DEBUG") echo -e "${BLUE}[DEBUG]${NC} $message" ;;
esac
}
echo "🔍 MYP VM Internet-Verbindung Diagnose"
echo "======================================"
echo
# 1. VM-Umgebung prüfen
log "INFO" "Prüfe VM-Umgebung..."
if command -v systemd-detect-virt &>/dev/null; then
virt_type=$(systemd-detect-virt)
if [[ "$virt_type" != "none" ]]; then
log "INFO" "✓ VM-Umgebung erkannt: $virt_type"
else
log "WARN" "Keine VM-Umgebung erkannt (aber Script wurde manuell gestartet)"
fi
else
log "WARN" "systemd-detect-virt nicht verfügbar"
fi
# 2. Netzwerk-Interface prüfen
log "INFO" "Prüfe Netzwerk-Interfaces..."
active_interfaces=$(ip link show | grep "state UP" | wc -l)
if [[ $active_interfaces -gt 0 ]]; then
log "INFO" "✓ $active_interfaces aktive Netzwerk-Interface(s)"
ip link show | grep "state UP" | while read line; do
interface=$(echo "$line" | awk -F: '{print $2}' | tr -d ' ')
log "DEBUG" " - Interface: $interface"
done
else
log "ERROR" "✗ Keine aktiven Netzwerk-Interfaces"
exit 1
fi
# 3. IP-Adressen prüfen
log "INFO" "Prüfe IP-Adressen..."
ip_addresses=$(hostname -I 2>/dev/null | tr ' ' '\n' | grep -v '^$' || echo "")
if [[ -n "$ip_addresses" ]]; then
log "INFO" "✓ IP-Adressen gefunden:"
echo "$ip_addresses" | while read ip; do
[[ -n "$ip" ]] && log "DEBUG" " - $ip"
done
else
log "ERROR" "✗ Keine IP-Adressen gefunden"
exit 1
fi
# 4. DNS-Konfiguration prüfen
log "INFO" "Prüfe DNS-Konfiguration..."
if [[ -f "/etc/resolv.conf" ]]; then
dns_servers=$(grep "^nameserver" /etc/resolv.conf | awk '{print $2}' | head -3)
if [[ -n "$dns_servers" ]]; then
log "INFO" "✓ DNS-Server konfiguriert:"
echo "$dns_servers" | while read dns; do
log "DEBUG" " - $dns"
done
else
log "WARN" "Keine DNS-Server in /etc/resolv.conf gefunden"
fi
else
log "WARN" "/etc/resolv.conf nicht gefunden"
fi
# 5. Gateway prüfen
log "INFO" "Prüfe Standard-Gateway..."
default_gateway=$(ip route | grep "^default" | awk '{print $3}' | head -1)
if [[ -n "$default_gateway" ]]; then
log "INFO" "✓ Standard-Gateway: $default_gateway"
# Gateway-Ping testen
if ping -c 2 -W 10 "$default_gateway" &>/dev/null; then
log "INFO" "✓ Gateway erreichbar"
else
log "ERROR" "✗ Gateway nicht erreichbar"
fi
else
log "ERROR" "✗ Kein Standard-Gateway gefunden"
fi
# 6. Internet-Konnektivität testen (erweitert)
log "INFO" "Teste Internet-Konnektivität (VM-optimiert)..."
test_hosts=(
"8.8.8.8:Google DNS"
"1.1.1.1:Cloudflare DNS"
"9.9.9.9:Quad9 DNS"
"208.67.222.222:OpenDNS"
)
internet_working=false
for host_info in "${test_hosts[@]}"; do
host=$(echo "$host_info" | cut -d: -f1)
name=$(echo "$host_info" | cut -d: -f2)
log "DEBUG" "Teste $name ($host)..."
if timeout 20 ping -c 3 -W 10 "$host" &>/dev/null; then
log "INFO" "✓ Internet-Verbindung über $name erfolgreich"
internet_working=true
break
else
log "WARN" "✗ $name nicht erreichbar"
fi
done
# 7. HTTP-Konnektivität testen
if [[ "$internet_working" == "true" ]]; then
log "INFO" "Teste HTTP-Konnektivität..."
test_urls=(
"http://connectivitycheck.gstatic.com/generate_204"
"http://www.gstatic.com/generate_204"
"http://clients3.google.com/generate_204"
)
for url in "${test_urls[@]}"; do
if timeout 30 curl -sf --connect-timeout 20 --max-time 25 "$url" &>/dev/null; then
log "INFO" "✓ HTTP-Verbindung erfolgreich zu $url"
break
else
log "WARN" "✗ HTTP-Verbindung fehlgeschlagen zu $url"
fi
done
fi
# 8. Fazit und Empfehlungen
echo
echo "🎯 DIAGNOSE-ERGEBNIS:"
echo "===================="
if [[ "$internet_working" == "true" ]]; then
log "INFO" "✅ Internet-Verbindung funktioniert!"
echo
echo "🚀 EMPFOHLENE BEFEHLE FÜR MYP-INSTALLATION:"
echo "sudo ./setup/aio_installer.sh --vm-mode --full"
echo "oder"
echo "sudo ./setup/aio_installer.sh --skip-internet-check --full"
echo
else
log "ERROR" "❌ Internet-Verbindung problematisch"
echo
echo "🔧 LÖSUNGSVORSCHLÄGE:"
echo "1. VM-Netzwerk-Einstellungen prüfen (NAT vs. Bridge)"
echo "2. VM neu starten und 2 Minuten warten"
echo "3. Host-Internet-Verbindung prüfen"
echo "4. Firewall/Proxy-Einstellungen prüfen"
echo
echo "🚀 TROTZDEM VERSUCHEN:"
echo "sudo ./setup/aio_installer.sh --force-offline --full"
echo
fi
echo "📋 WEITERE OPTIONEN:"
echo "sudo ./setup/aio_installer.sh --help"