Setup installation
This commit is contained in:
372
scripts/installation/README.md
Normal file
372
scripts/installation/README.md
Normal file
@@ -0,0 +1,372 @@
|
||||
# Installation Module
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das Installation Module bietet eine vollautomatische Master-Installation für das USB-SSD Management System. Es konfiguriert alle Abhängigkeiten, erstellt System-Services und richtet die komplette Infrastruktur für den produktiven Einsatz ein.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### `install.sh`
|
||||
**Zweck**: Master-Installation mit vollständiger System-Konfiguration
|
||||
|
||||
**Installationsschritte**:
|
||||
- System-Abhängigkeiten installieren
|
||||
- Scripts in System-Pfade kopieren
|
||||
- Systemd-Services konfigurieren
|
||||
- Udev-Rules einrichten
|
||||
- Benutzer-Berechtigungen setzen
|
||||
- Logging-Infrastruktur aufbauen
|
||||
|
||||
## Installation
|
||||
|
||||
### Schnell-Installation
|
||||
```bash
|
||||
# Repository klonen
|
||||
git clone https://git.gitcover.de/KMU/usb-ssd.git
|
||||
cd usb-ssd
|
||||
|
||||
# Master-Installation ausführen
|
||||
sudo ./scripts/installation/install.sh
|
||||
```
|
||||
|
||||
### Erweiterte Installation
|
||||
```bash
|
||||
# Installation mit Custom-Konfiguration
|
||||
sudo ./scripts/installation/install.sh --config /path/to/config.conf
|
||||
|
||||
# Installation ohne Systemd-Services
|
||||
sudo ./scripts/installation/install.sh --no-systemd
|
||||
|
||||
# Installation mit Debug-Modus
|
||||
sudo ./scripts/installation/install.sh --debug --verbose
|
||||
```
|
||||
|
||||
### Interaktive Installation
|
||||
```bash
|
||||
# Schritt-für-Schritt Installation mit Benutzer-Eingaben
|
||||
sudo ./scripts/installation/install.sh --interactive
|
||||
|
||||
# Nur bestimmte Komponenten installieren
|
||||
sudo ./scripts/installation/install.sh --components "detection,management"
|
||||
```
|
||||
|
||||
## Installationsoptionen
|
||||
|
||||
### Standard-Installation
|
||||
```bash
|
||||
# Vollständige Installation (empfohlen)
|
||||
sudo ./install.sh
|
||||
|
||||
# Installiert:
|
||||
# - Alle System-Abhängigkeiten
|
||||
# - Scripts nach /usr/local/bin/
|
||||
# - Systemd-Services
|
||||
# - Udev-Rules
|
||||
# - Log-Rotation
|
||||
# - Bash-Completion
|
||||
```
|
||||
|
||||
### Custom-Installation
|
||||
```bash
|
||||
# Spezifische Installationspfade
|
||||
sudo ./install.sh --prefix /opt/ssd-tools
|
||||
|
||||
# Custom-Konfiguration
|
||||
sudo ./install.sh --config-dir /etc/ssd-management
|
||||
|
||||
# Benutzer-spezifische Installation
|
||||
./install.sh --user-install
|
||||
```
|
||||
|
||||
### Komponenten-basierte Installation
|
||||
```bash
|
||||
# Nur Detection-Module
|
||||
sudo ./install.sh --component detection
|
||||
|
||||
# Nur Management-Module
|
||||
sudo ./install.sh --component management
|
||||
|
||||
# Nur Testing-Module
|
||||
sudo ./install.sh --component testing
|
||||
|
||||
# Mehrere Komponenten
|
||||
sudo ./install.sh --components "detection,management,testing"
|
||||
```
|
||||
|
||||
## System-Abhängigkeiten
|
||||
|
||||
### Automatisch installierte Packages
|
||||
|
||||
#### Ubuntu/Debian
|
||||
```bash
|
||||
# Core-Packages
|
||||
ntfs-3g # NTFS-Dateisystem Support
|
||||
util-linux # Mount/Unmount Utilities
|
||||
parted # Partitionstabellen-Management
|
||||
bc # Berechnungen in Scripts
|
||||
eject # Hardware-Eject Funktionalität
|
||||
|
||||
# Optional-Packages
|
||||
smartmontools # SSD-Health Monitoring
|
||||
hdparm # Hardware-Parameter Tuning
|
||||
fio # Performance-Testing
|
||||
samba-common # SMB-Integration
|
||||
```
|
||||
|
||||
#### CentOS/RHEL
|
||||
```bash
|
||||
# Core-Packages
|
||||
ntfs-3g
|
||||
util-linux
|
||||
parted
|
||||
bc
|
||||
eject
|
||||
|
||||
# EPEL-Repository für zusätzliche Tools
|
||||
sudo yum install epel-release
|
||||
```
|
||||
|
||||
### Manuelle Abhängigkeits-Installation
|
||||
```bash
|
||||
# Ubuntu/Debian
|
||||
sudo apt update
|
||||
sudo apt install ntfs-3g util-linux parted bc eject smartmontools hdparm fio
|
||||
|
||||
# CentOS/RHEL
|
||||
sudo yum install ntfs-3g util-linux parted bc eject smartmontools hdparm fio
|
||||
|
||||
# Arch Linux
|
||||
sudo pacman -S ntfs-3g util-linux parted bc eject smartmontools hdparm fio
|
||||
```
|
||||
|
||||
## Systemd-Integration
|
||||
|
||||
### Installierte Services
|
||||
|
||||
#### `ssd-detection.service`
|
||||
```ini
|
||||
[Unit]
|
||||
Description=USB-C SSD Detection Service
|
||||
After=local-fs.target
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
ExecStart=/usr/local/bin/ssd-detect.sh --monitor
|
||||
Restart=on-failure
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
```
|
||||
|
||||
#### `ssd-automount.service`
|
||||
```ini
|
||||
[Unit]
|
||||
Description=Automatic SSD Mounting
|
||||
After=ssd-detection.service
|
||||
|
||||
[Service]
|
||||
Type=forking
|
||||
ExecStart=/usr/local/bin/ssd-mount-manager.sh --auto-mount
|
||||
ExecStop=/usr/local/bin/ssd-safe-eject.sh --all
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
```
|
||||
|
||||
### Service-Management
|
||||
```bash
|
||||
# Services aktivieren
|
||||
sudo systemctl enable ssd-detection.service
|
||||
sudo systemctl enable ssd-automount.service
|
||||
|
||||
# Services starten
|
||||
sudo systemctl start ssd-detection.service
|
||||
sudo systemctl start ssd-automount.service
|
||||
|
||||
# Status prüfen
|
||||
sudo systemctl status ssd-detection.service
|
||||
```
|
||||
|
||||
## Udev-Rules
|
||||
|
||||
### Automatische USB-Erkennung
|
||||
```bash
|
||||
# /etc/udev/rules.d/99-ssd-automount.rules
|
||||
SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="add", RUN+="/usr/local/bin/ssd-detect.sh --device %k"
|
||||
SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="remove", RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k"
|
||||
```
|
||||
|
||||
### Udev-Rules aktivieren
|
||||
```bash
|
||||
# Rules neu laden
|
||||
sudo udevadm control --reload-rules
|
||||
sudo udevadm trigger
|
||||
|
||||
# Test der Rules
|
||||
sudo udevadm test /sys/block/sdb
|
||||
```
|
||||
|
||||
## Benutzer-Berechtigungen
|
||||
|
||||
### Gruppe-Konfiguration
|
||||
```bash
|
||||
# SSD-Management Gruppe erstellen
|
||||
sudo groupadd ssd-users
|
||||
|
||||
# Benutzer zur Gruppe hinzufügen
|
||||
sudo usermod -a -G ssd-users $USER
|
||||
|
||||
# Disk-Gruppe für Hardware-Zugriff
|
||||
sudo usermod -a -G disk $USER
|
||||
```
|
||||
|
||||
### Sudo-Konfiguration
|
||||
```bash
|
||||
# /etc/sudoers.d/ssd-management
|
||||
%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-mount-manager.sh
|
||||
%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-safe-eject.sh
|
||||
%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-detect.sh
|
||||
```
|
||||
|
||||
## Logging-Konfiguration
|
||||
|
||||
### Log-Rotation
|
||||
```bash
|
||||
# /etc/logrotate.d/ssd-management
|
||||
/var/log/ssd-*.log {
|
||||
daily
|
||||
rotate 30
|
||||
compress
|
||||
delaycompress
|
||||
missingok
|
||||
notifempty
|
||||
create 644 root root
|
||||
}
|
||||
```
|
||||
|
||||
### Syslog-Integration
|
||||
```bash
|
||||
# /etc/rsyslog.d/50-ssd-management.conf
|
||||
:programname, isequal, "ssd-detect" /var/log/ssd-detection.log
|
||||
:programname, isequal, "ssd-mount" /var/log/ssd-management.log
|
||||
:programname, isequal, "ssd-test" /var/log/ssd-testing.log
|
||||
& stop
|
||||
```
|
||||
|
||||
## Bash-Completion
|
||||
|
||||
### Auto-Completion aktivieren
|
||||
```bash
|
||||
# /etc/bash_completion.d/ssd-tools
|
||||
_ssd_detect() {
|
||||
local cur prev opts
|
||||
COMPREPLY=()
|
||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
||||
prev="${COMP_WORDS[COMP_CWORD-1]}"
|
||||
opts="--verbose --ntfs-only --device --output --monitor --debug"
|
||||
|
||||
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
||||
return 0
|
||||
}
|
||||
complete -F _ssd_detect ssd-detect.sh
|
||||
```
|
||||
|
||||
## Deinstallation
|
||||
|
||||
### Vollständige Deinstallation
|
||||
```bash
|
||||
# Deinstallations-Script ausführen
|
||||
sudo ./scripts/installation/uninstall.sh
|
||||
|
||||
# Manuelle Deinstallation
|
||||
sudo systemctl stop ssd-detection.service ssd-automount.service
|
||||
sudo systemctl disable ssd-detection.service ssd-automount.service
|
||||
sudo rm /etc/systemd/system/ssd-*.service
|
||||
sudo rm /usr/local/bin/ssd-*
|
||||
sudo rm /etc/udev/rules.d/99-ssd-automount.rules
|
||||
```
|
||||
|
||||
### Konfiguration beibehalten
|
||||
```bash
|
||||
# Nur Scripts entfernen, Konfiguration behalten
|
||||
sudo ./scripts/installation/uninstall.sh --keep-config
|
||||
```
|
||||
|
||||
## Upgrade-Prozess
|
||||
|
||||
### In-Place Upgrade
|
||||
```bash
|
||||
# Repository aktualisieren
|
||||
git pull origin main
|
||||
|
||||
# Upgrade ausführen
|
||||
sudo ./scripts/installation/install.sh --upgrade
|
||||
|
||||
# Services neu starten
|
||||
sudo systemctl restart ssd-detection.service
|
||||
```
|
||||
|
||||
### Backup vor Upgrade
|
||||
```bash
|
||||
# Konfiguration sichern
|
||||
sudo cp -r /etc/ssd-management /etc/ssd-management.backup
|
||||
|
||||
# Scripts sichern
|
||||
sudo cp /usr/local/bin/ssd-* /tmp/ssd-backup/
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Installations-Probleme
|
||||
```bash
|
||||
# Installation mit Debug-Output
|
||||
sudo ./install.sh --debug --verbose
|
||||
|
||||
# Abhängigkeits-Probleme prüfen
|
||||
./install.sh --check-dependencies
|
||||
|
||||
# Berechtigungs-Probleme
|
||||
sudo ./install.sh --fix-permissions
|
||||
```
|
||||
|
||||
### Häufige Probleme
|
||||
1. **Permission denied**: Installation mit `sudo` ausführen
|
||||
2. **Package not found**: Repository-Updates durchführen
|
||||
3. **Service failed**: Systemd-Logs prüfen (`journalctl -u ssd-detection.service`)
|
||||
|
||||
### Diagnose-Tools
|
||||
```bash
|
||||
# System-Diagnose
|
||||
./install.sh --diagnose
|
||||
|
||||
# Installations-Status prüfen
|
||||
./install.sh --status
|
||||
|
||||
# Konfiguration validieren
|
||||
./install.sh --validate
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
### Produktionsumgebung
|
||||
1. **Vollständige Installation** mit allen Komponenten
|
||||
2. **Systemd-Services aktivieren** für automatisches Management
|
||||
3. **Log-Rotation konfigurieren** für Langzeit-Betrieb
|
||||
4. **Monitoring einrichten** für Service-Überwachung
|
||||
5. **Backup-Strategie** für Konfigurationsdateien
|
||||
|
||||
### Entwicklungsumgebung
|
||||
1. **Komponenten-basierte Installation** für spezifische Tests
|
||||
2. **Debug-Modus aktivieren** für Entwicklung
|
||||
3. **User-Installation** für isolierte Tests
|
||||
4. **Häufige Upgrades** für aktuelle Features
|
||||
|
||||
## Changelog
|
||||
|
||||
### Version 0.1.0
|
||||
- Master-Installation Script
|
||||
- Systemd-Service Integration
|
||||
- Udev-Rules Konfiguration
|
||||
- Benutzer-Berechtigungen Setup
|
||||
- Logging-Infrastruktur
|
||||
- Bash-Completion Support
|
||||
170
scripts/ssd-detection/README.md
Normal file
170
scripts/ssd-detection/README.md
Normal file
@@ -0,0 +1,170 @@
|
||||
# SSD Detection Module
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das SSD Detection Module ist verantwortlich für die automatische Erkennung und Identifikation von USB-C SSDs im System. Es bietet robuste Hardware-Erkennung mit NTFS-Partition-Support.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### `ssd-detect.sh`
|
||||
**Zweck**: Automatische USB-C SSD Identifikation und NTFS-Partition Erkennung
|
||||
|
||||
**Hauptfunktionen**:
|
||||
- Erkennung neu angeschlossener USB-Storage-Devices
|
||||
- NTFS-Dateisystem Validierung
|
||||
- UUID-basierte Geräte-Identifikation
|
||||
- Hardware-Kompatibilitätsprüfung
|
||||
- Logging aller Erkennungsvorgänge
|
||||
|
||||
## Verwendung
|
||||
|
||||
### Grundlegende Erkennung
|
||||
```bash
|
||||
# Automatische SSD-Erkennung
|
||||
./ssd-detect.sh
|
||||
|
||||
# Verbose-Modus mit detailliertem Output
|
||||
./ssd-detect.sh --verbose
|
||||
|
||||
# Nur NTFS-Partitionen anzeigen
|
||||
./ssd-detect.sh --ntfs-only
|
||||
```
|
||||
|
||||
### Erweiterte Optionen
|
||||
```bash
|
||||
# Spezifisches Device prüfen
|
||||
./ssd-detect.sh --device /dev/sdb1
|
||||
|
||||
# JSON-Output für Automation
|
||||
./ssd-detect.sh --output json
|
||||
|
||||
# Kontinuierliche Überwachung
|
||||
./ssd-detect.sh --monitor
|
||||
```
|
||||
|
||||
## Ausgabe-Format
|
||||
|
||||
### Standard-Output
|
||||
```
|
||||
[INFO] USB-C SSD detected: /dev/sdb1
|
||||
[INFO] Filesystem: NTFS
|
||||
[INFO] UUID: 1234-5678-9ABC-DEF0
|
||||
[INFO] Size: 500GB
|
||||
[INFO] Label: BACKUP_SSD
|
||||
[SUCCESS] Device ready for mounting
|
||||
```
|
||||
|
||||
### JSON-Output
|
||||
```json
|
||||
{
|
||||
"device": "/dev/sdb1",
|
||||
"filesystem": "ntfs",
|
||||
"uuid": "1234-5678-9ABC-DEF0",
|
||||
"size": "500GB",
|
||||
"label": "BACKUP_SSD",
|
||||
"status": "ready"
|
||||
}
|
||||
```
|
||||
|
||||
## Konfiguration
|
||||
|
||||
### Environment Variables
|
||||
```bash
|
||||
# Standardmäßige Erkennungszeit (Sekunden)
|
||||
export SSD_DETECT_TIMEOUT=30
|
||||
|
||||
# Log-Level (DEBUG, INFO, WARN, ERROR)
|
||||
export SSD_LOG_LEVEL=INFO
|
||||
|
||||
# Unterstützte Dateisysteme
|
||||
export SSD_SUPPORTED_FS="ntfs,exfat,ext4"
|
||||
```
|
||||
|
||||
## Fehlerbehandlung
|
||||
|
||||
### Häufige Probleme
|
||||
1. **Keine SSD erkannt**: USB-Verbindung prüfen, Device-Permissions kontrollieren
|
||||
2. **NTFS nicht unterstützt**: `ntfs-3g` Package installieren
|
||||
3. **Permission denied**: Script mit `sudo` ausführen
|
||||
|
||||
### Debug-Modus
|
||||
```bash
|
||||
# Erweiterte Diagnose
|
||||
./ssd-detect.sh --debug
|
||||
|
||||
# System-Logs prüfen
|
||||
journalctl -f | grep ssd-detect
|
||||
```
|
||||
|
||||
## Integration
|
||||
|
||||
### Systemd-Service
|
||||
```bash
|
||||
# Automatische Erkennung bei Boot
|
||||
sudo systemctl enable ssd-detect.service
|
||||
```
|
||||
|
||||
### Udev-Rules
|
||||
```bash
|
||||
# Automatische Erkennung bei USB-Events
|
||||
# Siehe examples/udev-rules/
|
||||
```
|
||||
|
||||
## Abhängigkeiten
|
||||
|
||||
### Erforderliche Packages
|
||||
- `util-linux` - Device-Management
|
||||
- `ntfs-3g` - NTFS-Support
|
||||
- `parted` - Partitionstabellen
|
||||
- `udev` - Hardware-Events
|
||||
|
||||
### Installation
|
||||
```bash
|
||||
# Ubuntu/Debian
|
||||
sudo apt install util-linux ntfs-3g parted udev
|
||||
|
||||
# CentOS/RHEL
|
||||
sudo yum install util-linux ntfs-3g parted systemd-udev
|
||||
```
|
||||
|
||||
## Sicherheit
|
||||
|
||||
### Best Practices
|
||||
- Immer UUID-basierte Identifikation verwenden
|
||||
- Device-Permissions vor Zugriff prüfen
|
||||
- Logging für Audit-Trails aktivieren
|
||||
- Read-Only Modus für kritische Prüfungen
|
||||
|
||||
### Berechtigungen
|
||||
```bash
|
||||
# Minimale Berechtigungen für Detection
|
||||
sudo usermod -a -G disk $USER
|
||||
```
|
||||
|
||||
## Entwicklung
|
||||
|
||||
### Testing
|
||||
```bash
|
||||
# Unit-Tests ausführen
|
||||
./test-ssd-detect.sh
|
||||
|
||||
# Integration-Tests
|
||||
./test-ssd-detect-integration.sh
|
||||
```
|
||||
|
||||
### Debugging
|
||||
```bash
|
||||
# Trace-Modus
|
||||
bash -x ./ssd-detect.sh
|
||||
|
||||
# Profiling
|
||||
time ./ssd-detect.sh --benchmark
|
||||
```
|
||||
|
||||
## Changelog
|
||||
|
||||
### Version 0.1.0
|
||||
- Initiale Implementierung
|
||||
- NTFS-Support
|
||||
- UUID-basierte Erkennung
|
||||
- JSON-Output Format
|
||||
334
scripts/ssd-detection/ssd-safe-eject.sh
Normal file
334
scripts/ssd-detection/ssd-safe-eject.sh
Normal file
@@ -0,0 +1,334 @@
|
||||
#!/bin/bash
|
||||
# ssd-safe-eject.sh - Safe Eject Extension für USB-C SSDs
|
||||
# Zweck: Sichere Entfernung von USB-C SSDs mit vollständigem Sync und Hardware-Eject
|
||||
|
||||
set -e
|
||||
|
||||
# Konfiguration
|
||||
MOUNT_POINT="/mnt/ssd-storage"
|
||||
LOG_FILE="/var/log/ssd-mount.log"
|
||||
|
||||
# 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_message() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - SAFE-EJECT: $1" | sudo tee -a "$LOG_FILE"
|
||||
echo -e "${BLUE}[SAFE-EJECT]${NC} $1"
|
||||
}
|
||||
|
||||
log_success() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" | sudo tee -a "$LOG_FILE"
|
||||
echo -e "${GREEN}[✓]${NC} $1"
|
||||
}
|
||||
|
||||
log_warning() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" | sudo tee -a "$LOG_FILE"
|
||||
echo -e "${YELLOW}[!]${NC} $1"
|
||||
}
|
||||
|
||||
log_error() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" | sudo tee -a "$LOG_FILE"
|
||||
echo -e "${RED}[✗]${NC} $1"
|
||||
}
|
||||
|
||||
# Schritt 1: Pre-Eject Validierung
|
||||
validate_pre_eject() {
|
||||
log_message "Validiere Pre-Eject Status..."
|
||||
|
||||
if ! mountpoint -q "$MOUNT_POINT"; then
|
||||
log_warning "Keine SSD auf $MOUNT_POINT gemountet"
|
||||
return 1
|
||||
fi
|
||||
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
log_success "Gemountetes Device identifiziert: $mounted_device"
|
||||
|
||||
# Prüfe ob Device USB-Device ist
|
||||
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
|
||||
if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
|
||||
log_success "USB-Device bestätigt: $device_base"
|
||||
echo "$mounted_device"
|
||||
return 0
|
||||
else
|
||||
log_error "Device ist kein USB-Device - Safe-Eject nicht anwendbar"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Schritt 2: Aktive Prozesse prüfen
|
||||
check_active_processes() {
|
||||
local device="$1"
|
||||
log_message "Prüfe aktive Prozesse auf $MOUNT_POINT..."
|
||||
|
||||
# Prozesse finden die das Mount-Point verwenden
|
||||
active_processes=$(lsof "$MOUNT_POINT" 2>/dev/null || true)
|
||||
|
||||
if [ -n "$active_processes" ]; then
|
||||
log_warning "Aktive Prozesse gefunden:"
|
||||
echo "$active_processes"
|
||||
echo ""
|
||||
echo "Prozesse beenden? (y/n/s für skip)"
|
||||
read -r response
|
||||
|
||||
case "$response" in
|
||||
"y"|"Y")
|
||||
log_message "Beende Prozesse..."
|
||||
lsof -t "$MOUNT_POINT" 2>/dev/null | xargs -r sudo kill -TERM
|
||||
sleep 2
|
||||
# Prüfe erneut
|
||||
remaining=$(lsof "$MOUNT_POINT" 2>/dev/null || true)
|
||||
if [ -n "$remaining" ]; then
|
||||
log_warning "Einige Prozesse laufen noch - Force Kill..."
|
||||
lsof -t "$MOUNT_POINT" 2>/dev/null | xargs -r sudo kill -KILL
|
||||
fi
|
||||
log_success "Prozesse beendet"
|
||||
;;
|
||||
"s"|"S")
|
||||
log_warning "Prozesse werden nicht beendet - Fortfahren auf eigene Gefahr"
|
||||
;;
|
||||
*)
|
||||
log_message "Safe-Eject abgebrochen"
|
||||
return 1
|
||||
;;
|
||||
esac
|
||||
else
|
||||
log_success "Keine aktiven Prozesse gefunden"
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Schritt 3: Vollständiger Daten-Sync
|
||||
perform_full_sync() {
|
||||
log_message "Führe vollständigen Daten-Sync durch..."
|
||||
|
||||
# Globaler Sync
|
||||
log_message "Globaler Sync..."
|
||||
sync
|
||||
|
||||
# Warte auf Dirty Pages Flush
|
||||
log_message "Warte auf Buffer-Flush..."
|
||||
local timeout=30
|
||||
local count=0
|
||||
|
||||
while [ $count -lt $timeout ]; do
|
||||
dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
|
||||
writeback_pages=$(cat /proc/meminfo | grep "Writeback:" | awk '{print $2}')
|
||||
|
||||
if [ "$dirty_pages" -le 4 ] && [ "$writeback_pages" -le 4 ]; then
|
||||
log_success "Buffer-Flush abgeschlossen (Dirty: ${dirty_pages}kB, Writeback: ${writeback_pages}kB)"
|
||||
break
|
||||
fi
|
||||
|
||||
if [ $((count % 5)) -eq 0 ]; then
|
||||
log_message "Warte auf Buffer-Flush... (Dirty: ${dirty_pages}kB, Writeback: ${writeback_pages}kB)"
|
||||
fi
|
||||
|
||||
sleep 1
|
||||
count=$((count + 1))
|
||||
done
|
||||
|
||||
if [ $count -ge $timeout ]; then
|
||||
log_warning "Buffer-Flush Timeout erreicht - Fortfahren..."
|
||||
fi
|
||||
|
||||
# Finaler Sync
|
||||
log_message "Finaler Sync..."
|
||||
sync
|
||||
sleep 2
|
||||
|
||||
log_success "Vollständiger Sync abgeschlossen"
|
||||
}
|
||||
|
||||
# Schritt 4: Filesystem Unmount
|
||||
perform_unmount() {
|
||||
local device="$1"
|
||||
log_message "Unmounte Dateisystem: $device"
|
||||
|
||||
# Lazy Unmount falls normal unmount fehlschlägt
|
||||
if ! sudo umount "$MOUNT_POINT" 2>/dev/null; then
|
||||
log_warning "Normaler Unmount fehlgeschlagen - versuche Lazy Unmount..."
|
||||
|
||||
if sudo umount -l "$MOUNT_POINT" 2>/dev/null; then
|
||||
log_success "Lazy Unmount erfolgreich"
|
||||
else
|
||||
log_error "Unmount fehlgeschlagen"
|
||||
return 1
|
||||
fi
|
||||
else
|
||||
log_success "Unmount erfolgreich"
|
||||
fi
|
||||
|
||||
# Verifikation
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
log_error "Mount-Point noch aktiv nach Unmount"
|
||||
return 1
|
||||
else
|
||||
log_success "Mount-Point erfolgreich getrennt"
|
||||
return 0
|
||||
fi
|
||||
}
|
||||
|
||||
# Schritt 5: Hardware-Eject
|
||||
perform_hardware_eject() {
|
||||
local device="$1"
|
||||
local device_base=$(echo "$device" | sed 's/[0-9]*$//')
|
||||
|
||||
log_message "Hardware-Eject für Device: $device_base"
|
||||
|
||||
# Prüfe ob eject verfügbar ist
|
||||
if ! command -v eject >/dev/null; then
|
||||
log_warning "eject Befehl nicht verfügbar - installiere eject..."
|
||||
sudo apt update && sudo apt install -y eject
|
||||
fi
|
||||
|
||||
# Hardware-Eject durchführen
|
||||
if sudo eject "$device_base" 2>/dev/null; then
|
||||
log_success "Hardware-Eject erfolgreich: $device_base"
|
||||
else
|
||||
log_warning "Hardware-Eject fehlgeschlagen - möglicherweise nicht unterstützt"
|
||||
|
||||
# Alternative: USB-Device über sysfs deaktivieren
|
||||
usb_device=$(udevadm info --query=path --name="$device_base" 2>/dev/null | sed 's|/block/.*||')
|
||||
if [ -n "$usb_device" ]; then
|
||||
log_message "Versuche USB-Device Deaktivierung über sysfs..."
|
||||
if echo 1 | sudo tee "/sys$usb_device/remove" >/dev/null 2>&1; then
|
||||
log_success "USB-Device über sysfs deaktiviert"
|
||||
else
|
||||
log_warning "USB-Device Deaktivierung fehlgeschlagen"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
# Schritt 6: Post-Eject Validierung
|
||||
validate_post_eject() {
|
||||
local device="$1"
|
||||
local device_base=$(echo "$device" | sed 's/[0-9]*$//')
|
||||
|
||||
log_message "Post-Eject Validierung..."
|
||||
|
||||
# Prüfe ob Mount-Point noch aktiv
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
log_error "Mount-Point noch aktiv - Safe-Eject unvollständig"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Prüfe ob Device noch sichtbar
|
||||
sleep 3 # Kurze Wartezeit für System-Update
|
||||
|
||||
if [ -b "$device_base" ]; then
|
||||
log_warning "Device noch im System sichtbar: $device_base"
|
||||
log_message "Device kann möglicherweise manuell entfernt werden"
|
||||
else
|
||||
log_success "Device nicht mehr im System sichtbar"
|
||||
fi
|
||||
|
||||
log_success "Post-Eject Validierung abgeschlossen"
|
||||
return 0
|
||||
}
|
||||
|
||||
# Safe-Eject Status anzeigen
|
||||
show_eject_status() {
|
||||
echo ""
|
||||
echo "=== Safe-Eject Status ==="
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
|
||||
|
||||
echo "✓ Gemountetes Device: $mounted_device"
|
||||
echo "✓ Hardware Device: $device_base"
|
||||
|
||||
# USB-Status prüfen
|
||||
if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
|
||||
echo "✓ USB-Device: Ja"
|
||||
echo "✓ Safe-Eject: Verfügbar"
|
||||
else
|
||||
echo "✗ USB-Device: Nein"
|
||||
echo "✗ Safe-Eject: Nicht verfügbar"
|
||||
fi
|
||||
|
||||
# Aktive Prozesse prüfen
|
||||
active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
|
||||
if [ "$active_count" -gt 0 ]; then
|
||||
echo "! Aktive Prozesse: $active_count"
|
||||
else
|
||||
echo "✓ Aktive Prozesse: Keine"
|
||||
fi
|
||||
|
||||
else
|
||||
echo "✗ Kein Device gemountet"
|
||||
echo "✗ Safe-Eject: Nicht erforderlich"
|
||||
fi
|
||||
echo ""
|
||||
}
|
||||
|
||||
# Hauptfunktion Safe-Eject
|
||||
safe_eject_main() {
|
||||
echo "=== USB-C SSD Safe-Eject ==="
|
||||
echo "Version: 1.0"
|
||||
echo ""
|
||||
|
||||
# Pre-Validierung
|
||||
device=$(validate_pre_eject)
|
||||
if [ $? -ne 0 ]; then
|
||||
return 1
|
||||
fi
|
||||
|
||||
echo "=== Safe-Eject Prozess gestartet für: $device ==="
|
||||
echo ""
|
||||
|
||||
# Aktive Prozesse prüfen
|
||||
if ! check_active_processes "$device"; then
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Vollständiger Sync
|
||||
perform_full_sync
|
||||
|
||||
# Unmount
|
||||
if ! perform_unmount "$device"; then
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Hardware-Eject
|
||||
perform_hardware_eject "$device"
|
||||
|
||||
# Post-Validierung
|
||||
validate_post_eject "$device"
|
||||
|
||||
echo ""
|
||||
echo "=== Safe-Eject abgeschlossen ==="
|
||||
echo "USB-C SSD kann jetzt sicher entfernt werden."
|
||||
echo ""
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Hauptfunktion
|
||||
main() {
|
||||
case "${1:-eject}" in
|
||||
"eject")
|
||||
safe_eject_main
|
||||
;;
|
||||
"status")
|
||||
show_eject_status
|
||||
;;
|
||||
*)
|
||||
echo "Verwendung: $0 {eject|status}"
|
||||
echo ""
|
||||
echo "Befehle:"
|
||||
echo " eject - Sichere SSD-Entfernung durchführen"
|
||||
echo " status - Safe-Eject Status anzeigen"
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
# Script ausführen
|
||||
main "$@"
|
||||
264
scripts/ssd-management/README.md
Normal file
264
scripts/ssd-management/README.md
Normal file
@@ -0,0 +1,264 @@
|
||||
# SSD Management Module
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das SSD Management Module verwaltet den kompletten Lifecycle von USB-C SSDs - von Mount-Operationen bis zur sicheren Entfernung. Es bietet flexibles Mounting mit konstantem Mount-Point und umfassende Sicherheitsfeatures.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### `ssd-mount-manager.sh`
|
||||
**Zweck**: Flexibles Mount-Lifecycle Management mit konstantem Mount-Point
|
||||
|
||||
**Hauptfunktionen**:
|
||||
- Automatisches Mounting auf `/mnt/ssd-storage`
|
||||
- NTFS-Kompatibilität mit optimierten Mount-Optionen
|
||||
- UUID-basierte Geräte-Zuordnung
|
||||
- Mount-Status Überwachung
|
||||
- Fehlerbehandlung und Recovery
|
||||
|
||||
### `ssd-safe-eject.sh`
|
||||
**Zweck**: Sichere Hardware-Entfernung mit Datenintegritäts-Schutz
|
||||
|
||||
**Hauptfunktionen**:
|
||||
- Buffer-Flush Überwachung
|
||||
- Prozess-Detection vor Eject
|
||||
- Hardware-Eject Funktionalität
|
||||
- Cleanup von Mount-Points
|
||||
- Audit-Logging
|
||||
|
||||
## Verwendung
|
||||
|
||||
### Mount-Manager
|
||||
|
||||
#### Grundlegende Mount-Operationen
|
||||
```bash
|
||||
# Automatisches Mounting der erkannten SSD
|
||||
./ssd-mount-manager.sh mount
|
||||
|
||||
# Spezifische SSD mounten
|
||||
./ssd-mount-manager.sh mount --device /dev/sdb1
|
||||
|
||||
# Read-Only Mount für kritische Prüfungen
|
||||
./ssd-mount-manager.sh mount --readonly
|
||||
|
||||
# Mount-Status prüfen
|
||||
./ssd-mount-manager.sh status
|
||||
```
|
||||
|
||||
#### Erweiterte Mount-Optionen
|
||||
```bash
|
||||
# Custom Mount-Point
|
||||
./ssd-mount-manager.sh mount --mountpoint /custom/path
|
||||
|
||||
# Spezifische NTFS-Optionen
|
||||
./ssd-mount-manager.sh mount --options "uid=1000,gid=1000,umask=022"
|
||||
|
||||
# Automatisches Remounting
|
||||
./ssd-mount-manager.sh remount
|
||||
```
|
||||
|
||||
### Safe-Eject
|
||||
|
||||
#### Sichere Entfernung
|
||||
```bash
|
||||
# Standard Safe-Eject
|
||||
./ssd-safe-eject.sh
|
||||
|
||||
# Force-Eject (bei hängenden Prozessen)
|
||||
./ssd-safe-eject.sh --force
|
||||
|
||||
# Eject mit Prozess-Übersicht
|
||||
./ssd-safe-eject.sh --show-processes
|
||||
|
||||
# Nur Unmount (ohne Hardware-Eject)
|
||||
./ssd-safe-eject.sh --unmount-only
|
||||
```
|
||||
|
||||
#### Erweiterte Eject-Optionen
|
||||
```bash
|
||||
# Timeout für Buffer-Flush
|
||||
./ssd-safe-eject.sh --timeout 60
|
||||
|
||||
# Verbose-Modus
|
||||
./ssd-safe-eject.sh --verbose
|
||||
|
||||
# Dry-Run (Simulation)
|
||||
./ssd-safe-eject.sh --dry-run
|
||||
```
|
||||
|
||||
## Konfiguration
|
||||
|
||||
### Mount-Manager Konfiguration
|
||||
```bash
|
||||
# Standard Mount-Point
|
||||
export SSD_MOUNT_POINT="/mnt/ssd-storage"
|
||||
|
||||
# Standard NTFS-Optionen
|
||||
export SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022,windows_names"
|
||||
|
||||
# Timeout für Mount-Operationen
|
||||
export SSD_MOUNT_TIMEOUT=30
|
||||
```
|
||||
|
||||
### Safe-Eject Konfiguration
|
||||
```bash
|
||||
# Buffer-Flush Timeout
|
||||
export SSD_EJECT_TIMEOUT=60
|
||||
|
||||
# Prozess-Kill Timeout
|
||||
export SSD_PROCESS_TIMEOUT=10
|
||||
|
||||
# Hardware-Eject aktivieren
|
||||
export SSD_HARDWARE_EJECT=true
|
||||
```
|
||||
|
||||
## Mount-Point Management
|
||||
|
||||
### Konstanter Mount-Point
|
||||
Das System verwendet einen konstanten logischen Mount-Point (`/mnt/ssd-storage`), unabhängig von der physischen SSD:
|
||||
|
||||
```bash
|
||||
# Immer derselbe Pfad, verschiedene SSDs
|
||||
/mnt/ssd-storage/ # SSD A
|
||||
/mnt/ssd-storage/ # SSD B (nach Wechsel)
|
||||
/mnt/ssd-storage/ # SSD C (nach Wechsel)
|
||||
```
|
||||
|
||||
### SMB-Freigabe Vorbereitung
|
||||
```bash
|
||||
# Optimierte Berechtigungen für SMB
|
||||
./ssd-mount-manager.sh mount --smb-ready
|
||||
|
||||
# Automatische SMB-Konfiguration
|
||||
./ssd-mount-manager.sh mount --configure-smb
|
||||
```
|
||||
|
||||
## Sicherheitsfeatures
|
||||
|
||||
### Prozess-Detection
|
||||
```bash
|
||||
# Aktive Prozesse vor Eject anzeigen
|
||||
lsof /mnt/ssd-storage
|
||||
|
||||
# Automatische Prozess-Beendigung
|
||||
./ssd-safe-eject.sh --kill-processes
|
||||
```
|
||||
|
||||
### Buffer-Flush Überwachung
|
||||
```bash
|
||||
# Manueller Sync vor Eject
|
||||
sync && echo 3 > /proc/sys/vm/drop_caches
|
||||
|
||||
# Automatische Buffer-Überwachung
|
||||
./ssd-safe-eject.sh --monitor-buffers
|
||||
```
|
||||
|
||||
### Datenintegritäts-Prüfung
|
||||
```bash
|
||||
# Filesystem-Check vor Mount
|
||||
./ssd-mount-manager.sh mount --fsck
|
||||
|
||||
# Readonly-Test vor produktivem Mount
|
||||
./ssd-mount-manager.sh test-mount
|
||||
```
|
||||
|
||||
## Fehlerbehandlung
|
||||
|
||||
### Mount-Fehler
|
||||
```bash
|
||||
# Häufige Mount-Probleme diagnostizieren
|
||||
./ssd-mount-manager.sh diagnose
|
||||
|
||||
# Mount-Point Cleanup
|
||||
./ssd-mount-manager.sh cleanup
|
||||
|
||||
# Recovery-Modus
|
||||
./ssd-mount-manager.sh recover
|
||||
```
|
||||
|
||||
### Eject-Fehler
|
||||
```bash
|
||||
# Hängende Prozesse identifizieren
|
||||
./ssd-safe-eject.sh --list-blocking-processes
|
||||
|
||||
# Force-Unmount
|
||||
./ssd-safe-eject.sh --force-unmount
|
||||
|
||||
# Hardware-Reset
|
||||
./ssd-safe-eject.sh --hardware-reset
|
||||
```
|
||||
|
||||
## Logging und Monitoring
|
||||
|
||||
### Log-Konfiguration
|
||||
```bash
|
||||
# Log-Level setzen
|
||||
export SSD_LOG_LEVEL=INFO
|
||||
|
||||
# Log-Datei konfigurieren
|
||||
export SSD_LOG_FILE="/var/log/ssd-management.log"
|
||||
|
||||
# Syslog-Integration
|
||||
export SSD_USE_SYSLOG=true
|
||||
```
|
||||
|
||||
### Monitoring-Integration
|
||||
```bash
|
||||
# Prometheus-Metriken
|
||||
./ssd-mount-manager.sh --metrics
|
||||
|
||||
# Status-JSON für Monitoring
|
||||
./ssd-mount-manager.sh status --json
|
||||
```
|
||||
|
||||
## Systemd-Integration
|
||||
|
||||
### Service-Templates
|
||||
```bash
|
||||
# Mount-Service aktivieren
|
||||
sudo systemctl enable ssd-mount@.service
|
||||
|
||||
# Auto-Mount bei USB-Events
|
||||
sudo systemctl enable ssd-automount.service
|
||||
```
|
||||
|
||||
### Service-Konfiguration
|
||||
```ini
|
||||
# /etc/systemd/system/ssd-mount@.service
|
||||
[Unit]
|
||||
Description=SSD Mount Manager for %i
|
||||
After=local-fs.target
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --device %i
|
||||
ExecStop=/usr/local/bin/ssd-safe-eject.sh --device %i
|
||||
RemainAfterExit=yes
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
### Produktionsumgebung
|
||||
1. **Immer Safe-Eject verwenden** statt direkter `umount`
|
||||
2. **Mount-Status überwachen** vor kritischen Operationen
|
||||
3. **Logs regelmäßig prüfen** für Anomalien
|
||||
4. **Backup vor Mount-Operationen** bei kritischen Daten
|
||||
5. **Systemd-Services nutzen** für automatisches Management
|
||||
|
||||
### Entwicklungsumgebung
|
||||
1. **Dry-Run Modus** für Tests verwenden
|
||||
2. **Verbose-Logging** für Debugging aktivieren
|
||||
3. **Recovery-Scripte** bereithalten
|
||||
4. **Test-SSDs** für Entwicklung verwenden
|
||||
|
||||
## Changelog
|
||||
|
||||
### Version 0.1.0
|
||||
- Initiale Implementierung
|
||||
- Mount-Manager mit konstantem Mount-Point
|
||||
- Safe-Eject mit Prozess-Detection
|
||||
- NTFS-Optimierungen
|
||||
- Systemd-Integration
|
||||
347
scripts/ssd-management/ssd-mount-manager.sh
Normal file
347
scripts/ssd-management/ssd-mount-manager.sh
Normal file
@@ -0,0 +1,347 @@
|
||||
#!/bin/bash
|
||||
# ssd-mount-manager.sh - USB-C SSD Mount Management
|
||||
# Zweck: Flexibles Mounting verschiedener SSDs auf konstanten Mount-Point
|
||||
|
||||
set -e
|
||||
|
||||
# Konfiguration
|
||||
MOUNT_POINT="/mnt/ssd-storage"
|
||||
CONFIG_FILE="/etc/ssd-mount.conf"
|
||||
LOG_FILE="/var/log/ssd-mount.log"
|
||||
|
||||
# Logging-Funktion
|
||||
log_message() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | sudo tee -a "$LOG_FILE"
|
||||
echo "$1"
|
||||
}
|
||||
|
||||
# Konfigurationsdatei erstellen
|
||||
create_config() {
|
||||
log_message "Erstelle Konfigurationsdatei..."
|
||||
sudo tee "$CONFIG_FILE" > /dev/null << EOF
|
||||
# SSD Mount Manager Konfiguration
|
||||
# Erstellt: $(date)
|
||||
|
||||
# Standard Mount-Point
|
||||
MOUNT_POINT="$MOUNT_POINT"
|
||||
|
||||
# Standard Mount-Optionen für NTFS
|
||||
MOUNT_OPTIONS="defaults,uid=1000,gid=1000,umask=002,fmask=111,noatime"
|
||||
|
||||
# Automatisches Unmounting bei Shutdown
|
||||
AUTO_UMOUNT=true
|
||||
|
||||
# Backup der letzten gemounteten SSD
|
||||
LAST_DEVICE=""
|
||||
LAST_UUID=""
|
||||
EOF
|
||||
log_message "Konfiguration erstellt: $CONFIG_FILE"
|
||||
}
|
||||
|
||||
# Konfiguration laden
|
||||
load_config() {
|
||||
if [ -f "$CONFIG_FILE" ]; then
|
||||
source "$CONFIG_FILE"
|
||||
else
|
||||
create_config
|
||||
source "$CONFIG_FILE"
|
||||
fi
|
||||
}
|
||||
|
||||
# Mount-Point vorbereiten
|
||||
prepare_mount_point() {
|
||||
log_message "Bereite Mount-Point vor: $MOUNT_POINT"
|
||||
|
||||
if [ ! -d "$MOUNT_POINT" ]; then
|
||||
sudo mkdir -p "$MOUNT_POINT"
|
||||
log_message "Mount-Point erstellt: $MOUNT_POINT"
|
||||
fi
|
||||
|
||||
sudo chown root:root "$MOUNT_POINT"
|
||||
sudo chmod 755 "$MOUNT_POINT"
|
||||
log_message "Mount-Point Berechtigungen gesetzt"
|
||||
}
|
||||
|
||||
# Aktuelle Mounts prüfen
|
||||
check_current_mount() {
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
log_message "Aktuell gemountet: $mounted_device auf $MOUNT_POINT"
|
||||
return 0
|
||||
else
|
||||
log_message "Kein Device auf $MOUNT_POINT gemountet"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Device unmounten
|
||||
unmount_device() {
|
||||
log_message "Unmounte Device von $MOUNT_POINT..."
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
log_message "Unmounte $mounted_device..."
|
||||
|
||||
sudo umount "$MOUNT_POINT"
|
||||
log_message "Device erfolgreich unmountet"
|
||||
|
||||
# Letztes Device in Config speichern
|
||||
update_last_device ""
|
||||
else
|
||||
log_message "Kein Device zum Unmounten gefunden"
|
||||
fi
|
||||
}
|
||||
|
||||
# Safe-Eject Funktion
|
||||
safe_eject_device() {
|
||||
log_message "Starte Safe-Eject Prozess..."
|
||||
|
||||
# Externes Safe-Eject Script aufrufen
|
||||
if command -v ssd-safe-eject >/dev/null; then
|
||||
ssd-safe-eject eject
|
||||
else
|
||||
# Fallback: Integrierte Safe-Eject Funktionalität
|
||||
perform_integrated_safe_eject
|
||||
fi
|
||||
}
|
||||
|
||||
# Integrierte Safe-Eject Funktionalität
|
||||
perform_integrated_safe_eject() {
|
||||
if ! mountpoint -q "$MOUNT_POINT"; then
|
||||
log_message "Keine SSD gemountet - Safe-Eject nicht erforderlich"
|
||||
return 1
|
||||
fi
|
||||
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
|
||||
|
||||
log_message "Safe-Eject für $mounted_device..."
|
||||
|
||||
# Vollständiger Sync
|
||||
log_message "Führe Sync durch..."
|
||||
sync
|
||||
sleep 2
|
||||
|
||||
# Unmount
|
||||
log_message "Unmounte Device..."
|
||||
if sudo umount "$MOUNT_POINT"; then
|
||||
log_success "Unmount erfolgreich"
|
||||
else
|
||||
log_error "Unmount fehlgeschlagen"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Hardware-Eject
|
||||
log_message "Hardware-Eject..."
|
||||
if command -v eject >/dev/null; then
|
||||
if sudo eject "$device_base" 2>/dev/null; then
|
||||
log_success "Hardware-Eject erfolgreich"
|
||||
else
|
||||
log_warning "Hardware-Eject fehlgeschlagen"
|
||||
fi
|
||||
else
|
||||
log_warning "eject Befehl nicht verfügbar"
|
||||
fi
|
||||
|
||||
# Finaler Sync
|
||||
sync
|
||||
|
||||
log_success "Safe-Eject abgeschlossen - SSD kann entfernt werden"
|
||||
update_last_device ""
|
||||
}
|
||||
# Device mounten
|
||||
mount_device() {
|
||||
local device="$1"
|
||||
|
||||
if [ -z "$device" ]; then
|
||||
log_message "Fehler: Kein Device angegeben"
|
||||
return 1
|
||||
fi
|
||||
|
||||
if [ ! -b "$device" ]; then
|
||||
log_message "Fehler: Device $device existiert nicht"
|
||||
return 1
|
||||
fi
|
||||
|
||||
log_message "Mounte Device: $device"
|
||||
|
||||
# Prüfe ob bereits etwas gemountet ist
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
log_message "Mount-Point bereits belegt - unmounte zuerst..."
|
||||
unmount_device
|
||||
fi
|
||||
|
||||
# Device mounten
|
||||
log_message "Mounte $device auf $MOUNT_POINT mit Optionen: $MOUNT_OPTIONS"
|
||||
sudo mount -t ntfs-3g -o "$MOUNT_OPTIONS" "$device" "$MOUNT_POINT"
|
||||
|
||||
if [ $? -eq 0 ]; then
|
||||
log_message "Mount erfolgreich: $device auf $MOUNT_POINT"
|
||||
|
||||
# Device-Info speichern
|
||||
device_uuid=$(sudo blkid -s UUID -o value "$device")
|
||||
update_last_device "$device" "$device_uuid"
|
||||
|
||||
# Mount-Status anzeigen
|
||||
show_mount_status
|
||||
return 0
|
||||
else
|
||||
log_message "Fehler beim Mounten von $device"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Letztes Device in Config updaten
|
||||
update_last_device() {
|
||||
local device="$1"
|
||||
local uuid="$2"
|
||||
|
||||
sudo sed -i "s|LAST_DEVICE=.*|LAST_DEVICE=\"$device\"|" "$CONFIG_FILE"
|
||||
sudo sed -i "s|LAST_UUID=.*|LAST_UUID=\"$uuid\"|" "$CONFIG_FILE"
|
||||
}
|
||||
|
||||
# Mount-Status anzeigen
|
||||
show_mount_status() {
|
||||
echo ""
|
||||
echo "=== Mount-Status ==="
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
echo "✓ Gemountet: $mounted_device"
|
||||
echo "✓ Mount-Point: $MOUNT_POINT"
|
||||
|
||||
# Speicherplatz anzeigen
|
||||
df -h "$MOUNT_POINT"
|
||||
echo ""
|
||||
|
||||
# Device-Details
|
||||
device_uuid=$(sudo blkid -s UUID -o value "$mounted_device")
|
||||
device_label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null || echo "Kein Label")
|
||||
echo "UUID: $device_uuid"
|
||||
echo "Label: $device_label"
|
||||
|
||||
# Zugriffstest
|
||||
if [ -r "$MOUNT_POINT" ]; then
|
||||
echo "✓ Lesezugriff: OK"
|
||||
else
|
||||
echo "✗ Lesezugriff: Fehler"
|
||||
fi
|
||||
|
||||
if [ -w "$MOUNT_POINT" ]; then
|
||||
echo "✓ Schreibzugriff: OK"
|
||||
else
|
||||
echo "✗ Schreibzugriff: Fehler"
|
||||
fi
|
||||
|
||||
else
|
||||
echo "✗ Kein Device gemountet auf $MOUNT_POINT"
|
||||
fi
|
||||
echo ""
|
||||
}
|
||||
|
||||
# Verfügbare NTFS-Devices auflisten
|
||||
list_ntfs_devices() {
|
||||
echo "=== Verfügbare NTFS-Devices ==="
|
||||
lsblk -f | grep ntfs | while IFS= read -r line; do
|
||||
device=$(echo "$line" | awk '{print "/dev/" $1}')
|
||||
uuid=$(echo "$line" | awk '{print $3}')
|
||||
label=$(echo "$line" | awk '{print $4}')
|
||||
size=$(lsblk -o SIZE "$device" 2>/dev/null | tail -1)
|
||||
echo "$device | $size | UUID: $uuid | Label: $label"
|
||||
done
|
||||
echo ""
|
||||
}
|
||||
|
||||
# Automatisches Device-Detection
|
||||
auto_detect_device() {
|
||||
log_message "Automatische Device-Erkennung..."
|
||||
|
||||
# Suche nach NTFS-Partitionen auf USB-Devices
|
||||
for device in /dev/sd[a-z][0-9]*; do
|
||||
if [ -b "$device" ]; then
|
||||
fstype=$(lsblk -o FSTYPE "$device" 2>/dev/null | tail -1 | xargs)
|
||||
if [ "$fstype" = "ntfs" ]; then
|
||||
size=$(lsblk -b -o SIZE "$device" 2>/dev/null | tail -1)
|
||||
size_gb=$((size / 1024 / 1024 / 1024))
|
||||
|
||||
# Nur Devices > 100GB berücksichtigen (typisch für SSDs)
|
||||
if [ $size_gb -gt 100 ]; then
|
||||
log_message "NTFS-SSD gefunden: $device (${size_gb}GB)"
|
||||
echo "$device"
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
log_message "Keine geeignete NTFS-SSD gefunden"
|
||||
return 1
|
||||
}
|
||||
|
||||
# Hauptfunktion
|
||||
main() {
|
||||
echo "=== USB-C SSD Mount Manager ==="
|
||||
echo "Version: 1.0"
|
||||
echo ""
|
||||
|
||||
load_config
|
||||
prepare_mount_point
|
||||
|
||||
case "${1:-status}" in
|
||||
"mount")
|
||||
if [ -n "$2" ]; then
|
||||
mount_device "$2"
|
||||
else
|
||||
# Auto-Detection
|
||||
auto_device=$(auto_detect_device)
|
||||
if [ -n "$auto_device" ]; then
|
||||
echo "Auto-erkanntes Device: $auto_device"
|
||||
echo "Mounten? (y/n)"
|
||||
read -r response
|
||||
if [ "$response" = "y" ] || [ "$response" = "Y" ]; then
|
||||
mount_device "$auto_device"
|
||||
fi
|
||||
else
|
||||
echo "Kein Device auto-erkannt. Verfügbare Devices:"
|
||||
list_ntfs_devices
|
||||
fi
|
||||
fi
|
||||
;;
|
||||
"unmount"|"umount")
|
||||
unmount_device
|
||||
;;
|
||||
"safe-eject"|"eject")
|
||||
safe_eject_device
|
||||
;;
|
||||
"status")
|
||||
show_mount_status
|
||||
;;
|
||||
"list")
|
||||
list_ntfs_devices
|
||||
;;
|
||||
"remount")
|
||||
if check_current_mount; then
|
||||
unmount_device
|
||||
sleep 2
|
||||
fi
|
||||
auto_device=$(auto_detect_device)
|
||||
if [ -n "$auto_device" ]; then
|
||||
mount_device "$auto_device"
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
echo "Verwendung: $0 {mount [device]|unmount|safe-eject|status|list|remount}"
|
||||
echo ""
|
||||
echo "Befehle:"
|
||||
echo " mount [device] - Device mounten (auto-detect wenn kein device)"
|
||||
echo " unmount - Device unmounten (einfach)"
|
||||
echo " safe-eject - Sichere USB-C SSD Entfernung mit Hardware-Eject"
|
||||
echo " status - Mount-Status anzeigen"
|
||||
echo " list - Verfügbare NTFS-Devices auflisten"
|
||||
echo " remount - Unmount + Auto-detect + Mount"
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
# Script ausführen
|
||||
main "$@"
|
||||
349
scripts/ssd-testing/README.md
Normal file
349
scripts/ssd-testing/README.md
Normal file
@@ -0,0 +1,349 @@
|
||||
# SSD Testing Module
|
||||
|
||||
## Übersicht
|
||||
|
||||
Das SSD Testing Module bietet umfassende Qualitätssicherung für USB-C SSDs mit 11 spezialisierten Tests, Performance-Messung und SMB-Bereitschaftsprüfung. Es gewährleistet die Zuverlässigkeit und Kompatibilität der Storage-Infrastruktur.
|
||||
|
||||
## Hauptkomponenten
|
||||
|
||||
### `ssd-test-suite.sh`
|
||||
**Zweck**: Umfassende Qualitätssicherung und Performance-Messung
|
||||
|
||||
**Test-Kategorien**:
|
||||
- **Hardware-Tests**: Connectivity, Power, Temperature
|
||||
- **Filesystem-Tests**: NTFS-Integrität, Permissions, Capacity
|
||||
- **Performance-Tests**: Read/Write Speed, IOPS, Latency
|
||||
- **Integration-Tests**: SMB-Bereitschaft, Mount-Stabilität
|
||||
- **Security-Tests**: Access-Control, Encryption-Support
|
||||
|
||||
## Test-Suite Übersicht
|
||||
|
||||
### Die 11 Kern-Tests
|
||||
|
||||
| Test-ID | Name | Zweck | Dauer |
|
||||
|---------|------|-------|-------|
|
||||
| `T01` | **Hardware Detection** | USB-C Connectivity und Device-Recognition | 5s |
|
||||
| `T02` | **NTFS Filesystem** | Dateisystem-Integrität und Kompatibilität | 10s |
|
||||
| `T03` | **Mount Stability** | Mount/Unmount Zyklen und Stabilität | 30s |
|
||||
| `T04` | **Read Performance** | Sequential und Random Read-Geschwindigkeit | 60s |
|
||||
| `T05` | **Write Performance** | Sequential und Random Write-Geschwindigkeit | 60s |
|
||||
| `T06` | **File Operations** | Create, Copy, Delete, Rename Operationen | 45s |
|
||||
| `T07` | **Permission System** | Linux-Permissions und NTFS-ACLs | 15s |
|
||||
| `T08` | **SMB Readiness** | SMB-Freigabe Kompatibilität und Performance | 30s |
|
||||
| `T09` | **Capacity Verification** | Verfügbarer Speicher und Fragmentierung | 20s |
|
||||
| `T10` | **Error Handling** | Fehlerbehandlung und Recovery-Mechanismen | 25s |
|
||||
| `T11` | **Security Scan** | Access-Control und Encryption-Support | 40s |
|
||||
|
||||
## Verwendung
|
||||
|
||||
### Grundlegende Test-Ausführung
|
||||
```bash
|
||||
# Alle Tests ausführen
|
||||
./ssd-test-suite.sh all
|
||||
|
||||
# Spezifischen Test ausführen
|
||||
./ssd-test-suite.sh T01
|
||||
|
||||
# Test-Kategorie ausführen
|
||||
./ssd-test-suite.sh --category hardware
|
||||
./ssd-test-suite.sh --category performance
|
||||
./ssd-test-suite.sh --category integration
|
||||
```
|
||||
|
||||
### Erweiterte Test-Optionen
|
||||
```bash
|
||||
# Schnelle Tests (nur kritische)
|
||||
./ssd-test-suite.sh --quick
|
||||
|
||||
# Umfassende Tests (alle mit erweiterten Parametern)
|
||||
./ssd-test-suite.sh --comprehensive
|
||||
|
||||
# Performance-Benchmark
|
||||
./ssd-test-suite.sh --benchmark
|
||||
|
||||
# Kontinuierliche Tests
|
||||
./ssd-test-suite.sh --continuous --interval 300
|
||||
```
|
||||
|
||||
### Output-Formate
|
||||
```bash
|
||||
# Standard-Output (Human-readable)
|
||||
./ssd-test-suite.sh all
|
||||
|
||||
# JSON-Output für Automation
|
||||
./ssd-test-suite.sh all --output json
|
||||
|
||||
# XML-Report für CI/CD
|
||||
./ssd-test-suite.sh all --output xml
|
||||
|
||||
# CSV für Datenanalyse
|
||||
./ssd-test-suite.sh all --output csv
|
||||
```
|
||||
|
||||
## Test-Konfiguration
|
||||
|
||||
### Environment Variables
|
||||
```bash
|
||||
# Test-Timeout (Sekunden)
|
||||
export SSD_TEST_TIMEOUT=300
|
||||
|
||||
# Performance-Test Größe (MB)
|
||||
export SSD_TEST_SIZE=100
|
||||
|
||||
# Test-Wiederholungen
|
||||
export SSD_TEST_ITERATIONS=3
|
||||
|
||||
# Benchmark-Modus
|
||||
export SSD_BENCHMARK_MODE=true
|
||||
```
|
||||
|
||||
### Konfigurationsdatei
|
||||
```bash
|
||||
# /etc/ssd-test/config.conf
|
||||
TEST_MOUNT_POINT="/mnt/ssd-storage"
|
||||
TEST_DATA_SIZE="100MB"
|
||||
PERFORMANCE_THRESHOLD_READ="50MB/s"
|
||||
PERFORMANCE_THRESHOLD_WRITE="30MB/s"
|
||||
SMB_TEST_ENABLED=true
|
||||
SECURITY_SCAN_ENABLED=true
|
||||
```
|
||||
|
||||
## Test-Details
|
||||
|
||||
### Hardware-Tests (T01-T03)
|
||||
|
||||
#### T01: Hardware Detection
|
||||
```bash
|
||||
# Prüft USB-C Connectivity
|
||||
- Device-Erkennung im System
|
||||
- USB-Version und Geschwindigkeit
|
||||
- Power-Management Status
|
||||
- Device-Descriptor Validierung
|
||||
```
|
||||
|
||||
#### T02: NTFS Filesystem
|
||||
```bash
|
||||
# Validiert NTFS-Kompatibilität
|
||||
- Dateisystem-Typ Verifikation
|
||||
- NTFS-Version Kompatibilität
|
||||
- Journal-Status Prüfung
|
||||
- Cluster-Size Optimierung
|
||||
```
|
||||
|
||||
#### T03: Mount Stability
|
||||
```bash
|
||||
# Testet Mount/Unmount Zyklen
|
||||
- 10x Mount/Unmount Zyklen
|
||||
- Concurrent-Access Tests
|
||||
- Mount-Option Validierung
|
||||
- Recovery nach Fehlern
|
||||
```
|
||||
|
||||
### Performance-Tests (T04-T06)
|
||||
|
||||
#### T04: Read Performance
|
||||
```bash
|
||||
# Sequential Read Test
|
||||
dd if=/mnt/ssd-storage/testfile of=/dev/null bs=1M count=100
|
||||
|
||||
# Random Read Test (4K Blocks)
|
||||
fio --name=random-read --ioengine=libaio --rw=randread --bs=4k --size=100M
|
||||
```
|
||||
|
||||
#### T05: Write Performance
|
||||
```bash
|
||||
# Sequential Write Test
|
||||
dd if=/dev/zero of=/mnt/ssd-storage/testfile bs=1M count=100
|
||||
|
||||
# Random Write Test (4K Blocks)
|
||||
fio --name=random-write --ioengine=libaio --rw=randwrite --bs=4k --size=100M
|
||||
```
|
||||
|
||||
#### T06: File Operations
|
||||
```bash
|
||||
# Standard File-Operations
|
||||
- 1000 kleine Dateien erstellen (1KB)
|
||||
- 100 mittlere Dateien erstellen (1MB)
|
||||
- 10 große Dateien erstellen (10MB)
|
||||
- Copy, Move, Delete Operationen
|
||||
- Symlink und Hardlink Tests
|
||||
```
|
||||
|
||||
### Integration-Tests (T07-T09)
|
||||
|
||||
#### T07: Permission System
|
||||
```bash
|
||||
# Linux-Permissions testen
|
||||
chmod 755 /mnt/ssd-storage/testdir
|
||||
chown user:group /mnt/ssd-storage/testfile
|
||||
|
||||
# NTFS-ACL Kompatibilität
|
||||
setfacl -m u:user:rwx /mnt/ssd-storage/testdir
|
||||
```
|
||||
|
||||
#### T08: SMB Readiness
|
||||
```bash
|
||||
# SMB-Kompatibilität prüfen
|
||||
- Windows-Filename Kompatibilität
|
||||
- Extended Attributes Support
|
||||
- Case-Sensitivity Tests
|
||||
- Unicode-Filename Support
|
||||
- SMB-Performance Simulation
|
||||
```
|
||||
|
||||
#### T09: Capacity Verification
|
||||
```bash
|
||||
# Speicher-Analyse
|
||||
df -h /mnt/ssd-storage
|
||||
du -sh /mnt/ssd-storage/*
|
||||
|
||||
# Fragmentierung prüfen
|
||||
fsck.ntfs -f /dev/sdb1
|
||||
```
|
||||
|
||||
### Security-Tests (T10-T11)
|
||||
|
||||
#### T10: Error Handling
|
||||
```bash
|
||||
# Fehlerbehandlung testen
|
||||
- Disk-Full Simulation
|
||||
- Permission-Denied Scenarios
|
||||
- Network-Interruption (bei SMB)
|
||||
- Hardware-Disconnect Simulation
|
||||
```
|
||||
|
||||
#### T11: Security Scan
|
||||
```bash
|
||||
# Security-Features prüfen
|
||||
- Access-Control Lists (ACLs)
|
||||
- Encryption-Support Detection
|
||||
- Secure-Delete Capabilities
|
||||
- Audit-Trail Funktionalität
|
||||
```
|
||||
|
||||
## Benchmark-Modus
|
||||
|
||||
### Performance-Metriken
|
||||
```bash
|
||||
# Detaillierte Performance-Analyse
|
||||
./ssd-test-suite.sh --benchmark --detailed
|
||||
|
||||
# Vergleich mit Referenz-Werten
|
||||
./ssd-test-suite.sh --benchmark --compare baseline.json
|
||||
|
||||
# Performance-Trend Analyse
|
||||
./ssd-test-suite.sh --benchmark --trend --days 30
|
||||
```
|
||||
|
||||
### Benchmark-Output
|
||||
```json
|
||||
{
|
||||
"device": "/dev/sdb1",
|
||||
"timestamp": "2025-08-07T19:10:00Z",
|
||||
"performance": {
|
||||
"sequential_read": "120 MB/s",
|
||||
"sequential_write": "85 MB/s",
|
||||
"random_read_4k": "15000 IOPS",
|
||||
"random_write_4k": "8000 IOPS",
|
||||
"latency_avg": "2.5ms"
|
||||
},
|
||||
"health": {
|
||||
"temperature": "45°C",
|
||||
"wear_level": "2%",
|
||||
"error_count": 0
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## CI/CD Integration
|
||||
|
||||
### Jenkins Pipeline
|
||||
```groovy
|
||||
pipeline {
|
||||
agent any
|
||||
stages {
|
||||
stage('SSD Tests') {
|
||||
steps {
|
||||
sh './ssd-test-suite.sh all --output xml'
|
||||
publishTestResults testResultsPattern: 'ssd-test-results.xml'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### GitHub Actions
|
||||
```yaml
|
||||
name: SSD Tests
|
||||
on: [push, pull_request]
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Run SSD Tests
|
||||
run: ./ssd-test-suite.sh all --output json
|
||||
```
|
||||
|
||||
## Monitoring Integration
|
||||
|
||||
### Prometheus-Metriken
|
||||
```bash
|
||||
# Metriken exportieren
|
||||
./ssd-test-suite.sh --prometheus-metrics
|
||||
|
||||
# Grafana-Dashboard
|
||||
# Siehe examples/monitoring/grafana-dashboard.json
|
||||
```
|
||||
|
||||
### Alerting
|
||||
```bash
|
||||
# Performance-Alerts
|
||||
if [ $READ_SPEED -lt 50 ]; then
|
||||
alert "SSD Read Performance below threshold"
|
||||
fi
|
||||
|
||||
# Health-Alerts
|
||||
if [ $ERROR_COUNT -gt 0 ]; then
|
||||
alert "SSD Errors detected"
|
||||
fi
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Häufige Test-Fehler
|
||||
1. **T01 Failed**: USB-Verbindung prüfen, Treiber aktualisieren
|
||||
2. **T04/T05 Slow**: SSD-Health prüfen, USB-Port wechseln
|
||||
3. **T08 Failed**: SMB-Packages installieren, Firewall prüfen
|
||||
|
||||
### Debug-Modus
|
||||
```bash
|
||||
# Erweiterte Diagnose
|
||||
./ssd-test-suite.sh all --debug --verbose
|
||||
|
||||
# Test-Logs analysieren
|
||||
tail -f /var/log/ssd-test.log
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
### Produktionsumgebung
|
||||
1. **Regelmäßige Tests** (täglich/wöchentlich) einrichten
|
||||
2. **Performance-Baselines** etablieren und überwachen
|
||||
3. **Test-Ergebnisse archivieren** für Trend-Analyse
|
||||
4. **Automatische Alerts** bei Test-Fehlern konfigurieren
|
||||
|
||||
### Entwicklungsumgebung
|
||||
1. **Quick-Tests** vor Code-Changes ausführen
|
||||
2. **Comprehensive-Tests** vor Releases durchführen
|
||||
3. **Benchmark-Vergleiche** für Performance-Regression
|
||||
4. **Test-Coverage** für alle SSD-Typen sicherstellen
|
||||
|
||||
## Changelog
|
||||
|
||||
### Version 0.1.0
|
||||
- 11 umfassende Test-Kategorien
|
||||
- Performance-Benchmark Integration
|
||||
- SMB-Bereitschaftsprüfung
|
||||
- CI/CD Pipeline Support
|
||||
- Prometheus-Metriken Export
|
||||
419
scripts/ssd-testing/ssd-test-suite.sh
Normal file
419
scripts/ssd-testing/ssd-test-suite.sh
Normal file
@@ -0,0 +1,419 @@
|
||||
#!/bin/bash
|
||||
# ssd-test-suite.sh - USB-C SSD Test Suite
|
||||
# Zweck: Umfassende Tests für gemountete SSDs
|
||||
|
||||
set -e
|
||||
|
||||
# Konfiguration
|
||||
MOUNT_POINT="/mnt/ssd-storage"
|
||||
TEST_DIR="$MOUNT_POINT/.ssd-tests"
|
||||
LOG_FILE="/var/log/ssd-tests.log"
|
||||
|
||||
# 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 und Ausgabe
|
||||
log_test() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - TEST: $1" >> "$LOG_FILE"
|
||||
echo -e "${BLUE}[TEST]${NC} $1"
|
||||
}
|
||||
|
||||
log_success() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" >> "$LOG_FILE"
|
||||
echo -e "${GREEN}[✓]${NC} $1"
|
||||
}
|
||||
|
||||
log_warning() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" >> "$LOG_FILE"
|
||||
echo -e "${YELLOW}[!]${NC} $1"
|
||||
}
|
||||
|
||||
log_error() {
|
||||
echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" >> "$LOG_FILE"
|
||||
echo -e "${RED}[✗]${NC} $1"
|
||||
}
|
||||
|
||||
# Test 1: Mount-Status prüfen
|
||||
test_mount_status() {
|
||||
log_test "Prüfe Mount-Status..."
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
log_success "SSD ist gemountet: $mounted_device auf $MOUNT_POINT"
|
||||
return 0
|
||||
else
|
||||
log_error "Keine SSD auf $MOUNT_POINT gemountet"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 2: Dateisystem-Typ prüfen
|
||||
test_filesystem_type() {
|
||||
log_test "Prüfe Dateisystem-Typ..."
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
fs_type=$(lsblk -o FSTYPE "$mounted_device" | tail -1 | xargs)
|
||||
|
||||
if [ "$fs_type" = "ntfs" ]; then
|
||||
log_success "Dateisystem: NTFS ✓"
|
||||
return 0
|
||||
else
|
||||
log_warning "Dateisystem: $fs_type (erwartet: NTFS)"
|
||||
return 1
|
||||
fi
|
||||
else
|
||||
log_error "Kein gemountetes Device für Filesystem-Test"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 3: Lesezugriff prüfen
|
||||
test_read_access() {
|
||||
log_test "Prüfe Lesezugriff..."
|
||||
|
||||
if [ -r "$MOUNT_POINT" ]; then
|
||||
# Versuche Verzeichnis-Listing
|
||||
file_count=$(ls -1 "$MOUNT_POINT" 2>/dev/null | wc -l)
|
||||
log_success "Lesezugriff OK - $file_count Objekte gefunden"
|
||||
return 0
|
||||
else
|
||||
log_error "Kein Lesezugriff auf $MOUNT_POINT"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 4: Schreibzugriff prüfen
|
||||
test_write_access() {
|
||||
log_test "Prüfe Schreibzugriff..."
|
||||
|
||||
test_file="$MOUNT_POINT/.write_test_$(date +%s).tmp"
|
||||
|
||||
if echo "Write test - $(date)" > "$test_file" 2>/dev/null; then
|
||||
if [ -f "$test_file" ]; then
|
||||
content=$(cat "$test_file")
|
||||
rm -f "$test_file"
|
||||
log_success "Schreibzugriff OK"
|
||||
return 0
|
||||
else
|
||||
log_error "Datei konnte nicht erstellt werden"
|
||||
return 1
|
||||
fi
|
||||
else
|
||||
log_error "Kein Schreibzugriff auf $MOUNT_POINT"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 5: Verzeichnis-Operationen
|
||||
test_directory_operations() {
|
||||
log_test "Prüfe Verzeichnis-Operationen..."
|
||||
|
||||
# Test-Verzeichnis erstellen
|
||||
if mkdir -p "$TEST_DIR" 2>/dev/null; then
|
||||
log_success "Verzeichnis erstellen: OK"
|
||||
|
||||
# Test-Unterverzeichnis
|
||||
sub_dir="$TEST_DIR/subdir_$(date +%s)"
|
||||
if mkdir "$sub_dir" 2>/dev/null; then
|
||||
log_success "Unterverzeichnis erstellen: OK"
|
||||
|
||||
# Verzeichnis löschen
|
||||
if rmdir "$sub_dir" 2>/dev/null; then
|
||||
log_success "Verzeichnis löschen: OK"
|
||||
else
|
||||
log_warning "Verzeichnis löschen: Fehler"
|
||||
fi
|
||||
else
|
||||
log_warning "Unterverzeichnis erstellen: Fehler"
|
||||
fi
|
||||
|
||||
# Test-Verzeichnis aufräumen
|
||||
rmdir "$TEST_DIR" 2>/dev/null || log_warning "Test-Verzeichnis Cleanup: Fehler"
|
||||
return 0
|
||||
else
|
||||
log_error "Verzeichnis-Operationen: Fehler"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 6: Performance-Test (Schreibgeschwindigkeit)
|
||||
test_write_performance() {
|
||||
log_test "Prüfe Schreibperformance..."
|
||||
|
||||
test_file="$MOUNT_POINT/.performance_test_$(date +%s).tmp"
|
||||
|
||||
# 100MB Test-Datei schreiben
|
||||
start_time=$(date +%s.%N)
|
||||
|
||||
if dd if=/dev/zero of="$test_file" bs=1M count=100 2>/dev/null; then
|
||||
end_time=$(date +%s.%N)
|
||||
duration=$(echo "$end_time - $start_time" | bc -l 2>/dev/null || echo "0")
|
||||
|
||||
if [ -f "$test_file" ]; then
|
||||
file_size=$(stat -c%s "$test_file" 2>/dev/null || echo "0")
|
||||
rm -f "$test_file"
|
||||
|
||||
if command -v bc >/dev/null && [ "$duration" != "0" ]; then
|
||||
speed=$(echo "scale=2; ($file_size / 1024 / 1024) / $duration" | bc -l)
|
||||
log_success "Schreibgeschwindigkeit: ${speed} MB/s"
|
||||
else
|
||||
log_success "Performance-Test abgeschlossen (Zeit: ${duration}s)"
|
||||
fi
|
||||
else
|
||||
log_warning "Performance-Test: Datei nicht erstellt"
|
||||
fi
|
||||
return 0
|
||||
else
|
||||
log_error "Performance-Test: Schreibfehler"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 7: Speicherplatz prüfen
|
||||
test_disk_space() {
|
||||
log_test "Prüfe Speicherplatz..."
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
space_info=$(df -h "$MOUNT_POINT" | tail -1)
|
||||
total=$(echo "$space_info" | awk '{print $2}')
|
||||
used=$(echo "$space_info" | awk '{print $3}')
|
||||
available=$(echo "$space_info" | awk '{print $4}')
|
||||
usage=$(echo "$space_info" | awk '{print $5}')
|
||||
|
||||
log_success "Speicherplatz - Total: $total, Belegt: $used, Verfügbar: $available, Auslastung: $usage"
|
||||
|
||||
# Warnung bei hoher Auslastung
|
||||
usage_percent=$(echo "$usage" | sed 's/%//')
|
||||
if [ "$usage_percent" -gt 90 ]; then
|
||||
log_warning "Hohe Speicherauslastung: $usage"
|
||||
fi
|
||||
|
||||
return 0
|
||||
else
|
||||
log_error "Speicherplatz-Check: Kein gemountetes Device"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 8: NTFS-spezifische Eigenschaften
|
||||
test_ntfs_features() {
|
||||
log_test "Prüfe NTFS-Features..."
|
||||
|
||||
if mountpoint -q "$MOUNT_POINT"; then
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
|
||||
# UUID prüfen
|
||||
uuid=$(sudo blkid -s UUID -o value "$mounted_device" 2>/dev/null)
|
||||
if [ -n "$uuid" ]; then
|
||||
log_success "NTFS UUID: $uuid"
|
||||
else
|
||||
log_warning "NTFS UUID nicht ermittelbar"
|
||||
fi
|
||||
|
||||
# Label prüfen
|
||||
label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null)
|
||||
if [ -n "$label" ]; then
|
||||
log_success "NTFS Label: $label"
|
||||
else
|
||||
log_success "NTFS Label: (kein Label gesetzt)"
|
||||
fi
|
||||
|
||||
# NTFS-spezifische Mount-Optionen prüfen
|
||||
mount_options=$(mount | grep "$MOUNT_POINT" | sed 's/.*(\(.*\)).*/\1/')
|
||||
log_success "Mount-Optionen: $mount_options"
|
||||
|
||||
return 0
|
||||
else
|
||||
log_error "NTFS-Features: Kein gemountetes Device"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 9: SMB-Bereitschaft prüfen
|
||||
test_smb_readiness() {
|
||||
log_test "Prüfe SMB-Bereitschaft..."
|
||||
|
||||
# Benutzer-/Gruppen-Zugriff prüfen
|
||||
user_id=$(id -u)
|
||||
group_id=$(id -g)
|
||||
|
||||
if [ -r "$MOUNT_POINT" ] && [ -w "$MOUNT_POINT" ]; then
|
||||
log_success "Benutzer-Zugriff (UID: $user_id, GID: $group_id): OK"
|
||||
|
||||
# Test-Datei für SMB-Zugriff erstellen
|
||||
smb_test_file="$MOUNT_POINT/.smb_test_$(date +%s).txt"
|
||||
if echo "SMB Test - $(date)" > "$smb_test_file" 2>/dev/null; then
|
||||
if [ -f "$smb_test_file" ]; then
|
||||
rm -f "$smb_test_file"
|
||||
log_success "SMB-Test-Datei: OK"
|
||||
fi
|
||||
fi
|
||||
|
||||
return 0
|
||||
else
|
||||
log_error "SMB-Bereitschaft: Unzureichende Zugriffsrechte"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 10: Safe-Eject Bereitschaft prüfen
|
||||
test_safe_eject_readiness() {
|
||||
log_test "Prüfe Safe-Eject Bereitschaft..."
|
||||
|
||||
if ! mountpoint -q "$MOUNT_POINT"; then
|
||||
log_warning "Safe-Eject: Kein Device gemountet"
|
||||
return 1
|
||||
fi
|
||||
|
||||
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
|
||||
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
|
||||
|
||||
# USB-Device prüfen
|
||||
if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
|
||||
log_success "USB-Device erkannt: Safe-Eject verfügbar"
|
||||
|
||||
# eject Befehl prüfen
|
||||
if command -v eject >/dev/null; then
|
||||
log_success "eject Befehl: Verfügbar"
|
||||
else
|
||||
log_warning "eject Befehl: Nicht installiert (installierbar mit: sudo apt install eject)"
|
||||
fi
|
||||
|
||||
# Aktive Prozesse prüfen
|
||||
active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
|
||||
if [ "$active_count" -eq 0 ]; then
|
||||
log_success "Aktive Prozesse: Keine (Safe-Eject bereit)"
|
||||
else
|
||||
log_warning "Aktive Prozesse: $active_count (Safe-Eject mit Vorsicht)"
|
||||
fi
|
||||
|
||||
# Buffer-Status prüfen
|
||||
dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
|
||||
if [ "$dirty_pages" -le 100 ]; then
|
||||
log_success "System Buffer: Sauber (${dirty_pages}kB)"
|
||||
else
|
||||
log_warning "System Buffer: Dirty Pages vorhanden (${dirty_pages}kB)"
|
||||
fi
|
||||
|
||||
return 0
|
||||
else
|
||||
log_warning "Kein USB-Device - Safe-Eject nicht erforderlich"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 11: Gesamtsystem-Status
|
||||
test_system_status() {
|
||||
log_test "Prüfe Gesamtsystem-Status..."
|
||||
|
||||
# NTFS-3G prüfen
|
||||
if command -v mount.ntfs-3g >/dev/null; then
|
||||
log_success "NTFS-3G: Installiert"
|
||||
else
|
||||
log_error "NTFS-3G: Nicht installiert"
|
||||
fi
|
||||
|
||||
# Kernel-Module prüfen
|
||||
if lsmod | grep -q ntfs; then
|
||||
log_success "NTFS Kernel-Modul: Geladen"
|
||||
else
|
||||
log_warning "NTFS Kernel-Modul: Nicht erkannt"
|
||||
fi
|
||||
|
||||
# System-Load prüfen
|
||||
load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
|
||||
log_success "System Load: $load_avg"
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Alle Tests ausführen
|
||||
run_all_tests() {
|
||||
echo "=== USB-C SSD Test Suite ==="
|
||||
echo "Version: 1.0"
|
||||
echo "Zeitstempel: $(date)"
|
||||
echo "Mount-Point: $MOUNT_POINT"
|
||||
echo ""
|
||||
|
||||
total_tests=11
|
||||
passed_tests=0
|
||||
|
||||
# Test-Log initialisieren
|
||||
echo "=== Test-Session gestartet: $(date) ===" >> "$LOG_FILE"
|
||||
|
||||
# Tests ausführen
|
||||
test_mount_status && ((passed_tests++))
|
||||
test_filesystem_type && ((passed_tests++))
|
||||
test_read_access && ((passed_tests++))
|
||||
test_write_access && ((passed_tests++))
|
||||
test_directory_operations && ((passed_tests++))
|
||||
test_write_performance && ((passed_tests++))
|
||||
test_disk_space && ((passed_tests++))
|
||||
test_ntfs_features && ((passed_tests++))
|
||||
test_smb_readiness && ((passed_tests++))
|
||||
test_safe_eject_readiness && ((passed_tests++))
|
||||
test_system_status && ((passed_tests++))
|
||||
|
||||
echo ""
|
||||
echo "=== Test-Zusammenfassung ==="
|
||||
echo "Tests bestanden: $passed_tests/$total_tests"
|
||||
|
||||
if [ $passed_tests -eq $total_tests ]; then
|
||||
log_success "Alle Tests bestanden - SSD ist bereit für SMB-Freigabe!"
|
||||
echo "=== ALLE TESTS BESTANDEN ===" >> "$LOG_FILE"
|
||||
return 0
|
||||
else
|
||||
failed_tests=$((total_tests - passed_tests))
|
||||
log_warning "$failed_tests Tests fehlgeschlagen - Überprüfung erforderlich"
|
||||
echo "=== $failed_tests TESTS FEHLGESCHLAGEN ===" >> "$LOG_FILE"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Hauptfunktion
|
||||
main() {
|
||||
case "${1:-all}" in
|
||||
"all")
|
||||
run_all_tests
|
||||
;;
|
||||
"quick")
|
||||
echo "=== Quick Test ==="
|
||||
test_mount_status && test_read_access && test_write_access
|
||||
;;
|
||||
"mount")
|
||||
test_mount_status
|
||||
;;
|
||||
"access")
|
||||
test_read_access && test_write_access
|
||||
;;
|
||||
"performance")
|
||||
test_write_performance
|
||||
;;
|
||||
"smb")
|
||||
test_smb_readiness
|
||||
;;
|
||||
"safe-eject"|"eject")
|
||||
test_safe_eject_readiness
|
||||
;;
|
||||
*)
|
||||
echo "Verwendung: $0 {all|quick|mount|access|performance|smb|safe-eject}"
|
||||
echo ""
|
||||
echo "Tests:"
|
||||
echo " all - Alle Tests ausführen (empfohlen)"
|
||||
echo " quick - Schnelle Basis-Tests"
|
||||
echo " mount - Nur Mount-Status prüfen"
|
||||
echo " access - Nur Zugriff prüfen"
|
||||
echo " performance - Nur Performance-Test"
|
||||
echo " smb - Nur SMB-Bereitschaft prüfen"
|
||||
echo " safe-eject - Nur Safe-Eject Bereitschaft prüfen"
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
# Script ausführen
|
||||
main "$@"
|
||||
Reference in New Issue
Block a user