diff --git a/docs/api-reference.md b/docs/api-reference.md new file mode 100644 index 0000000..805374f --- /dev/null +++ b/docs/api-reference.md @@ -0,0 +1,479 @@ +# USB-SSD Management System - API Reference + +## Übersicht + +Diese Referenz dokumentiert alle verfügbaren Scripts, Parameter und Optionen des USB-SSD Management Systems. Alle Scripts unterstützen die `--help` Option für detaillierte Informationen. + +## Script-Übersicht + +| Script | Zweck | Hauptfunktionen | +|--------|-------|-----------------| +| `ssd-detect.sh` | Hardware-Erkennung | USB-C SSD Identifikation, NTFS-Erkennung | +| `ssd-mount-manager.sh` | Mount-Management | Mounting, Unmounting, Status-Überwachung | +| `ssd-test-suite.sh` | Qualitätssicherung | 11 Test-Kategorien, Performance-Benchmarks | +| `ssd-safe-eject.sh` | Sichere Entfernung | Buffer-Flush, Prozess-Detection, Hardware-Eject | + +## ssd-detect.sh + +### Syntax +```bash +ssd-detect.sh [OPTIONS] [COMMAND] +``` + +### Befehle +| Befehl | Beschreibung | +|--------|--------------| +| `detect` | Standard-Erkennung (Default) | +| `list` | Alle erkannten SSDs auflisten | +| `monitor` | Kontinuierliche Überwachung | +| `info` | Detaillierte Device-Informationen | + +### Optionen +| Option | Kurz | Typ | Beschreibung | Default | +|--------|------|-----|--------------|---------| +| `--device` | `-d` | String | Spezifisches Device prüfen | Auto-detect | +| `--ntfs-only` | `-n` | Flag | Nur NTFS-Partitionen anzeigen | false | +| `--output` | `-o` | String | Output-Format (text/json/xml) | text | +| `--verbose` | `-v` | Flag | Detaillierte Ausgabe | false | +| `--debug` | | Flag | Debug-Modus aktivieren | false | +| `--monitor` | `-m` | Flag | Kontinuierliche Überwachung | false | +| `--interval` | `-i` | Integer | Monitor-Intervall (Sekunden) | 5 | +| `--timeout` | `-t` | Integer | Detection-Timeout (Sekunden) | 30 | +| `--hardware-info` | | Flag | Hardware-Details anzeigen | false | +| `--performance-info` | | Flag | Performance-Informationen | false | + +### Beispiele +```bash +# Standard-Erkennung +ssd-detect.sh + +# 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 --interval 10 + +# Debug-Modus +ssd-detect.sh --debug --verbose +``` + +### Exit-Codes +| Code | Bedeutung | +|------|-----------| +| 0 | Erfolg - SSD erkannt | +| 1 | Allgemeiner Fehler | +| 2 | Keine SSD gefunden | +| 3 | NTFS nicht unterstützt | +| 4 | Timeout erreicht | +| 5 | Permission denied | + +### Environment Variables +```bash +export SSD_DETECT_TIMEOUT=30 # Detection-Timeout +export SSD_LOG_LEVEL=INFO # Log-Level +export SSD_SUPPORTED_FS="ntfs,exfat" # Unterstützte Dateisysteme +export SSD_DEBUG=false # Debug-Modus +``` + +## ssd-mount-manager.sh + +### Syntax +```bash +ssd-mount-manager.sh [OPTIONS] COMMAND +``` + +### Befehle +| Befehl | Beschreibung | +|--------|--------------| +| `mount` | SSD mounten | +| `unmount` | SSD unmounten | +| `remount` | SSD neu mounten | +| `status` | Mount-Status anzeigen | +| `diagnose` | Mount-Probleme diagnostizieren | +| `cleanup` | Mount-Point bereinigen | +| `recover` | Recovery-Modus | +| `metrics` | Performance-Metriken | + +### Optionen +| Option | Kurz | Typ | Beschreibung | Default | +|--------|------|-----|--------------|---------| +| `--device` | `-d` | String | Spezifisches Device | Auto-detect | +| `--mountpoint` | `-m` | String | Mount-Point Pfad | /mnt/ssd-storage | +| `--options` | `-o` | String | Mount-Optionen | uid=1000,gid=1000 | +| `--readonly` | `-r` | Flag | Read-Only Mount | false | +| `--readwrite` | `-w` | Flag | Read-Write Mount | true | +| `--smb-ready` | | Flag | SMB-optimierte Optionen | false | +| `--fsck` | | Flag | Filesystem-Check vor Mount | false | +| `--timeout` | `-t` | Integer | Mount-Timeout (Sekunden) | 30 | +| `--force` | `-f` | Flag | Force-Mount | false | +| `--verbose` | `-v` | Flag | Detaillierte Ausgabe | false | +| `--json` | | Flag | JSON-Output | false | + +### Beispiele +```bash +# Standard-Mount +ssd-mount-manager.sh mount + +# Custom Mount-Point +ssd-mount-manager.sh mount --mountpoint /custom/path + +# Read-Only Mount +ssd-mount-manager.sh mount --readonly + +# SMB-optimiertes Mounting +ssd-mount-manager.sh mount --smb-ready + +# Status prüfen +ssd-mount-manager.sh status --json + +# Diagnose +ssd-mount-manager.sh diagnose +``` + +### Exit-Codes +| Code | Bedeutung | +|------|-----------| +| 0 | Erfolg | +| 1 | Allgemeiner Fehler | +| 2 | Device nicht gefunden | +| 3 | Mount fehlgeschlagen | +| 4 | Unmount fehlgeschlagen | +| 5 | Permission denied | +| 6 | Timeout erreicht | + +### Environment Variables +```bash +export SSD_MOUNT_POINT="/mnt/ssd-storage" # Standard Mount-Point +export SSD_MOUNT_OPTIONS="uid=1000,gid=1000" # Standard Mount-Optionen +export SSD_MOUNT_TIMEOUT=30 # Mount-Timeout +export SSD_AUTO_MOUNT=true # Auto-Mount aktivieren +export SSD_SMB_READY=false # SMB-Optimierungen +``` + +## ssd-test-suite.sh + +### Syntax +```bash +ssd-test-suite.sh [OPTIONS] [TESTS] +``` + +### Test-IDs +| Test-ID | Name | Kategorie | Dauer | +|---------|------|-----------|-------| +| `T01` | Hardware Detection | Hardware | 5s | +| `T02` | NTFS Filesystem | Hardware | 10s | +| `T03` | Mount Stability | Hardware | 30s | +| `T04` | Read Performance | Performance | 60s | +| `T05` | Write Performance | Performance | 60s | +| `T06` | File Operations | Performance | 45s | +| `T07` | Permission System | Integration | 15s | +| `T08` | SMB Readiness | Integration | 30s | +| `T09` | Capacity Verification | Integration | 20s | +| `T10` | Error Handling | Security | 25s | +| `T11` | Security Scan | Security | 40s | + +### Befehle +| Befehl | Beschreibung | +|--------|--------------| +| `all` | Alle Tests ausführen | +| `quick` | Nur kritische Tests (T01,T02,T03,T08) | +| `T01-T11` | Spezifische Tests | +| `hardware` | Hardware-Tests (T01-T03) | +| `performance` | Performance-Tests (T04-T06) | +| `integration` | Integration-Tests (T07-T09) | +| `security` | Security-Tests (T10-T11) | + +### Optionen +| Option | Kurz | Typ | Beschreibung | Default | +|--------|------|-----|--------------|---------| +| `--category` | `-c` | String | Test-Kategorie | all | +| `--output` | `-o` | String | Output-Format (text/json/xml/csv) | text | +| `--benchmark` | `-b` | Flag | Benchmark-Modus | false | +| `--detailed` | | Flag | Detaillierte Ergebnisse | false | +| `--continuous` | | Flag | Kontinuierliche Tests | false | +| `--interval` | `-i` | Integer | Test-Intervall (Sekunden) | 3600 | +| `--timeout` | `-t` | Integer | Test-Timeout (Sekunden) | 300 | +| `--size` | `-s` | String | Test-Daten Größe | 100MB | +| `--iterations` | | Integer | Test-Wiederholungen | 3 | +| `--compare` | | String | Baseline-Datei für Vergleich | - | +| `--trend` | | Flag | Trend-Analyse | false | +| `--prometheus-metrics` | | Flag | Prometheus-Metriken | false | + +### Beispiele +```bash +# Alle Tests +ssd-test-suite.sh all + +# Schnelle Tests +ssd-test-suite.sh --quick + +# Performance-Tests mit Benchmark +ssd-test-suite.sh performance --benchmark + +# Kontinuierliche Tests +ssd-test-suite.sh --continuous --interval 1800 + +# JSON-Output +ssd-test-suite.sh all --output json + +# Spezifische Tests +ssd-test-suite.sh T01 T04 T08 +``` + +### Exit-Codes +| Code | Bedeutung | +|------|-----------| +| 0 | Alle Tests erfolgreich | +| 1 | Ein oder mehrere Tests fehlgeschlagen | +| 2 | Kritischer Test fehlgeschlagen | +| 3 | Performance unter Threshold | +| 4 | Timeout erreicht | +| 5 | Permission denied | + +### Environment Variables +```bash +export SSD_TEST_TIMEOUT=300 # Test-Timeout +export SSD_TEST_SIZE=100 # Test-Daten Größe (MB) +export SSD_TEST_ITERATIONS=3 # Test-Wiederholungen +export SSD_BENCHMARK_MODE=false # Benchmark-Modus +export SSD_PERFORMANCE_THRESHOLD_READ="50MB/s" # Read-Performance Threshold +export SSD_PERFORMANCE_THRESHOLD_WRITE="30MB/s" # Write-Performance Threshold +``` + +## ssd-safe-eject.sh + +### Syntax +```bash +ssd-safe-eject.sh [OPTIONS] +``` + +### Optionen +| Option | Kurz | Typ | Beschreibung | Default | +|--------|------|-----|--------------|---------| +| `--device` | `-d` | String | Spezifisches Device | Auto-detect | +| `--force` | `-f` | Flag | Force-Eject | false | +| `--show-processes` | | Flag | Blockierende Prozesse anzeigen | false | +| `--kill-processes` | | Flag | Prozesse automatisch beenden | false | +| `--unmount-only` | | Flag | Nur Unmount (kein Hardware-Eject) | false | +| `--timeout` | `-t` | Integer | Buffer-Flush Timeout (Sekunden) | 60 | +| `--process-timeout` | | Integer | Prozess-Kill Timeout (Sekunden) | 10 | +| `--verbose` | `-v` | Flag | Detaillierte Ausgabe | false | +| `--dry-run` | | Flag | Simulation (keine Änderungen) | false | +| `--monitor-buffers` | | Flag | Buffer-Status überwachen | false | +| `--hardware-reset` | | Flag | Hardware-Reset nach Eject | false | + +### Beispiele +```bash +# Standard Safe-Eject +ssd-safe-eject.sh + +# Mit Prozess-Übersicht +ssd-safe-eject.sh --show-processes + +# Force-Eject +ssd-safe-eject.sh --force --kill-processes + +# Nur Unmount +ssd-safe-eject.sh --unmount-only + +# Dry-Run +ssd-safe-eject.sh --dry-run --verbose +``` + +### Exit-Codes +| Code | Bedeutung | +|------|-----------| +| 0 | Erfolgreicher Eject | +| 1 | Allgemeiner Fehler | +| 2 | Device nicht gefunden | +| 3 | Unmount fehlgeschlagen | +| 4 | Prozesse blockieren | +| 5 | Hardware-Eject fehlgeschlagen | +| 6 | Timeout erreicht | + +### Environment Variables +```bash +export SSD_EJECT_TIMEOUT=60 # Buffer-Flush Timeout +export SSD_PROCESS_TIMEOUT=10 # Prozess-Kill Timeout +export SSD_HARDWARE_EJECT=true # Hardware-Eject aktivieren +export SSD_KILL_PROCESSES=false # Automatisches Prozess-Killing +export SSD_MONITOR_BUFFERS=true # Buffer-Monitoring +``` + +## Globale Environment Variables + +### Logging-Konfiguration +```bash +export SSD_LOG_LEVEL=INFO # Log-Level (DEBUG,INFO,WARN,ERROR) +export SSD_LOG_FILE="/var/log/ssd-management.log" # Log-Datei +export SSD_USE_SYSLOG=true # Syslog-Integration +export SSD_DEBUG=false # Debug-Modus +export SSD_VERBOSE=false # Verbose-Output +``` + +### System-Konfiguration +```bash +export SSD_CONFIG_DIR="/etc/ssd-management" # Konfigurationsverzeichnis +export SSD_CACHE_DIR="/var/cache/ssd-management" # Cache-Verzeichnis +export SSD_LOCK_DIR="/var/lock/ssd-management" # Lock-Verzeichnis +export SSD_PID_FILE="/var/run/ssd-management.pid" # PID-Datei +``` + +### Performance-Konfiguration +```bash +export SSD_MAX_PARALLEL_OPS=1 # Maximale parallele Operationen +export SSD_IO_SCHEDULER="mq-deadline" # I/O-Scheduler +export SSD_READ_AHEAD_KB=1024 # Read-Ahead Buffer +export SSD_CACHE_MODE="strict" # Cache-Modus +``` + +## Konfigurationsdateien + +### Haupt-Konfiguration +```ini +# /etc/ssd-management/config.conf +[global] +debug = false +verbose = false +log_level = INFO + +[mount] +default_mount_point = /mnt/ssd-storage +ntfs_options = uid=1000,gid=1000,umask=022,windows_names +auto_mount = true +smb_ready = false + +[testing] +quick_tests = T01,T02,T03,T08 +performance_threshold_read = 50MB/s +performance_threshold_write = 30MB/s +benchmark_enabled = false + +[security] +require_sudo = true +audit_logging = true +process_detection = true +buffer_monitoring = true +``` + +### Logging-Konfiguration +```ini +# /etc/ssd-management/logging.conf +[loggers] +keys = root,ssd + +[handlers] +keys = fileHandler,syslogHandler + +[formatters] +keys = detailedFormatter + +[logger_root] +level = INFO +handlers = fileHandler + +[logger_ssd] +level = DEBUG +handlers = fileHandler,syslogHandler +qualname = ssd +propagate = 0 + +[handler_fileHandler] +class = FileHandler +level = DEBUG +formatter = detailedFormatter +args = ('/var/log/ssd-management.log',) + +[handler_syslogHandler] +class = handlers.SysLogHandler +level = INFO +formatter = detailedFormatter +args = (('localhost', handlers.SYSLOG_UDP_PORT), handlers.SysLogHandler.LOG_USER) + +[formatter_detailedFormatter] +format = %(asctime)s - %(name)s - %(levelname)s - %(message)s +``` + +## Return-Codes Übersicht + +### Allgemeine Codes (0-9) +| Code | Bedeutung | +|------|-----------| +| 0 | Erfolg | +| 1 | Allgemeiner Fehler | +| 2 | Ungültige Parameter | +| 3 | Permission denied | +| 4 | Timeout erreicht | +| 5 | Resource nicht verfügbar | + +### Hardware-Codes (10-19) +| Code | Bedeutung | +|------|-----------| +| 10 | Device nicht gefunden | +| 11 | USB-Fehler | +| 12 | Hardware-Fehler | +| 13 | Filesystem nicht unterstützt | +| 14 | Partition-Fehler | + +### Mount-Codes (20-29) +| Code | Bedeutung | +|------|-----------| +| 20 | Mount fehlgeschlagen | +| 21 | Unmount fehlgeschlagen | +| 22 | Mount-Point nicht verfügbar | +| 23 | Filesystem-Fehler | +| 24 | Permission-Fehler | + +### Test-Codes (30-39) +| Code | Bedeutung | +|------|-----------| +| 30 | Test fehlgeschlagen | +| 31 | Performance unter Threshold | +| 32 | Kritischer Test fehlgeschlagen | +| 33 | Test-Timeout | +| 34 | Test-Daten korrupt | + +## JSON-Output Format + +### Standard-Response +```json +{ + "timestamp": "2025-08-07T19:10:00Z", + "script": "ssd-detect.sh", + "version": "0.1.0", + "status": "success", + "exit_code": 0, + "data": { + // Script-spezifische Daten + }, + "errors": [], + "warnings": [] +} +``` + +### Error-Response +```json +{ + "timestamp": "2025-08-07T19:10:00Z", + "script": "ssd-mount-manager.sh", + "version": "0.1.0", + "status": "error", + "exit_code": 20, + "data": null, + "errors": [ + { + "code": "MOUNT_FAILED", + "message": "Failed to mount /dev/sdb1", + "details": "Permission denied" + } + ], + "warnings": [] +} +``` + +--- + +**💡 Tipp**: Verwenden Sie `script-name.sh --help` für die aktuellste Dokumentation und alle verfügbaren Optionen. diff --git a/docs/installation-guide.md b/docs/installation-guide.md new file mode 100644 index 0000000..abe9a57 --- /dev/null +++ b/docs/installation-guide.md @@ -0,0 +1,439 @@ +# USB-SSD Management System - Detaillierte Installation + +## Übersicht + +Diese Anleitung führt Sie Schritt-für-Schritt durch die Installation des USB-SSD Management Systems auf Ubuntu/Linux-Servern. Das System ist speziell für KMU-Infrastrukturen optimiert und bietet professionelle Verwaltung wechselbarer USB-C SSDs. + +## Systemanforderungen + +### Mindestanforderungen +- **Betriebssystem**: Ubuntu 20.04+ / Debian 11+ / CentOS 8+ / RHEL 8+ +- **Hardware**: USB-C Port, mindestens 1GB freier Speicher +- **Berechtigungen**: `sudo` Zugriff für Installation +- **Netzwerk**: Internetverbindung für Package-Downloads + +### Empfohlene Konfiguration +- **RAM**: 4GB+ für Performance-Tests +- **CPU**: 2+ Cores für parallele Operationen +- **Storage**: 10GB+ freier Speicher für Logs und Caches +- **USB**: USB 3.0+ für optimale Performance + +### Unterstützte Distributionen +| Distribution | Version | Status | Notizen | +|--------------|---------|--------|---------| +| Ubuntu | 20.04+ | ✅ Vollständig | Empfohlen für Produktionsumgebungen | +| Debian | 11+ | ✅ Vollständig | Stabile Alternative zu Ubuntu | +| CentOS | 8+ | ✅ Vollständig | Enterprise-Umgebungen | +| RHEL | 8+ | ✅ Vollständig | Enterprise-Support verfügbar | +| Fedora | 35+ | ⚠️ Beta | Community-Support | +| Arch Linux | Rolling | ⚠️ Beta | Für erfahrene Benutzer | + +## Vor der Installation + +### 1. System-Update +```bash +# Ubuntu/Debian +sudo apt update && sudo apt upgrade -y + +# CentOS/RHEL +sudo yum update -y + +# Fedora +sudo dnf update -y +``` + +### 2. Git installieren +```bash +# Ubuntu/Debian +sudo apt install git -y + +# CentOS/RHEL +sudo yum install git -y + +# Fedora +sudo dnf install git -y +``` + +### 3. System-Informationen sammeln +```bash +# Betriebssystem-Version +lsb_release -a + +# Verfügbarer Speicher +df -h + +# USB-Ports identifizieren +lsusb + +# Aktuelle Benutzer-Gruppen +groups $USER +``` + +## Installation + +### Schritt 1: Repository klonen +```bash +# In Home-Verzeichnis wechseln +cd ~ + +# Repository klonen +git clone https://git.gitcover.de/KMU/usb-ssd.git + +# In Projekt-Verzeichnis wechseln +cd usb-ssd + +# Repository-Struktur prüfen +ls -la +``` + +### Schritt 2: Installations-Script ausführen +```bash +# Standard-Installation (empfohlen) +sudo ./scripts/installation/install.sh + +# Installation mit Verbose-Output +sudo ./scripts/installation/install.sh --verbose + +# Interaktive Installation mit Benutzer-Eingaben +sudo ./scripts/installation/install.sh --interactive +``` + +### Schritt 3: Installation verifizieren +```bash +# Installierte Scripts prüfen +ls -la /usr/local/bin/ssd-* + +# Systemd-Services prüfen +sudo systemctl status ssd-detection.service + +# Udev-Rules prüfen +ls -la /etc/udev/rules.d/99-ssd-* + +# Benutzer-Berechtigungen prüfen +groups $USER +``` + +## Erweiterte Installationsoptionen + +### Custom-Installation +```bash +# Installation in Custom-Verzeichnis +sudo ./scripts/installation/install.sh --prefix /opt/ssd-tools + +# Nur bestimmte Komponenten installieren +sudo ./scripts/installation/install.sh --components "detection,management" + +# Installation ohne Systemd-Services +sudo ./scripts/installation/install.sh --no-systemd + +# Installation mit Custom-Konfiguration +sudo ./scripts/installation/install.sh --config /path/to/custom.conf +``` + +### Benutzer-spezifische Installation +```bash +# Installation nur für aktuellen Benutzer (ohne sudo) +./scripts/installation/install.sh --user-install + +# Scripts werden installiert nach: +# ~/.local/bin/ssd-* +# ~/.config/ssd-management/ +``` + +### Entwicklungs-Installation +```bash +# Installation mit Debug-Modus +sudo ./scripts/installation/install.sh --debug --verbose + +# Installation mit Entwicklungs-Tools +sudo ./scripts/installation/install.sh --dev-tools + +# Symlinks statt Kopien (für Entwicklung) +sudo ./scripts/installation/install.sh --symlink +``` + +## Post-Installation Konfiguration + +### 1. Benutzer-Berechtigungen +```bash +# Aktuellen Benutzer zu ssd-users Gruppe hinzufügen +sudo usermod -a -G ssd-users $USER + +# Disk-Gruppe für Hardware-Zugriff +sudo usermod -a -G disk $USER + +# Neue Gruppen-Mitgliedschaft aktivieren +newgrp ssd-users + +# Berechtigungen prüfen +groups +``` + +### 2. Systemd-Services konfigurieren +```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 +sudo systemctl status ssd-automount.service +``` + +### 3. Udev-Rules aktivieren +```bash +# Udev-Rules neu laden +sudo udevadm control --reload-rules +sudo udevadm trigger + +# Test mit angeschlossener USB-SSD +sudo udevadm test /sys/block/sdb +``` + +### 4. Logging konfigurieren +```bash +# Log-Verzeichnisse erstellen +sudo mkdir -p /var/log/ssd-management + +# Log-Rotation aktivieren +sudo systemctl enable logrotate.timer + +# Erste Logs prüfen +sudo tail -f /var/log/ssd-detection.log +``` + +## Erste Verwendung + +### 1. USB-C SSD anschließen +```bash +# SSD anschließen und erkennen lassen +# Automatische Erkennung durch udev-rules + +# Manuelle Erkennung +ssd-detect.sh + +# Erkannte Geräte anzeigen +lsblk | grep -E "sd[b-z]" +``` + +### 2. Erste Mount-Operation +```bash +# Automatisches Mounting +ssd-mount-manager.sh mount + +# Mount-Status prüfen +ssd-mount-manager.sh status + +# Mount-Point prüfen +ls -la /mnt/ssd-storage/ +``` + +### 3. Test-Suite ausführen +```bash +# Schnelle Tests +ssd-test-suite.sh --quick + +# Vollständige Tests +ssd-test-suite.sh all + +# Performance-Benchmark +ssd-test-suite.sh --benchmark +``` + +### 4. Sichere Entfernung +```bash +# Safe-Eject ausführen +ssd-safe-eject.sh + +# Status nach Eject prüfen +ssd-mount-manager.sh status +``` + +## Konfiguration anpassen + +### 1. Haupt-Konfigurationsdatei +```bash +# Konfigurationsdatei bearbeiten +sudo nano /etc/ssd-management/config.conf + +# Beispiel-Konfiguration: +SSD_MOUNT_POINT="/mnt/ssd-storage" +SSD_LOG_LEVEL="INFO" +SSD_AUTO_MOUNT="true" +SSD_SMB_READY="true" +``` + +### 2. Mount-Optionen anpassen +```bash +# NTFS-Mount-Optionen +SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022,windows_names" + +# Performance-Optimierungen +SSD_MOUNT_OPTIONS="$SSD_MOUNT_OPTIONS,big_writes,cache=strict" +``` + +### 3. Logging-Level anpassen +```bash +# Debug-Logging aktivieren +export SSD_LOG_LEVEL=DEBUG + +# Syslog-Integration +export SSD_USE_SYSLOG=true + +# Log-Datei-Pfad +export SSD_LOG_FILE="/var/log/ssd-management.log" +``` + +## Troubleshooting + +### Häufige Installations-Probleme + +#### Problem: "Permission denied" +```bash +# Lösung: Installation mit sudo ausführen +sudo ./scripts/installation/install.sh + +# Benutzer-Berechtigungen prüfen +sudo -l +``` + +#### Problem: "Package not found" +```bash +# Lösung: Repository-Updates durchführen +sudo apt update # Ubuntu/Debian +sudo yum update # CentOS/RHEL + +# EPEL-Repository aktivieren (CentOS/RHEL) +sudo yum install epel-release +``` + +#### Problem: "Systemd service failed" +```bash +# Service-Status prüfen +sudo systemctl status ssd-detection.service + +# Service-Logs anzeigen +sudo journalctl -u ssd-detection.service + +# Service neu starten +sudo systemctl restart ssd-detection.service +``` + +#### Problem: "USB device not detected" +```bash +# USB-Geräte auflisten +lsusb + +# Block-Geräte anzeigen +lsblk + +# Udev-Events überwachen +sudo udevadm monitor + +# NTFS-Support prüfen +sudo modprobe ntfs +``` + +### Diagnose-Tools + +#### System-Diagnose +```bash +# Installations-Status prüfen +./scripts/installation/install.sh --status + +# Abhängigkeiten validieren +./scripts/installation/install.sh --check-dependencies + +# Konfiguration testen +./scripts/installation/install.sh --validate +``` + +#### Hardware-Diagnose +```bash +# USB-Controller prüfen +lspci | grep -i usb + +# Kernel-Module prüfen +lsmod | grep -E "(usb|ntfs)" + +# Hardware-Logs prüfen +dmesg | grep -i usb +``` + +## Deinstallation + +### Vollständige Deinstallation +```bash +# Deinstallations-Script ausführen +sudo ./scripts/installation/uninstall.sh + +# Manuelle Bereinigung (falls nötig) +sudo rm -rf /usr/local/bin/ssd-* +sudo rm -rf /etc/ssd-management/ +sudo rm -f /etc/systemd/system/ssd-*.service +sudo rm -f /etc/udev/rules.d/99-ssd-*.rules +``` + +### Konfiguration beibehalten +```bash +# Nur Scripts entfernen +sudo ./scripts/installation/uninstall.sh --keep-config + +# Logs beibehalten +sudo ./scripts/installation/uninstall.sh --keep-logs +``` + +## Upgrade-Prozess + +### Standard-Upgrade +```bash +# Repository aktualisieren +cd ~/usb-ssd +git pull origin main + +# Upgrade ausführen +sudo ./scripts/installation/install.sh --upgrade + +# Services neu starten +sudo systemctl restart ssd-detection.service ssd-automount.service +``` + +### Backup vor Upgrade +```bash +# Konfiguration sichern +sudo cp -r /etc/ssd-management /etc/ssd-management.backup.$(date +%Y%m%d) + +# Scripts sichern +sudo mkdir -p /tmp/ssd-backup +sudo cp /usr/local/bin/ssd-* /tmp/ssd-backup/ +``` + +## Support und Hilfe + +### Community-Support +- **Issues**: [Repository Issues](https://git.gitcover.de/KMU/usb-ssd/issues) +- **Discussions**: Repository-Discussions +- **Wiki**: [Repository Wiki](https://git.gitcover.de/KMU/usb-ssd/wiki) + +### Logs für Support +```bash +# System-Informationen sammeln +sudo ./scripts/installation/install.sh --system-info > system-info.txt + +# Logs sammeln +sudo tar -czf ssd-logs.tar.gz /var/log/ssd-*.log + +# Konfiguration anonymisieren +sudo cp /etc/ssd-management/config.conf config-anonymized.conf +``` + +### Enterprise-Support +Für professionellen Support und Custom-Entwicklungen kontaktieren Sie die GitCover® Organization. + +--- + +**⚠️ Wichtiger Hinweis**: Diese Installation manipuliert System-Konfigurationen und Hardware-Zugriffe. Führen Sie die Installation nur auf Systemen durch, auf denen Sie vollständige administrative Rechte haben und verstehen die Auswirkungen der Änderungen. diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md new file mode 100644 index 0000000..d4fb566 --- /dev/null +++ b/docs/troubleshooting.md @@ -0,0 +1,660 @@ +# USB-SSD Management System - Troubleshooting + +## Übersicht + +Diese Anleitung hilft bei der Diagnose und Lösung häufiger Probleme mit dem USB-SSD Management System. Die Probleme sind nach Kategorien sortiert und enthalten detaillierte Lösungsschritte. + +## Allgemeine Diagnose-Tools + +### System-Informationen sammeln +```bash +# System-Status prüfen +./scripts/installation/install.sh --status + +# Hardware-Informationen +lsusb -v | grep -A 10 "Mass Storage" +lsblk -f +dmesg | grep -i usb | tail -20 + +# Service-Status +sudo systemctl status ssd-detection.service +sudo systemctl status ssd-automount.service + +# Log-Analyse +tail -50 /var/log/ssd-management.log +journalctl -u ssd-detection.service --since "1 hour ago" +``` + +### Debug-Modus aktivieren +```bash +# Environment-Variables setzen +export SSD_DEBUG=true +export SSD_VERBOSE=true +export SSD_LOG_LEVEL=DEBUG + +# Scripts mit Debug-Output ausführen +ssd-detect.sh --debug --verbose +ssd-mount-manager.sh diagnose +ssd-test-suite.sh --debug +``` + +## Hardware-Probleme + +### Problem: USB-C SSD wird nicht erkannt + +#### Symptome +- `lsusb` zeigt das Gerät nicht an +- Keine Kernel-Messages beim Anschließen +- `ssd-detect.sh` findet keine Geräte + +#### Diagnose +```bash +# USB-Controller prüfen +lspci | grep -i usb + +# USB-Geräte auflisten +lsusb -t + +# Kernel-Messages überwachen +sudo dmesg -w +# SSD anschließen und Messages beobachten + +# USB-Module prüfen +lsmod | grep -E "(usb|storage)" +``` + +#### Lösungsansätze +```bash +# 1. USB-Module neu laden +sudo modprobe -r usb_storage +sudo modprobe usb_storage + +# 2. USB-Controller zurücksetzen +echo '1-1' | sudo tee /sys/bus/usb/drivers/usb/unbind +echo '1-1' | sudo tee /sys/bus/usb/drivers/usb/bind + +# 3. Udev-Rules neu laden +sudo udevadm control --reload-rules +sudo udevadm trigger + +# 4. Anderen USB-Port testen +# SSD an verschiedenen Ports testen + +# 5. Power-Management prüfen +echo 'on' | sudo tee /sys/bus/usb/devices/*/power/control +``` + +### Problem: SSD wird erkannt aber nicht als Block-Device + +#### Symptome +- `lsusb` zeigt das Gerät an +- `lsblk` zeigt kein entsprechendes Device +- Kernel-Messages zeigen Fehler + +#### Diagnose +```bash +# Block-Devices auflisten +lsblk -a + +# SCSI-Devices prüfen +cat /proc/scsi/scsi + +# Device-Mapper prüfen +sudo dmsetup ls + +# Partition-Tabelle prüfen +sudo fdisk -l | grep -A 10 "Disk /dev/sd" +``` + +#### Lösungsansätze +```bash +# 1. SCSI-Bus neu scannen +echo "- - -" | sudo tee /sys/class/scsi_host/host*/scan + +# 2. Partition-Tabelle reparieren +sudo parted /dev/sdb print +sudo parted /dev/sdb mklabel msdos # Nur wenn nötig! + +# 3. Device-Permissions prüfen +ls -la /dev/sd* +sudo chmod 660 /dev/sdb* + +# 4. Storage-Module neu laden +sudo modprobe -r usb_storage +sudo modprobe usb_storage quirks=VENDOR:PRODUCT:u +``` + +## Dateisystem-Probleme + +### Problem: NTFS-Dateisystem wird nicht unterstützt + +#### Symptome +- Mount schlägt mit "unknown filesystem type 'ntfs'" fehl +- `ssd-detect.sh` erkennt Filesystem nicht +- NTFS-Tools nicht verfügbar + +#### Diagnose +```bash +# NTFS-Support prüfen +cat /proc/filesystems | grep ntfs +which ntfs-3g +dpkg -l | grep ntfs + +# Kernel-Module prüfen +lsmod | grep ntfs +modinfo ntfs +``` + +#### Lösungsansätze +```bash +# 1. NTFS-3G installieren +# Ubuntu/Debian +sudo apt update +sudo apt install ntfs-3g + +# CentOS/RHEL +sudo yum install ntfs-3g + +# 2. NTFS-Modul laden +sudo modprobe ntfs + +# 3. Fuse-Support prüfen +sudo modprobe fuse +ls -la /dev/fuse + +# 4. Alternative: exFAT verwenden +sudo apt install exfat-fuse exfat-utils +``` + +### Problem: Filesystem-Korruption + +#### Symptome +- Mount schlägt mit I/O-Fehlern fehl +- Dateien sind nicht lesbar +- `ssd-test-suite.sh` zeigt Filesystem-Fehler + +#### Diagnose +```bash +# Filesystem-Check +sudo fsck.ntfs -f /dev/sdb1 +sudo ntfsfix /dev/sdb1 + +# SMART-Daten prüfen +sudo smartctl -a /dev/sdb + +# Bad-Blocks testen +sudo badblocks -v /dev/sdb1 +``` + +#### Lösungsansätze +```bash +# 1. Read-Only Mount versuchen +sudo mount -t ntfs -o ro /dev/sdb1 /mnt/ssd-storage + +# 2. Filesystem reparieren +sudo ntfsfix /dev/sdb1 +sudo fsck.ntfs -f /dev/sdb1 + +# 3. Daten retten +sudo ddrescue /dev/sdb1 /backup/ssd-image.img /backup/ssd-mapfile + +# 4. Neu formatieren (Datenverlust!) +sudo mkfs.ntfs -f /dev/sdb1 +``` + +## Mount-Probleme + +### Problem: Mount schlägt fehl + +#### Symptome +- `ssd-mount-manager.sh mount` gibt Fehler zurück +- Mount-Point ist nicht verfügbar +- Permission-Denied Fehler + +#### Diagnose +```bash +# Mount-Diagnose +ssd-mount-manager.sh diagnose + +# Aktuelle Mounts prüfen +mount | grep ssd +findmnt /mnt/ssd-storage + +# Mount-Point Status +ls -la /mnt/ssd-storage +stat /mnt/ssd-storage + +# Berechtigungen prüfen +groups $USER +id $USER +``` + +#### Lösungsansätze +```bash +# 1. Mount-Point bereinigen +ssd-mount-manager.sh cleanup +sudo umount -f /mnt/ssd-storage +sudo rmdir /mnt/ssd-storage +sudo mkdir -p /mnt/ssd-storage + +# 2. Berechtigungen korrigieren +sudo chown root:root /mnt/ssd-storage +sudo chmod 755 /mnt/ssd-storage + +# 3. Manueller Mount-Test +sudo mount -t ntfs /dev/sdb1 /mnt/ssd-storage +sudo mount -t ntfs -o uid=1000,gid=1000 /dev/sdb1 /mnt/ssd-storage + +# 4. Recovery-Modus +ssd-mount-manager.sh recover +``` + +### Problem: Mount hängt oder ist langsam + +#### Symptome +- Mount-Operation dauert sehr lange +- System reagiert nicht während Mount +- Hohe I/O-Wait Zeiten + +#### Diagnose +```bash +# I/O-Status prüfen +iostat -x 1 +iotop + +# Mount-Optionen prüfen +mount | grep ssd-storage + +# USB-Performance prüfen +sudo hdparm -t /dev/sdb1 +sudo dd if=/dev/sdb1 of=/dev/null bs=1M count=100 +``` + +#### Lösungsansätze +```bash +# 1. Mount-Optionen optimieren +sudo mount -t ntfs -o big_writes,cache=strict /dev/sdb1 /mnt/ssd-storage + +# 2. USB-Performance tunen +echo mq-deadline | sudo tee /sys/block/sdb/queue/scheduler +echo 1024 | sudo tee /sys/block/sdb/queue/read_ahead_kb + +# 3. Timeout erhöhen +export SSD_MOUNT_TIMEOUT=120 +ssd-mount-manager.sh mount + +# 4. Alternative Mount-Methode +sudo mount.ntfs-3g /dev/sdb1 /mnt/ssd-storage -o uid=1000,gid=1000 +``` + +## Service-Probleme + +### Problem: Systemd-Services starten nicht + +#### Symptome +- `systemctl start ssd-detection.service` schlägt fehl +- Services sind im "failed" Status +- Boot-Prozess hängt bei SSD-Services + +#### Diagnose +```bash +# Service-Status detailliert +sudo systemctl status ssd-detection.service -l +sudo systemctl status ssd-automount.service -l + +# Service-Logs +sudo journalctl -u ssd-detection.service --no-pager +sudo journalctl -u ssd-automount.service --since "1 hour ago" + +# Service-Konfiguration prüfen +sudo systemctl cat ssd-detection.service +sudo systemd-analyze verify /etc/systemd/system/ssd-detection.service +``` + +#### Lösungsansätze +```bash +# 1. Services neu laden +sudo systemctl daemon-reload +sudo systemctl reset-failed ssd-detection.service + +# 2. Service-Konfiguration reparieren +sudo systemctl edit ssd-detection.service +# [Service] +# Restart=on-failure +# RestartSec=5 + +# 3. Dependencies prüfen +sudo systemctl list-dependencies ssd-detection.service + +# 4. Service manuell testen +sudo /usr/local/bin/ssd-detect.sh --monitor +``` + +### Problem: Udev-Rules funktionieren nicht + +#### Symptome +- Automatische Erkennung funktioniert nicht +- USB-Events lösen keine Scripts aus +- Manuelle Erkennung funktioniert + +#### Diagnose +```bash +# Udev-Rules prüfen +ls -la /etc/udev/rules.d/99-ssd-* +cat /etc/udev/rules.d/99-ssd-automount.rules + +# Udev-Events testen +sudo udevadm monitor --environment --udev +# SSD anschließen und Events beobachten + +# Rule-Syntax testen +sudo udevadm test /sys/block/sdb +``` + +#### Lösungsansätze +```bash +# 1. Rules neu laden +sudo udevadm control --reload-rules +sudo udevadm trigger + +# 2. Rule-Syntax korrigieren +sudo nano /etc/udev/rules.d/99-ssd-automount.rules +# Korrekte Syntax: +# SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="add", RUN+="/usr/local/bin/ssd-detect.sh --device %k" + +# 3. Permissions prüfen +sudo chmod 644 /etc/udev/rules.d/99-ssd-automount.rules + +# 4. Udev-Service neu starten +sudo systemctl restart systemd-udevd +``` + +## Performance-Probleme + +### Problem: Langsame SSD-Performance + +#### Symptome +- `ssd-test-suite.sh` zeigt schlechte Performance +- Datei-Operationen sind langsam +- Benchmark-Werte unter Erwartung + +#### Diagnose +```bash +# Performance-Benchmark +ssd-test-suite.sh --benchmark --detailed + +# Hardware-Performance testen +sudo hdparm -t /dev/sdb1 +sudo dd if=/dev/zero of=/mnt/ssd-storage/testfile bs=1M count=1000 + +# USB-Geschwindigkeit prüfen +lsusb -t +cat /sys/bus/usb/devices/*/speed +``` + +#### Lösungsansätze +```bash +# 1. USB 3.0+ Port verwenden +# SSD an USB 3.0+ Port anschließen + +# 2. Mount-Optionen optimieren +sudo mount -o remount,big_writes,cache=strict /mnt/ssd-storage + +# 3. I/O-Scheduler optimieren +echo mq-deadline | sudo tee /sys/block/sdb/queue/scheduler + +# 4. Read-Ahead tunen +echo 2048 | sudo tee /sys/block/sdb/queue/read_ahead_kb + +# 5. SSD-Health prüfen +sudo smartctl -a /dev/sdb +``` + +### Problem: Hohe CPU-Last bei SSD-Operationen + +#### Symptome +- Hohe CPU-Auslastung während Mount/Unmount +- System reagiert langsam bei SSD-Zugriff +- `top` zeigt hohe System-CPU + +#### Diagnose +```bash +# CPU-Usage überwachen +top -p $(pgrep -f ssd-) +htop + +# I/O-Wait analysieren +iostat -x 1 10 + +# Prozess-Analyse +sudo strace -p $(pgrep -f ssd-mount-manager) +``` + +#### Lösungsansätze +```bash +# 1. Nice-Level anpassen +sudo renice -n 10 $(pgrep -f ssd-) + +# 2. I/O-Priorität setzen +sudo ionice -c 3 -p $(pgrep -f ssd-) + +# 3. Concurrent-Operations reduzieren +export SSD_MAX_PARALLEL_OPS=1 + +# 4. Caching optimieren +echo 1 | sudo tee /proc/sys/vm/drop_caches +``` + +## Eject-Probleme + +### Problem: Safe-Eject schlägt fehl + +#### Symptome +- `ssd-safe-eject.sh` gibt Fehler zurück +- "Device is busy" Meldungen +- Unmount schlägt fehl + +#### Diagnose +```bash +# Blockierende Prozesse finden +ssd-safe-eject.sh --show-processes +lsof /mnt/ssd-storage +fuser -v /mnt/ssd-storage + +# Mount-Status prüfen +mount | grep ssd-storage +findmnt /mnt/ssd-storage + +# Buffer-Status prüfen +cat /proc/meminfo | grep -E "(Dirty|Writeback)" +``` + +#### Lösungsansätze +```bash +# 1. Prozesse beenden +ssd-safe-eject.sh --kill-processes +sudo fuser -km /mnt/ssd-storage + +# 2. Buffer-Flush erzwingen +sync +echo 3 | sudo tee /proc/sys/vm/drop_caches + +# 3. Force-Unmount +sudo umount -f /mnt/ssd-storage +sudo umount -l /mnt/ssd-storage # Lazy unmount + +# 4. Hardware-Reset +echo 1 | sudo tee /sys/block/sdb/device/delete +``` + +### Problem: Hardware-Eject funktioniert nicht + +#### Symptome +- Unmount erfolgreich, aber LED blinkt weiter +- SSD kann nicht physisch entfernt werden +- `eject` Befehl schlägt fehl + +#### Diagnose +```bash +# Eject-Fähigkeiten prüfen +sudo hdparm -I /dev/sdb | grep -i removable +cat /sys/block/sdb/removable + +# SCSI-Eject testen +sudo sg_start --eject /dev/sdb +``` + +#### Lösungsansätze +```bash +# 1. Standard-Eject +sudo eject /dev/sdb + +# 2. SCSI-Eject +sudo sg_start --stop --eject /dev/sdb + +# 3. USB-Device entfernen +echo 1 | sudo tee /sys/block/sdb/device/delete + +# 4. Power-Management +echo auto | sudo tee /sys/block/sdb/device/power/control +``` + +## Logging-Probleme + +### Problem: Logs werden nicht erstellt + +#### Symptome +- Log-Dateien sind leer oder existieren nicht +- Keine Einträge in Systemd-Journal +- Debug-Output wird nicht angezeigt + +#### Diagnose +```bash +# Log-Verzeichnisse prüfen +ls -la /var/log/ssd-* +ls -la /var/log/syslog + +# Berechtigungen prüfen +stat /var/log/ssd-management.log +sudo -u ssd-user touch /var/log/test.log + +# Syslog-Konfiguration +cat /etc/rsyslog.d/50-ssd-management.conf +sudo systemctl status rsyslog +``` + +#### Lösungsansätze +```bash +# 1. Log-Verzeichnisse erstellen +sudo mkdir -p /var/log/ssd-management +sudo chown syslog:adm /var/log/ssd-management + +# 2. Berechtigungen korrigieren +sudo chmod 644 /var/log/ssd-*.log +sudo chown syslog:adm /var/log/ssd-*.log + +# 3. Syslog neu starten +sudo systemctl restart rsyslog + +# 4. Manuelle Log-Tests +logger -t ssd-test "Test message" +tail -f /var/log/syslog | grep ssd-test +``` + +## Erweiterte Diagnose + +### Vollständige System-Diagnose +```bash +#!/bin/bash +# system-diagnosis.sh + +echo "=== USB-SSD System Diagnosis ===" +echo "Date: $(date)" +echo "User: $(whoami)" +echo + +echo "=== System Information ===" +uname -a +lsb_release -a 2>/dev/null || cat /etc/os-release +echo + +echo "=== Hardware Information ===" +lsusb -v | grep -A 10 "Mass Storage" +lsblk -f +lspci | grep -i usb +echo + +echo "=== Service Status ===" +systemctl status ssd-detection.service --no-pager +systemctl status ssd-automount.service --no-pager +echo + +echo "=== Mount Status ===" +mount | grep ssd +findmnt /mnt/ssd-storage +echo + +echo "=== Log Analysis ===" +tail -20 /var/log/ssd-management.log +journalctl -u ssd-detection.service --since "1 hour ago" --no-pager +echo + +echo "=== Performance Test ===" +if [ -b /dev/sdb1 ]; then + sudo hdparm -t /dev/sdb1 +fi +echo + +echo "=== Configuration ===" +cat /etc/ssd-management/config.conf 2>/dev/null || echo "No config file found" +echo + +echo "=== Diagnosis Complete ===" +``` + +### Log-Sammlung für Support +```bash +#!/bin/bash +# collect-logs.sh + +TIMESTAMP=$(date +%Y%m%d_%H%M%S) +LOGDIR="/tmp/ssd-logs-$TIMESTAMP" + +mkdir -p "$LOGDIR" + +# System-Logs +cp /var/log/ssd-*.log "$LOGDIR/" 2>/dev/null +journalctl -u ssd-detection.service > "$LOGDIR/systemd-detection.log" +journalctl -u ssd-automount.service > "$LOGDIR/systemd-automount.log" + +# Konfiguration +cp -r /etc/ssd-management/ "$LOGDIR/config/" 2>/dev/null +cp /etc/udev/rules.d/99-ssd-*.rules "$LOGDIR/" 2>/dev/null + +# System-Informationen +./system-diagnosis.sh > "$LOGDIR/diagnosis.txt" + +# Archiv erstellen +tar -czf "ssd-logs-$TIMESTAMP.tar.gz" -C /tmp "ssd-logs-$TIMESTAMP" +echo "Logs collected in: ssd-logs-$TIMESTAMP.tar.gz" +``` + +## Support-Kontakt + +### Vor Support-Anfrage +1. **Diagnose durchführen**: `system-diagnosis.sh` ausführen +2. **Logs sammeln**: `collect-logs.sh` verwenden +3. **Reproduzierbarkeit**: Problem-Schritte dokumentieren +4. **System-Details**: Hardware und Software-Versionen angeben + +### Community-Support +- **Issues**: [Repository Issues](https://git.gitcover.de/KMU/usb-ssd/issues) +- **Discussions**: Repository-Discussions für allgemeine Fragen +- **Wiki**: [Repository Wiki](https://git.gitcover.de/KMU/usb-ssd/wiki) + +### Enterprise-Support +Für professionellen Support und Custom-Entwicklungen kontaktieren Sie die GitCover® Organization. + +--- + +**⚠️ Wichtiger Hinweis**: Bei kritischen Produktionsproblemen immer zuerst Backups erstellen und in einer Testumgebung reproduzieren, bevor Lösungsschritte angewendet werden. diff --git a/docs/usage-guide.md b/docs/usage-guide.md new file mode 100644 index 0000000..3f8318f --- /dev/null +++ b/docs/usage-guide.md @@ -0,0 +1,570 @@ +# USB-SSD Management System - Nutzungshandbuch + +## Übersicht + +Dieses Handbuch beschreibt die detaillierte Nutzung aller Funktionen des USB-SSD Management Systems. Es richtet sich an System-Administratoren, DevOps-Engineers und Entwickler in KMU-Umgebungen. + +## Grundlegende Konzepte + +### Konstanter Mount-Point +Das System verwendet einen konstanten logischen Mount-Point (`/mnt/ssd-storage`), unabhängig von der physischen SSD: +- **Vorteil**: Anwendungen können immer denselben Pfad verwenden +- **Flexibilität**: SSDs können gewechselt werden ohne Anpassung der Konfiguration +- **SMB-Integration**: Freigaben bleiben konstant verfügbar + +### UUID-basierte Identifikation +Alle Operationen basieren auf UUID-Identifikation statt Device-Namen: +- **Stabilität**: Unabhängig von USB-Port-Wechseln +- **Sicherheit**: Eindeutige Identifikation verhindert Verwechslungen +- **Logging**: Nachverfolgbare Audit-Trails + +## Täglicher Workflow + +### 1. SSD anschließen und erkennen +```bash +# USB-C SSD anschließen +# Automatische Erkennung durch udev-rules + +# Manuelle Erkennung (falls nötig) +ssd-detect.sh + +# Erkannte SSDs anzeigen +ssd-detect.sh --list + +# Detaillierte Informationen +ssd-detect.sh --verbose +``` + +### 2. SSD mounten +```bash +# Automatisches Mounting +ssd-mount-manager.sh mount + +# Spezifische SSD mounten +ssd-mount-manager.sh mount --device /dev/sdb1 + +# Read-Only Mount für Prüfungen +ssd-mount-manager.sh mount --readonly + +# Mount-Status prüfen +ssd-mount-manager.sh status +``` + +### 3. Mit SSD arbeiten +```bash +# Verfügbaren Speicher prüfen +df -h /mnt/ssd-storage + +# Dateien kopieren +cp -r /home/user/documents/ /mnt/ssd-storage/backup/ + +# Berechtigungen prüfen +ls -la /mnt/ssd-storage/ + +# SMB-Freigabe testen (falls konfiguriert) +smbclient //localhost/ssd-storage -U $USER +``` + +### 4. SSD sicher entfernen +```bash +# Sichere Entfernung +ssd-safe-eject.sh + +# Mit Prozess-Übersicht +ssd-safe-eject.sh --show-processes + +# Force-Eject bei hängenden Prozessen +ssd-safe-eject.sh --force + +# Status nach Entfernung prüfen +ssd-mount-manager.sh status +``` + +## Erweiterte Funktionen + +### SSD-Erkennung (ssd-detect.sh) + +#### Grundlegende Verwendung +```bash +# Alle USB-Storage-Geräte erkennen +ssd-detect.sh + +# Nur NTFS-Partitionen +ssd-detect.sh --ntfs-only + +# JSON-Output für Automation +ssd-detect.sh --output json + +# Kontinuierliche Überwachung +ssd-detect.sh --monitor --interval 5 +``` + +#### Erweiterte Optionen +```bash +# Spezifisches Device prüfen +ssd-detect.sh --device /dev/sdb1 + +# Hardware-Details anzeigen +ssd-detect.sh --hardware-info + +# Performance-Informationen +ssd-detect.sh --performance-info + +# Debug-Modus +ssd-detect.sh --debug --verbose +``` + +#### Output-Beispiele +```bash +# 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 +{ + "device": "/dev/sdb1", + "filesystem": "ntfs", + "uuid": "1234-5678-9ABC-DEF0", + "size": "500GB", + "label": "BACKUP_SSD", + "status": "ready", + "usb_version": "3.0", + "speed": "5Gbps" +} +``` + +### Mount-Management (ssd-mount-manager.sh) + +#### Mount-Operationen +```bash +# Standard-Mount +ssd-mount-manager.sh mount + +# Custom Mount-Point +ssd-mount-manager.sh mount --mountpoint /custom/path + +# Spezifische Mount-Optionen +ssd-mount-manager.sh mount --options "uid=1000,gid=1000,umask=022" + +# SMB-optimiertes Mounting +ssd-mount-manager.sh mount --smb-ready +``` + +#### Status und Monitoring +```bash +# Aktueller Status +ssd-mount-manager.sh status + +# Detaillierte Informationen +ssd-mount-manager.sh status --detailed + +# JSON-Output für Monitoring +ssd-mount-manager.sh status --json + +# Performance-Metriken +ssd-mount-manager.sh metrics +``` + +#### Troubleshooting +```bash +# Mount-Probleme diagnostizieren +ssd-mount-manager.sh diagnose + +# Mount-Point bereinigen +ssd-mount-manager.sh cleanup + +# Recovery-Modus +ssd-mount-manager.sh recover + +# Filesystem-Check vor Mount +ssd-mount-manager.sh mount --fsck +``` + +### Test-Suite (ssd-test-suite.sh) + +#### Grundlegende Tests +```bash +# Alle Tests ausführen +ssd-test-suite.sh all + +# Schnelle Tests (nur kritische) +ssd-test-suite.sh --quick + +# Spezifischen Test ausführen +ssd-test-suite.sh T01 # Hardware Detection +ssd-test-suite.sh T04 # Read Performance +ssd-test-suite.sh T08 # SMB Readiness +``` + +#### Test-Kategorien +```bash +# Hardware-Tests +ssd-test-suite.sh --category hardware + +# Performance-Tests +ssd-test-suite.sh --category performance + +# Integration-Tests +ssd-test-suite.sh --category integration + +# Security-Tests +ssd-test-suite.sh --category security +``` + +#### Benchmark-Modus +```bash +# Performance-Benchmark +ssd-test-suite.sh --benchmark + +# Detaillierte Performance-Analyse +ssd-test-suite.sh --benchmark --detailed + +# Vergleich mit Baseline +ssd-test-suite.sh --benchmark --compare baseline.json + +# Kontinuierliche Performance-Überwachung +ssd-test-suite.sh --benchmark --continuous --interval 3600 +``` + +### Sichere Entfernung (ssd-safe-eject.sh) + +#### Standard-Eject +```bash +# Sichere Entfernung +ssd-safe-eject.sh + +# Mit Verbose-Output +ssd-safe-eject.sh --verbose + +# Dry-Run (Simulation) +ssd-safe-eject.sh --dry-run +``` + +#### Erweiterte Eject-Optionen +```bash +# Aktive Prozesse anzeigen +ssd-safe-eject.sh --show-processes + +# Prozesse automatisch beenden +ssd-safe-eject.sh --kill-processes + +# Force-Eject bei Problemen +ssd-safe-eject.sh --force + +# Nur Unmount (ohne Hardware-Eject) +ssd-safe-eject.sh --unmount-only +``` + +#### Timeout-Konfiguration +```bash +# Custom Buffer-Flush Timeout +ssd-safe-eject.sh --timeout 120 + +# Prozess-Kill Timeout +ssd-safe-eject.sh --process-timeout 30 + +# Hardware-Eject Timeout +ssd-safe-eject.sh --eject-timeout 10 +``` + +## Use Cases und Workflows + +### 1. KMU-Backup-System +```bash +#!/bin/bash +# Tägliches Backup-Script + +# SSD mounten +ssd-mount-manager.sh mount || exit 1 + +# Backup durchführen +rsync -av --delete /important/data/ /mnt/ssd-storage/backup/ + +# Backup verifizieren +if [ $? -eq 0 ]; then + echo "Backup erfolgreich" + # Optional: Test-Suite ausführen + ssd-test-suite.sh --quick +else + echo "Backup fehlgeschlagen" + exit 1 +fi + +# SSD sicher entfernen +ssd-safe-eject.sh +``` + +### 2. Entwicklungsumgebung +```bash +#!/bin/bash +# Projekt-SSD wechseln + +# Aktuelle SSD sicher entfernen +ssd-safe-eject.sh + +echo "Bitte neue Projekt-SSD anschließen..." +read -p "Drücken Sie Enter wenn bereit..." + +# Neue SSD erkennen und mounten +ssd-detect.sh +ssd-mount-manager.sh mount + +# Projekt-Verzeichnis wechseln +cd /mnt/ssd-storage/project-alpha/ + +echo "Entwicklungsumgebung bereit" +``` + +### 3. Media-Server Erweiterung +```bash +#!/bin/bash +# Neue Media-Library hinzufügen + +# SSD mounten +ssd-mount-manager.sh mount --smb-ready + +# Qualitätsprüfung +ssd-test-suite.sh all + +# Media-Verzeichnis erstellen +mkdir -p /mnt/ssd-storage/media/videos +mkdir -p /mnt/ssd-storage/media/music + +# Berechtigungen für Media-Server setzen +chown -R mediaserver:mediaserver /mnt/ssd-storage/media/ +chmod -R 755 /mnt/ssd-storage/media/ + +# SMB-Freigabe neu laden (falls konfiguriert) +sudo systemctl reload smbd + +echo "Media-Library bereit" +``` + +### 4. Sichere Datenübertragung +```bash +#!/bin/bash +# Verschlüsselte Datenübertragung + +# SSD read-only mounten für Prüfung +ssd-mount-manager.sh mount --readonly + +# Datenintegrität prüfen +ssd-test-suite.sh T02 T06 # Filesystem + File Operations + +# Read-Write remount +ssd-mount-manager.sh remount --readwrite + +# Verschlüsselte Daten entschlüsseln +gpg --decrypt /mnt/ssd-storage/encrypted.gpg > /tmp/decrypted.txt + +# Verarbeitung... +process_data.sh /tmp/decrypted.txt + +# Temporäre Dateien sicher löschen +shred -vfz -n 3 /tmp/decrypted.txt + +# SSD sicher entfernen +ssd-safe-eject.sh +``` + +## Konfiguration und Anpassung + +### Environment Variables +```bash +# Mount-Konfiguration +export SSD_MOUNT_POINT="/mnt/ssd-storage" +export SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022" +export SSD_MOUNT_TIMEOUT=30 + +# Logging-Konfiguration +export SSD_LOG_LEVEL=INFO +export SSD_LOG_FILE="/var/log/ssd-management.log" +export SSD_USE_SYSLOG=true + +# Test-Konfiguration +export SSD_TEST_TIMEOUT=300 +export SSD_TEST_SIZE=100 +export SSD_BENCHMARK_MODE=false + +# Eject-Konfiguration +export SSD_EJECT_TIMEOUT=60 +export SSD_PROCESS_TIMEOUT=10 +export SSD_HARDWARE_EJECT=true +``` + +### Konfigurationsdatei +```bash +# /etc/ssd-management/config.conf +[mount] +default_mount_point = /mnt/ssd-storage +ntfs_options = uid=1000,gid=1000,umask=022,windows_names +auto_mount = true +smb_ready = true + +[logging] +log_level = INFO +log_file = /var/log/ssd-management.log +use_syslog = true +rotate_logs = true + +[testing] +quick_tests = T01,T02,T03,T08 +performance_threshold_read = 50MB/s +performance_threshold_write = 30MB/s +benchmark_enabled = false + +[security] +require_sudo = true +audit_logging = true +process_detection = true +buffer_monitoring = true +``` + +## Monitoring und Logging + +### Log-Analyse +```bash +# Aktuelle Logs anzeigen +tail -f /var/log/ssd-management.log + +# Fehler-Logs filtern +grep ERROR /var/log/ssd-management.log + +# Performance-Logs analysieren +grep PERFORMANCE /var/log/ssd-management.log | tail -20 + +# Audit-Trail anzeigen +grep AUDIT /var/log/ssd-management.log +``` + +### Systemd-Journal +```bash +# Service-Logs anzeigen +journalctl -u ssd-detection.service -f + +# Fehler-Logs der letzten Stunde +journalctl -u ssd-automount.service --since "1 hour ago" -p err + +# Boot-Logs für SSD-Services +journalctl -b -u ssd-detection.service +``` + +### Performance-Monitoring +```bash +# Aktuelle Performance-Metriken +ssd-mount-manager.sh metrics + +# Performance-Trend (letzte 24h) +ssd-test-suite.sh --benchmark --trend --hours 24 + +# Prometheus-Metriken exportieren +ssd-test-suite.sh --prometheus-metrics > /var/lib/prometheus/ssd-metrics.prom +``` + +## Troubleshooting + +### Häufige Probleme und Lösungen + +#### Problem: SSD wird nicht erkannt +```bash +# Diagnose +lsusb # USB-Geräte auflisten +lsblk # Block-Geräte anzeigen +dmesg | tail -20 # Kernel-Messages prüfen + +# Lösungsansätze +sudo udevadm trigger # Udev-Events neu auslösen +sudo modprobe ntfs # NTFS-Modul laden +ssd-detect.sh --debug # Debug-Modus +``` + +#### Problem: Mount schlägt fehl +```bash +# Diagnose +ssd-mount-manager.sh diagnose +sudo fsck.ntfs /dev/sdb1 # Filesystem prüfen +mount | grep ssd-storage # Aktuelle Mounts prüfen + +# Lösungsansätze +ssd-mount-manager.sh cleanup # Mount-Point bereinigen +ssd-mount-manager.sh recover # Recovery-Modus +sudo umount -f /mnt/ssd-storage # Force-Unmount +``` + +#### Problem: Eject hängt +```bash +# Diagnose +ssd-safe-eject.sh --show-processes # Blockierende Prozesse +lsof /mnt/ssd-storage # Offene Dateien +fuser -v /mnt/ssd-storage # Prozess-Details + +# Lösungsansätze +ssd-safe-eject.sh --kill-processes # Prozesse beenden +ssd-safe-eject.sh --force # Force-Eject +sudo fuser -km /mnt/ssd-storage # Alle Prozesse killen +``` + +### Debug-Modi +```bash +# Alle Scripts mit Debug-Output +export SSD_DEBUG=true +export SSD_VERBOSE=true + +# Trace-Modus für Scripts +bash -x ssd-detect.sh + +# Systemd-Service Debug +sudo systemctl edit ssd-detection.service +# [Service] +# Environment=SSD_DEBUG=true +``` + +## Best Practices + +### Produktionsumgebung +1. **Regelmäßige Tests**: Tägliche Quick-Tests, wöchentliche Full-Tests +2. **Monitoring**: Performance-Metriken überwachen, Alerts konfigurieren +3. **Backup**: Konfiguration und Logs regelmäßig sichern +4. **Updates**: System und Scripts aktuell halten +5. **Dokumentation**: Änderungen und Konfigurationen dokumentieren + +### Sicherheit +1. **Berechtigungen**: Minimale Berechtigungen verwenden +2. **Audit-Logs**: Alle Operationen protokollieren +3. **Verschlüsselung**: Sensible Daten verschlüsselt übertragen +4. **Access-Control**: Zugriff auf autorisierte Benutzer beschränken +5. **Regular-Scans**: Regelmäßige Security-Tests durchführen + +### Performance +1. **USB 3.0+**: Moderne USB-Standards verwenden +2. **SSD-Qualität**: Hochwertige SSDs für kritische Anwendungen +3. **Mount-Optionen**: Performance-optimierte NTFS-Optionen +4. **Caching**: Angemessene Cache-Konfiguration +5. **Monitoring**: Performance-Degradation frühzeitig erkennen + +--- + +**💡 Tipp**: Nutzen Sie die `--help` Option bei allen Scripts für detaillierte Informationen zu verfügbaren Parametern und Optionen. + +## Anhang + +### Script-Referenz +- `ssd-detect.sh` - Hardware-Erkennung und Device-Identifikation +- `ssd-mount-manager.sh` - Mount-Lifecycle Management +- `ssd-test-suite.sh` - Qualitätssicherung und Performance-Tests +- `ssd-safe-eject.sh` - Sichere Hardware-Entfernung + +### Wichtige Pfade +- `/mnt/ssd-storage/` - Standard Mount-Point +- `/etc/ssd-management/` - Konfigurationsdateien +- `/var/log/ssd-*.log` - Log-Dateien +- `/usr/local/bin/ssd-*` - Installierte Scripts + +### Support-Ressourcen +- [Installation Guide](installation-guide.md) - Detaillierte Installation +- [Troubleshooting](troubleshooting.md) - Problemlösungen +- [API Reference](api-reference.md) - Script-Parameter Referenz diff --git a/examples/smb-configuration/setup-smb.sh b/examples/smb-configuration/setup-smb.sh new file mode 100644 index 0000000..6dd8ad6 --- /dev/null +++ b/examples/smb-configuration/setup-smb.sh @@ -0,0 +1,490 @@ +#!/bin/bash +# USB-SSD Management System - SMB Setup Script +# Automatische Konfiguration von Samba für USB-C SSD Freigaben +# +# Verwendung: +# sudo ./setup-smb.sh [OPTIONS] +# +# Optionen: +# --install-samba Samba-Pakete installieren +# --configure-users Benutzer und Gruppen konfigurieren +# --setup-shares Freigaben konfigurieren +# --enable-services Services aktivieren und starten +# --all Alle Schritte ausführen + +set -euo pipefail + +# ============================================================================ +# Konfiguration +# ============================================================================ + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +SMB_CONF="/etc/samba/smb.conf" +SMB_CONF_BACKUP="/etc/samba/smb.conf.backup.$(date +%Y%m%d_%H%M%S)" +SSD_MOUNT_POINT="/mnt/ssd-storage" +LOG_FILE="/var/log/ssd-smb-setup.log" + +# Farben für Output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# ============================================================================ +# Logging-Funktionen +# ============================================================================ + +log() { + echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}" | tee -a "$LOG_FILE" +} + +warn() { + echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}" | tee -a "$LOG_FILE" +} + +error() { + echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}" | tee -a "$LOG_FILE" + exit 1 +} + +info() { + echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] INFO: $1${NC}" | tee -a "$LOG_FILE" +} + +# ============================================================================ +# Hilfsfunktionen +# ============================================================================ + +check_root() { + if [[ $EUID -ne 0 ]]; then + error "Dieses Script muss als root ausgeführt werden (sudo)" + fi +} + +check_mount_point() { + if [[ ! -d "$SSD_MOUNT_POINT" ]]; then + warn "Mount-Point $SSD_MOUNT_POINT existiert nicht - wird erstellt" + mkdir -p "$SSD_MOUNT_POINT" + chmod 755 "$SSD_MOUNT_POINT" + fi +} + +detect_os() { + if [[ -f /etc/os-release ]]; then + . /etc/os-release + OS=$ID + VERSION=$VERSION_ID + else + error "Betriebssystem konnte nicht erkannt werden" + fi + + log "Erkanntes OS: $OS $VERSION" +} + +# ============================================================================ +# Samba-Installation +# ============================================================================ + +install_samba() { + log "Installiere Samba-Pakete..." + + case "$OS" in + ubuntu|debian) + apt update + apt install -y samba samba-common-bin smbclient cifs-utils + ;; + centos|rhel|fedora) + if command -v dnf &> /dev/null; then + dnf install -y samba samba-common samba-client cifs-utils + else + yum install -y samba samba-common samba-client cifs-utils + fi + ;; + *) + error "Nicht unterstütztes Betriebssystem: $OS" + ;; + esac + + log "Samba-Installation abgeschlossen" +} + +# ============================================================================ +# Benutzer und Gruppen +# ============================================================================ + +configure_users() { + log "Konfiguriere Benutzer und Gruppen..." + + # Gruppen erstellen + local groups=( + "ssd-users:Benutzer mit SSD-Zugriff" + "ssd-admins:SSD-Administratoren" + "ssd-readonly:Nur-Lese-Zugriff auf SSD" + "backup-users:Backup-Benutzer" + "backup-admins:Backup-Administratoren" + "media-users:Media-Benutzer" + "developers:Entwickler" + "dev-leads:Entwicklungsleiter" + "archive-admins:Archiv-Administratoren" + ) + + for group_info in "${groups[@]}"; do + local group_name="${group_info%%:*}" + local group_desc="${group_info##*:}" + + if ! getent group "$group_name" &>/dev/null; then + groupadd "$group_name" + log "Gruppe erstellt: $group_name ($group_desc)" + else + info "Gruppe existiert bereits: $group_name" + fi + done + + # Standard-Benutzer zu ssd-users hinzufügen + if [[ -n "${SUDO_USER:-}" ]]; then + usermod -a -G ssd-users "$SUDO_USER" + log "Benutzer $SUDO_USER zu ssd-users hinzugefügt" + fi + + # Service-Benutzer erstellen + if ! id "ssd-service" &>/dev/null; then + useradd -r -s /bin/false -d /var/lib/ssd-service -c "SSD Service User" ssd-service + usermod -a -G ssd-users ssd-service + log "Service-Benutzer ssd-service erstellt" + fi + + log "Benutzer- und Gruppen-Konfiguration abgeschlossen" +} + +# ============================================================================ +# Verzeichnis-Struktur +# ============================================================================ + +setup_directories() { + log "Erstelle Verzeichnis-Struktur..." + + local directories=( + "$SSD_MOUNT_POINT" + "$SSD_MOUNT_POINT/backup" + "$SSD_MOUNT_POINT/archive" + "$SSD_MOUNT_POINT/media" + "$SSD_MOUNT_POINT/development" + "$SSD_MOUNT_POINT/temp" + "$SSD_MOUNT_POINT/home" + ) + + for dir in "${directories[@]}"; do + if [[ ! -d "$dir" ]]; then + mkdir -p "$dir" + log "Verzeichnis erstellt: $dir" + fi + done + + # Berechtigungen setzen + chown -R root:ssd-users "$SSD_MOUNT_POINT" + chmod -R 775 "$SSD_MOUNT_POINT" + + # Spezielle Berechtigungen + chmod 755 "$SSD_MOUNT_POINT/backup" + chown root:backup-users "$SSD_MOUNT_POINT/backup" + + chmod 755 "$SSD_MOUNT_POINT/archive" + chown root:archive-admins "$SSD_MOUNT_POINT/archive" + + chmod 777 "$SSD_MOUNT_POINT/temp" + + log "Verzeichnis-Struktur konfiguriert" +} + +# ============================================================================ +# SMB-Konfiguration +# ============================================================================ + +backup_smb_config() { + if [[ -f "$SMB_CONF" ]]; then + cp "$SMB_CONF" "$SMB_CONF_BACKUP" + log "SMB-Konfiguration gesichert: $SMB_CONF_BACKUP" + fi +} + +setup_smb_config() { + log "Konfiguriere Samba..." + + backup_smb_config + + # Neue Konfiguration kopieren + if [[ -f "$SCRIPT_DIR/smb.conf.example" ]]; then + cp "$SCRIPT_DIR/smb.conf.example" "$SMB_CONF" + log "SMB-Konfiguration installiert" + else + error "SMB-Konfigurationsdatei nicht gefunden: $SCRIPT_DIR/smb.conf.example" + fi + + # Mount-Point in Konfiguration anpassen + sed -i "s|/mnt/ssd-storage|$SSD_MOUNT_POINT|g" "$SMB_CONF" + + # Konfiguration validieren + if testparm -s "$SMB_CONF" &>/dev/null; then + log "SMB-Konfiguration ist gültig" + else + error "SMB-Konfiguration ist ungültig" + fi + + log "SMB-Konfiguration abgeschlossen" +} + +# ============================================================================ +# Service-Konfiguration +# ============================================================================ + +enable_services() { + log "Aktiviere und starte Services..." + + local services=("smbd" "nmbd") + + for service in "${services[@]}"; do + systemctl enable "$service" + systemctl restart "$service" + + if systemctl is-active --quiet "$service"; then + log "Service $service ist aktiv" + else + error "Service $service konnte nicht gestartet werden" + fi + done + + # Firewall-Konfiguration (falls UFW aktiv) + if command -v ufw &> /dev/null && ufw status | grep -q "Status: active"; then + ufw allow samba + log "Firewall-Regel für Samba hinzugefügt" + fi + + log "Service-Konfiguration abgeschlossen" +} + +# ============================================================================ +# Benutzer-Setup +# ============================================================================ + +setup_samba_users() { + log "Konfiguriere Samba-Benutzer..." + + # Aktueller Benutzer (falls vorhanden) + if [[ -n "${SUDO_USER:-}" ]]; then + echo "Samba-Passwort für Benutzer $SUDO_USER setzen:" + smbpasswd -a "$SUDO_USER" + smbpasswd -e "$SUDO_USER" + log "Samba-Benutzer $SUDO_USER konfiguriert" + fi + + # Service-Benutzer (ohne Passwort-Login) + smbpasswd -a ssd-service -n + smbpasswd -d ssd-service + + log "Samba-Benutzer-Konfiguration abgeschlossen" +} + +# ============================================================================ +# Tests und Validierung +# ============================================================================ + +test_smb_config() { + log "Teste SMB-Konfiguration..." + + # Konfiguration testen + if ! testparm -s &>/dev/null; then + error "SMB-Konfiguration ist ungültig" + fi + + # Services testen + for service in smbd nmbd; do + if ! systemctl is-active --quiet "$service"; then + error "Service $service ist nicht aktiv" + fi + done + + # Freigaben testen + if ! smbclient -L localhost -N &>/dev/null; then + warn "SMB-Freigaben sind nicht erreichbar" + else + log "SMB-Freigaben sind erreichbar" + fi + + log "SMB-Tests abgeschlossen" +} + +# ============================================================================ +# Cleanup und Wartung +# ============================================================================ + +setup_maintenance() { + log "Konfiguriere Wartungs-Scripts..." + + # Temp-Verzeichnis Cleanup + cat > /etc/cron.daily/ssd-temp-cleanup << 'EOF' +#!/bin/bash +# Bereinige temporäre SSD-Dateien (älter als 7 Tage) +find /mnt/ssd-storage/temp -type f -mtime +7 -delete 2>/dev/null || true +find /mnt/ssd-storage/temp -type d -empty -delete 2>/dev/null || true +EOF + + chmod +x /etc/cron.daily/ssd-temp-cleanup + + # Log-Rotation für SMB-Logs + cat > /etc/logrotate.d/ssd-smb << 'EOF' +/var/log/samba/*.log { + daily + rotate 30 + compress + delaycompress + missingok + notifempty + create 644 root root + postrotate + systemctl reload smbd nmbd 2>/dev/null || true + endscript +} +EOF + + log "Wartungs-Scripts konfiguriert" +} + +# ============================================================================ +# Hauptfunktionen +# ============================================================================ + +show_usage() { + cat << EOF +USB-SSD SMB Setup Script + +Verwendung: $0 [OPTIONEN] + +Optionen: + --install-samba Samba-Pakete installieren + --configure-users Benutzer und Gruppen konfigurieren + --setup-shares Freigaben konfigurieren + --enable-services Services aktivieren und starten + --all Alle Schritte ausführen + --help Diese Hilfe anzeigen + +Beispiele: + $0 --all # Vollständige Installation + $0 --install-samba # Nur Samba installieren + $0 --configure-users # Nur Benutzer konfigurieren + $0 --setup-shares # Nur Freigaben konfigurieren + +EOF +} + +main() { + local install_samba=false + local configure_users=false + local setup_shares=false + local enable_services=false + local all_steps=false + + # Parameter parsen + while [[ $# -gt 0 ]]; do + case $1 in + --install-samba) + install_samba=true + shift + ;; + --configure-users) + configure_users=true + shift + ;; + --setup-shares) + setup_shares=true + shift + ;; + --enable-services) + enable_services=true + shift + ;; + --all) + all_steps=true + shift + ;; + --help) + show_usage + exit 0 + ;; + *) + error "Unbekannte Option: $1" + ;; + esac + done + + # Wenn keine spezifischen Optionen, zeige Hilfe + if [[ "$install_samba" == false && "$configure_users" == false && "$setup_shares" == false && "$enable_services" == false && "$all_steps" == false ]]; then + show_usage + exit 1 + fi + + # Root-Berechtigung prüfen + check_root + + # OS erkennen + detect_os + + # Mount-Point prüfen + check_mount_point + + # Log-Datei initialisieren + mkdir -p "$(dirname "$LOG_FILE")" + touch "$LOG_FILE" + + log "USB-SSD SMB Setup gestartet" + + # Schritte ausführen + if [[ "$all_steps" == true || "$install_samba" == true ]]; then + install_samba + fi + + if [[ "$all_steps" == true || "$configure_users" == true ]]; then + configure_users + setup_directories + fi + + if [[ "$all_steps" == true || "$setup_shares" == true ]]; then + setup_smb_config + setup_samba_users + setup_maintenance + fi + + if [[ "$all_steps" == true || "$enable_services" == true ]]; then + enable_services + test_smb_config + fi + + log "USB-SSD SMB Setup abgeschlossen" + + # Zusammenfassung + cat << EOF + +${GREEN}=== Setup-Zusammenfassung ===${NC} + +SMB-Freigaben: + - //$(hostname)/ssd-storage (Haupt-Freigabe) + - //$(hostname)/ssd-backup (Backup-Speicher) + - //$(hostname)/ssd-archive (Archiv, Read-Only) + - //$(hostname)/ssd-media (Media-Dateien) + - //$(hostname)/ssd-dev (Entwicklung) + - //$(hostname)/ssd-temp (Temporäre Dateien) + +Nächste Schritte: + 1. USB-SSD anschließen und mounten: ssd-mount-manager.sh mount + 2. SMB-Freigaben testen: smbclient -L localhost -U $USER + 3. Von Windows: \\\\$(hostname)\\ssd-storage + +Log-Datei: $LOG_FILE +Konfiguration: $SMB_CONF +Backup: $SMB_CONF_BACKUP + +EOF +} + +# Script ausführen +main "$@" diff --git a/examples/smb-configuration/smb.conf.example b/examples/smb-configuration/smb.conf.example new file mode 100644 index 0000000..9c94fc6 --- /dev/null +++ b/examples/smb-configuration/smb.conf.example @@ -0,0 +1,338 @@ +# USB-SSD Management System - SMB Configuration Example +# Optimierte Samba-Konfiguration für USB-C SSD Freigaben +# +# Installation: +# sudo cp smb.conf.example /etc/samba/smb.conf +# sudo systemctl restart smbd nmbd +# sudo smbpasswd -a $USER + +# ============================================================================ +# Global Configuration +# ============================================================================ + +[global] + # Server-Identifikation + workgroup = WORKGROUP + server string = USB-SSD File Server + netbios name = SSD-SERVER + + # Protokoll-Versionen (SMB2/3 für bessere Performance) + server min protocol = SMB2 + server max protocol = SMB3 + client min protocol = SMB2 + client max protocol = SMB3 + + # Security-Konfiguration + security = user + map to guest = bad user + guest account = nobody + + # Logging + log file = /var/log/samba/log.%m + log level = 1 + max log size = 1000 + + # Performance-Optimierungen + socket options = TCP_NODELAY IPTOS_LOWDELAY SO_RCVBUF=131072 SO_SNDBUF=131072 + read raw = yes + write raw = yes + max xmit = 65535 + dead time = 15 + getwd cache = yes + + # Unicode und Charset + unix charset = UTF-8 + display charset = UTF-8 + dos charset = CP850 + + # Erweiterte Attribute für NTFS-Kompatibilität + ea support = yes + store dos attributes = yes + map archive = no + map hidden = no + map read only = no + map system = no + + # Locking-Optimierungen + kernel oplocks = no + level2 oplocks = yes + oplocks = yes + + # Name-Resolution + name resolve order = lmhosts wins bcast host + dns proxy = no + + # Printing (deaktiviert für SSD-Server) + load printers = no + printing = bsd + printcap name = /dev/null + disable spoolss = yes + +# ============================================================================ +# USB-SSD Storage Share +# ============================================================================ + +[ssd-storage] + # Basis-Konfiguration + comment = USB-C SSD Storage + path = /mnt/ssd-storage + browseable = yes + writable = yes + guest ok = no + + # Benutzer-Zugriff + valid users = @ssd-users, @disk + admin users = @ssd-admins + write list = @ssd-users + read list = @ssd-users, @ssd-readonly + + # Permissions + create mask = 0664 + directory mask = 0775 + force create mode = 0664 + force directory mode = 0775 + force user = ssd-user + force group = ssd-users + + # Performance-Optimierungen für USB-SSD + strict allocate = yes + allocation roundup size = 1048576 + read raw = yes + write raw = yes + + # NTFS-Kompatibilität + store dos attributes = yes + map archive = no + map hidden = no + map read only = no + map system = no + + # Erweiterte Attribute + ea support = yes + acl allow execute always = yes + + # Locking für Multi-User Zugriff + oplocks = yes + level2 oplocks = yes + kernel oplocks = no + locking = yes + strict locking = no + + # Veto-Dateien (Systemdateien ausschließen) + veto files = /._*/.DS_Store/Thumbs.db/desktop.ini/ + delete veto files = yes + + # Recycle-Bin (optional) + # vfs objects = recycle + # recycle:repository = .recycle + # recycle:keeptree = yes + # recycle:versions = yes + +# ============================================================================ +# Backup-spezifische Freigabe +# ============================================================================ + +[ssd-backup] + comment = USB-SSD Backup Storage + path = /mnt/ssd-storage/backup + browseable = yes + writable = yes + guest ok = no + + # Nur Backup-Benutzer + valid users = @backup-users + admin users = @backup-admins + write list = @backup-users + + # Restriktive Permissions + create mask = 0640 + directory mask = 0750 + force create mode = 0640 + force directory mode = 0750 + + # Backup-optimierte Einstellungen + strict allocate = yes + sync always = yes + strict sync = yes + + # Audit-Logging + full_audit:prefix = %u|%I|%S + full_audit:success = open opendir write unlink mkdir rmdir rename + full_audit:failure = all + vfs objects = full_audit + +# ============================================================================ +# Read-Only Archive Share +# ============================================================================ + +[ssd-archive] + comment = USB-SSD Archive (Read-Only) + path = /mnt/ssd-storage/archive + browseable = yes + writable = no + guest ok = yes + + # Read-Only Zugriff + read only = yes + write list = @archive-admins + + # Optimiert für große Dateien + read raw = yes + large readwrite = yes + + # Caching für bessere Performance + kernel share modes = yes + posix locking = no + +# ============================================================================ +# Media-Server Integration +# ============================================================================ + +[ssd-media] + comment = USB-SSD Media Storage + path = /mnt/ssd-storage/media + browseable = yes + writable = yes + guest ok = yes + + # Media-optimierte Einstellungen + valid users = @media-users, guest + write list = @media-admins + + # Große Dateien optimiert + read raw = yes + write raw = yes + large readwrite = yes + + # Media-spezifische Veto-Files + veto files = /._*/.DS_Store/Thumbs.db/.@__thumb/ + delete veto files = yes + + # Streaming-Optimierungen + strict allocate = no + allocation roundup size = 4096 + + # DLNA/UPnP Kompatibilität + store dos attributes = no + map archive = no + map hidden = no + +# ============================================================================ +# Development Share +# ============================================================================ + +[ssd-dev] + comment = USB-SSD Development Storage + path = /mnt/ssd-storage/development + browseable = yes + writable = yes + guest ok = no + + # Entwickler-Zugriff + valid users = @developers + admin users = @dev-leads + write list = @developers + + # Entwickler-freundliche Permissions + create mask = 0664 + directory mask = 0775 + force create mode = 0664 + force directory mode = 0775 + + # Git-Repository Unterstützung + store dos attributes = no + map archive = no + map hidden = no + map read only = no + map system = no + + # Symlink-Unterstützung + follow symlinks = yes + wide links = no + unix extensions = yes + + # Case-Sensitivity für Entwicklung + case sensitive = auto + default case = lower + preserve case = yes + short preserve case = yes + +# ============================================================================ +# Temporäre Freigabe +# ============================================================================ + +[ssd-temp] + comment = USB-SSD Temporary Storage + path = /mnt/ssd-storage/temp + browseable = yes + writable = yes + guest ok = yes + + # Temporärer Zugriff + valid users = @ssd-users, guest + + # Temporäre Dateien + create mask = 0666 + directory mask = 0777 + + # Automatische Bereinigung (via Cron) + # 0 2 * * * find /mnt/ssd-storage/temp -type f -mtime +7 -delete + + # Keine Attribute speichern + store dos attributes = no + ea support = no + +# ============================================================================ +# Administrative Freigabe +# ============================================================================ + +[ssd-admin] + comment = USB-SSD Administrative Access + path = /mnt/ssd-storage + browseable = no + writable = yes + guest ok = no + + # Nur Administratoren + valid users = @ssd-admins + admin users = @ssd-admins + + # Vollzugriff + create mask = 0664 + directory mask = 0775 + + # Audit-Logging für Admin-Zugriffe + full_audit:prefix = ADMIN|%u|%I|%S + full_audit:success = all + full_audit:failure = all + vfs objects = full_audit + + # Erweiterte Funktionen + ea support = yes + acl allow execute always = yes + nt acl support = yes + +# ============================================================================ +# Homes-Integration (optional) +# ============================================================================ + +[homes] + comment = Home Directories on USB-SSD + browseable = no + writable = yes + guest ok = no + + # Benutzer-spezifische Pfade + path = /mnt/ssd-storage/home/%S + valid users = %S + + # Standard-Permissions + create mask = 0600 + directory mask = 0700 + + # Privacy-Einstellungen + hide dot files = yes + hide files = /desktop.ini/thumbs.db/ + + # Quota-Unterstützung (falls aktiviert) + # preexec = /usr/local/bin/setup-user-quota.sh %S diff --git a/examples/systemd-services/README.md b/examples/systemd-services/README.md new file mode 100644 index 0000000..febd4df --- /dev/null +++ b/examples/systemd-services/README.md @@ -0,0 +1,287 @@ +# Systemd Service Templates + +## Übersicht + +Diese Verzeichnis enthält Systemd-Service-Templates für die automatische Integration des USB-SSD Management Systems in die Linux-Systemd-Infrastruktur. + +## Verfügbare Services + +### `ssd-detection.service` +**Zweck**: Kontinuierliche USB-C SSD Erkennung und Überwachung + +**Funktionen**: +- Automatische Erkennung neu angeschlossener SSDs +- Kontinuierliche Überwachung im 5-Sekunden-Intervall +- Integration mit udev-Events +- Systemd-Journal Logging +- Automatischer Restart bei Fehlern + +**Installation**: +```bash +sudo cp ssd-detection.service /etc/systemd/system/ +sudo systemctl daemon-reload +sudo systemctl enable ssd-detection.service +sudo systemctl start ssd-detection.service +``` + +### `ssd-automount.service` +**Zweck**: Automatisches Mounting erkannter SSDs + +**Funktionen**: +- Automatisches Mounting auf `/mnt/ssd-storage` +- Abhängigkeit von `ssd-detection.service` +- Graceful Shutdown mit Safe-Eject +- Remount-Funktionalität +- PID-File Management + +**Installation**: +```bash +sudo cp ssd-automount.service /etc/systemd/system/ +sudo systemctl daemon-reload +sudo systemctl enable ssd-automount.service +sudo systemctl start ssd-automount.service +``` + +### `ssd-mount@.service` +**Zweck**: Template-Service für spezifische Device-Mounting + +**Funktionen**: +- Template-basiertes Mounting für spezifische Devices +- Device-Binding mit `BindsTo=` +- Oneshot-Service mit `RemainAfterExit=yes` +- Automatisches Cleanup bei Device-Entfernung + +**Verwendung**: +```bash +# Service für spezifisches Device starten +sudo systemctl start ssd-mount@sdb1.service + +# Service für spezifisches Device aktivieren +sudo systemctl enable ssd-mount@sdb1.service + +# Status prüfen +sudo systemctl status ssd-mount@sdb1.service +``` + +## Service-Konfiguration + +### Anpassung der Services + +#### Environment-Variables +```bash +# Service-Konfiguration bearbeiten +sudo systemctl edit ssd-detection.service + +# Beispiel-Konfiguration: +[Service] +Environment=SSD_LOG_LEVEL=DEBUG +Environment=SSD_MONITOR_INTERVAL=10 +Environment=SSD_USE_SYSLOG=true +``` + +#### Mount-Point anpassen +```bash +# Automount-Service anpassen +sudo systemctl edit ssd-automount.service + +[Service] +Environment=SSD_MOUNT_POINT=/custom/mount/point +``` + +#### Security-Einstellungen +```bash +# Zusätzliche Security-Optionen +sudo systemctl edit ssd-detection.service + +[Service] +# Zusätzliche Device-Zugriffe +DeviceAllow=/dev/nvme* rw +DeviceAllow=/dev/mmcblk* rw + +# Zusätzliche Pfad-Zugriffe +ReadWritePaths=/custom/path +``` + +## Service-Management + +### Standard-Operationen +```bash +# Services aktivieren +sudo systemctl enable ssd-detection.service ssd-automount.service + +# Services starten +sudo systemctl start ssd-detection.service ssd-automount.service + +# Status prüfen +sudo systemctl status ssd-detection.service +sudo systemctl status ssd-automount.service + +# Services stoppen +sudo systemctl stop ssd-detection.service ssd-automount.service + +# Services deaktivieren +sudo systemctl disable ssd-detection.service ssd-automount.service +``` + +### Logs und Monitoring +```bash +# Service-Logs anzeigen +sudo journalctl -u ssd-detection.service -f +sudo journalctl -u ssd-automount.service --since "1 hour ago" + +# Alle SSD-Services +sudo journalctl -u "ssd-*" --since today + +# Service-Status überwachen +watch -n 5 'systemctl status ssd-detection.service ssd-automount.service' +``` + +### Troubleshooting +```bash +# Service-Konfiguration validieren +sudo systemd-analyze verify /etc/systemd/system/ssd-detection.service + +# Service-Dependencies anzeigen +sudo systemctl list-dependencies ssd-automount.service + +# Failed-Services anzeigen +sudo systemctl --failed | grep ssd + +# Service neu starten +sudo systemctl restart ssd-detection.service +``` + +## Erweiterte Konfiguration + +### Custom-Service erstellen +```bash +# Basis-Template kopieren +sudo cp ssd-detection.service /etc/systemd/system/ssd-custom.service + +# Service anpassen +sudo nano /etc/systemd/system/ssd-custom.service + +# Service aktivieren +sudo systemctl daemon-reload +sudo systemctl enable ssd-custom.service +``` + +### Multi-Device Support +```bash +# Template-Service für mehrere Devices +sudo systemctl enable ssd-mount@sdb1.service +sudo systemctl enable ssd-mount@sdc1.service +sudo systemctl enable ssd-mount@sdd1.service + +# Alle Template-Services starten +sudo systemctl start ssd-mount@*.service +``` + +### Timer-basierte Services +```bash +# Timer für regelmäßige Tests erstellen +sudo nano /etc/systemd/system/ssd-test.service +sudo nano /etc/systemd/system/ssd-test.timer + +# Timer aktivieren +sudo systemctl enable ssd-test.timer +sudo systemctl start ssd-test.timer +``` + +## Security-Konfiguration + +### Hardening-Optionen +```ini +[Service] +# Zusätzliche Security-Features +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true +RestrictRealtime=true +RestrictSUIDSGID=true +LockPersonality=true +MemoryDenyWriteExecute=true +RestrictNamespaces=true +``` + +### Capability-Management +```ini +[Service] +# Minimale Capabilities +CapabilityBoundingSet=CAP_SYS_ADMIN CAP_DAC_OVERRIDE +AmbientCapabilities=CAP_SYS_ADMIN CAP_DAC_OVERRIDE +``` + +### User/Group-Konfiguration +```bash +# Dedicated Service-User erstellen +sudo useradd -r -s /bin/false ssd-service +sudo usermod -a -G disk ssd-service + +# Service-Konfiguration anpassen +[Service] +User=ssd-service +Group=disk +``` + +## Integration mit anderen Services + +### SMB-Integration +```ini +[Unit] +# SMB-Service nach SSD-Mount starten +Before=smbd.service +PartOf=smbd.service + +[Service] +# SMB-Reload nach Mount +ExecStartPost=/bin/systemctl reload-or-restart smbd.service +``` + +### Backup-Integration +```ini +[Unit] +# Backup-Service nach SSD-Mount starten +Before=backup.service + +[Service] +# Backup-Trigger nach Mount +ExecStartPost=/usr/local/bin/trigger-backup.sh +``` + +### Monitoring-Integration +```ini +[Service] +# Prometheus-Metriken exportieren +ExecStartPost=/usr/local/bin/export-ssd-metrics.sh +``` + +## Best Practices + +### Produktionsumgebung +1. **Immer `systemctl daemon-reload`** nach Service-Änderungen +2. **Service-Dependencies** korrekt konfigurieren +3. **Logging-Level** für Produktion auf INFO setzen +4. **Security-Features** aktivieren +5. **Monitoring** für Service-Status einrichten + +### Entwicklungsumgebung +1. **Debug-Logging** aktivieren +2. **Manual-Start** für Tests verwenden +3. **Service-Isolation** für Entwicklung +4. **Frequent-Reload** für Änderungen + +### Monitoring und Alerting +1. **Systemd-Status** überwachen +2. **Service-Logs** analysieren +3. **Performance-Metriken** sammeln +4. **Failure-Alerts** konfigurieren + +## Changelog + +### Version 0.1.0 +- Basis-Service Templates +- Security-Hardening +- Multi-Device Support +- Integration-Beispiele +- Comprehensive Documentation diff --git a/examples/systemd-services/ssd-automount.service b/examples/systemd-services/ssd-automount.service new file mode 100644 index 0000000..b312279 --- /dev/null +++ b/examples/systemd-services/ssd-automount.service @@ -0,0 +1,45 @@ +[Unit] +Description=Automatic SSD Mounting Service +Documentation=https://git.gitcover.de/KMU/usb-ssd +After=ssd-detection.service +Requires=ssd-detection.service +BindsTo=ssd-detection.service + +[Service] +Type=forking +User=root +Group=root +ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --auto-mount +ExecStop=/usr/local/bin/ssd-safe-eject.sh --all +ExecReload=/usr/local/bin/ssd-mount-manager.sh remount +PIDFile=/var/run/ssd-automount.pid +Restart=on-failure +RestartSec=10 +TimeoutStartSec=60 +TimeoutStopSec=30 + +# Logging +StandardOutput=journal +StandardError=journal +SyslogIdentifier=ssd-automount + +# Security +NoNewPrivileges=true +ProtectSystem=strict +ProtectHome=true +ReadWritePaths=/var/log /var/run /mnt /media +PrivateTmp=true +PrivateDevices=false +DevicePolicy=closed +DeviceAllow=/dev/sd* rw +DeviceAllow=/dev/disk/by-uuid/* rw + +# Environment +Environment=SSD_LOG_LEVEL=INFO +Environment=SSD_USE_SYSLOG=true +Environment=SSD_AUTO_MOUNT=true +Environment=SSD_MOUNT_POINT=/mnt/ssd-storage + +[Install] +WantedBy=multi-user.target +Also=ssd-detection.service diff --git a/examples/systemd-services/ssd-detection.service b/examples/systemd-services/ssd-detection.service new file mode 100644 index 0000000..5219201 --- /dev/null +++ b/examples/systemd-services/ssd-detection.service @@ -0,0 +1,42 @@ +[Unit] +Description=USB-C SSD Detection Service +Documentation=https://git.gitcover.de/KMU/usb-ssd +After=local-fs.target +Wants=systemd-udevd.service +After=systemd-udevd.service + +[Service] +Type=simple +User=root +Group=root +ExecStart=/usr/local/bin/ssd-detect.sh --monitor --interval 5 +ExecReload=/bin/kill -HUP $MAINPID +Restart=on-failure +RestartSec=5 +TimeoutStartSec=30 +TimeoutStopSec=10 + +# Logging +StandardOutput=journal +StandardError=journal +SyslogIdentifier=ssd-detection + +# Security +NoNewPrivileges=true +ProtectSystem=strict +ProtectHome=true +ReadWritePaths=/var/log /var/run /mnt +PrivateTmp=true +PrivateDevices=false +DevicePolicy=closed +DeviceAllow=/dev/sd* rw +DeviceAllow=/dev/disk/by-uuid/* rw + +# Environment +Environment=SSD_LOG_LEVEL=INFO +Environment=SSD_USE_SYSLOG=true +Environment=SSD_MONITOR_INTERVAL=5 + +[Install] +WantedBy=multi-user.target +Alias=ssd-detect.service diff --git a/examples/systemd-services/ssd-mount@.service b/examples/systemd-services/ssd-mount@.service new file mode 100644 index 0000000..b8e1716 --- /dev/null +++ b/examples/systemd-services/ssd-mount@.service @@ -0,0 +1,38 @@ +[Unit] +Description=SSD Mount Manager for %i +Documentation=https://git.gitcover.de/KMU/usb-ssd +After=local-fs.target +BindsTo=dev-%i.device +After=dev-%i.device + +[Service] +Type=oneshot +RemainAfterExit=yes +User=root +Group=root +ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%i +ExecStop=/usr/local/bin/ssd-safe-eject.sh --device /dev/%i +TimeoutStartSec=30 +TimeoutStopSec=15 + +# Logging +StandardOutput=journal +StandardError=journal +SyslogIdentifier=ssd-mount + +# Security +NoNewPrivileges=true +ProtectSystem=strict +ProtectHome=true +ReadWritePaths=/var/log /var/run /mnt +PrivateTmp=true +PrivateDevices=false +DevicePolicy=closed +DeviceAllow=/dev/%i rw + +# Environment +Environment=SSD_LOG_LEVEL=INFO +Environment=SSD_USE_SYSLOG=true + +[Install] +WantedBy=multi-user.target diff --git a/examples/udev-rules/99-ssd-automount.rules b/examples/udev-rules/99-ssd-automount.rules new file mode 100644 index 0000000..9bea9a6 --- /dev/null +++ b/examples/udev-rules/99-ssd-automount.rules @@ -0,0 +1,158 @@ +# USB-SSD Management System - Udev Rules +# Automatische Erkennung und Mounting von USB-C SSDs +# +# Installation: +# sudo cp 99-ssd-automount.rules /etc/udev/rules.d/ +# sudo udevadm control --reload-rules +# sudo udevadm trigger + +# ============================================================================ +# USB Storage Device Detection +# ============================================================================ + +# USB Mass Storage Devices - Automatische Erkennung +SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --udev-mode" + +# USB Storage Devices - Entfernung +SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="remove", \ + RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k --udev-mode" + +# ============================================================================ +# NTFS Filesystem Detection +# ============================================================================ + +# NTFS Partitionen - Automatisches Mounting +SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", ACTION=="add", \ + ATTRS{removable}=="1", \ + RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount" + +# exFAT Partitionen - Alternative Unterstützung +SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="exfat", ENV{ID_BUS}=="usb", ACTION=="add", \ + ATTRS{removable}=="1", \ + RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount" + +# ============================================================================ +# Device Permissions und Ownership +# ============================================================================ + +# USB Storage Devices - Berechtigungen setzen +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + GROUP="disk", MODE="0660" + +# Device-Nodes für SSD-Management Gruppe +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{ID_FS_TYPE}=="ntfs|exfat", \ + GROUP="ssd-users", MODE="0664" + +# ============================================================================ +# Symlink Creation +# ============================================================================ + +# Persistente Symlinks basierend auf UUID +SUBSYSTEM=="block", ENV{ID_FS_UUID}!="", ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", \ + SYMLINK+="disk/by-ssd-uuid/$env{ID_FS_UUID}" + +# Symlinks basierend auf Label +SUBSYSTEM=="block", ENV{ID_FS_LABEL}!="", ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", \ + SYMLINK+="disk/by-ssd-label/$env{ID_FS_LABEL}" + +# ============================================================================ +# Spezifische Vendor/Product Rules +# ============================================================================ + +# Samsung USB-C SSDs +SUBSYSTEM=="block", ATTRS{idVendor}=="04e8", ATTRS{idProduct}=="61f*", \ + ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor samsung" + +# SanDisk USB-C SSDs +SUBSYSTEM=="block", ATTRS{idVendor}=="0781", ATTRS{idProduct}=="55*", \ + ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor sandisk" + +# Generic USB 3.0+ Storage +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{bcdUSB}=="0300|0310|0320", \ + ATTRS{removable}=="1", ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --usb3-mode" + +# ============================================================================ +# Environment Variables für Scripts +# ============================================================================ + +# Udev-Modus für alle SSD-Scripts +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{SSD_UDEV_MODE}="true", \ + ENV{SSD_LOG_LEVEL}="INFO", \ + ENV{SSD_USE_SYSLOG}="true" + +# Device-Informationen für Scripts +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{SSD_DEVICE_PATH}="/dev/%k", \ + ENV{SSD_DEVICE_UUID}="$env{ID_FS_UUID}", \ + ENV{SSD_DEVICE_LABEL}="$env{ID_FS_LABEL}", \ + ENV{SSD_DEVICE_TYPE}="$env{ID_FS_TYPE}" + +# ============================================================================ +# Systemd Service Integration +# ============================================================================ + +# Systemd-Service für spezifische Devices starten +SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", ACTION=="add", \ + TAG+="systemd", ENV{SYSTEMD_WANTS}="ssd-mount@%k.service" + +# Systemd-Service bei Device-Entfernung stoppen +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/bin/systemctl stop ssd-mount@%k.service" + +# ============================================================================ +# Logging und Debugging +# ============================================================================ + +# Debug-Informationen loggen (nur bei Debug-Modus) +# SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ +# RUN+="/usr/bin/logger -t udev-ssd 'Device %k: Action=%E{ACTION}, Type=%E{ID_FS_TYPE}, UUID=%E{ID_FS_UUID}'" + +# ============================================================================ +# Sicherheits-Rules +# ============================================================================ + +# Nur autorisierte Benutzer können auf SSD-Devices zugreifen +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{ID_FS_TYPE}=="ntfs|exfat", \ + TEST!="/etc/ssd-management/authorized_users", \ + GROUP="root", MODE="0600" + +# Blacklist für bekannte problematische Devices +SUBSYSTEM=="block", ATTRS{idVendor}=="0000", ATTRS{idProduct}=="0000", \ + ENV{UDISKS_IGNORE}="1" + +# ============================================================================ +# Performance-Optimierungen +# ============================================================================ + +# I/O-Scheduler für USB-SSDs optimieren +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ATTR{queue/scheduler}="mq-deadline" + +# Read-Ahead für USB-SSDs optimieren +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ATTR{queue/read_ahead_kb}="1024" + +# ============================================================================ +# Cleanup und Maintenance +# ============================================================================ + +# Alte Mount-Points bereinigen bei Device-Entfernung +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/usr/local/bin/ssd-mount-manager.sh cleanup --device %k" + +# Temporäre Dateien bereinigen +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/bin/rm -f /tmp/ssd-%k-*" diff --git a/examples/udev-rules/README.md b/examples/udev-rules/README.md new file mode 100644 index 0000000..b8050cc --- /dev/null +++ b/examples/udev-rules/README.md @@ -0,0 +1,343 @@ +# Udev Rules für USB-SSD Management + +## Übersicht + +Diese Udev-Rules ermöglichen die automatische Erkennung und Verarbeitung von USB-C SSDs auf Linux-Systemen. Sie integrieren sich nahtlos mit dem USB-SSD Management System und bieten Hardware-Event-basierte Automatisierung. + +## Verfügbare Rules + +### `99-ssd-automount.rules` +**Zweck**: Umfassende Udev-Rules für automatische SSD-Erkennung und -Management + +**Hauptfunktionen**: +- Automatische USB Storage Device Erkennung +- NTFS/exFAT Filesystem Detection +- Device-Permissions und Ownership Management +- Persistente Symlink-Erstellung +- Systemd-Service Integration +- Performance-Optimierungen +- Security-Features + +## Installation + +### Standard-Installation +```bash +# Rules-Datei kopieren +sudo cp 99-ssd-automount.rules /etc/udev/rules.d/ + +# Udev-Rules neu laden +sudo udevadm control --reload-rules + +# Bestehende Devices neu triggern +sudo udevadm trigger + +# Installation verifizieren +ls -la /etc/udev/rules.d/99-ssd-* +``` + +### Test der Installation +```bash +# USB-SSD anschließen und Events überwachen +sudo udevadm monitor --environment --udev + +# Spezifisches Device testen +sudo udevadm test /sys/block/sdb + +# Rule-Syntax validieren +sudo udevadm test --action=add /sys/block/sdb +``` + +## Rule-Kategorien + +### 1. USB Storage Device Detection +```bash +# Automatische Erkennung bei USB-Device-Anschluss +SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --udev-mode" + +# Automatische Behandlung bei Device-Entfernung +SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="remove", \ + RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k --udev-mode" +``` + +### 2. Filesystem-spezifische Rules +```bash +# NTFS-Partitionen automatisch mounten +SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", ACTION=="add", \ + ATTRS{removable}=="1", \ + RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount" + +# exFAT-Support +SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="exfat", ENV{ID_BUS}=="usb", ACTION=="add", \ + ATTRS{removable}=="1", \ + RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount" +``` + +### 3. Device-Permissions +```bash +# Basis-Berechtigungen für USB Storage +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + GROUP="disk", MODE="0660" + +# Erweiterte Berechtigungen für SSD-Management +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{ID_FS_TYPE}=="ntfs|exfat", \ + GROUP="ssd-users", MODE="0664" +``` + +### 4. Symlink-Management +```bash +# UUID-basierte Symlinks +SUBSYSTEM=="block", ENV{ID_FS_UUID}!="", ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", \ + SYMLINK+="disk/by-ssd-uuid/$env{ID_FS_UUID}" + +# Label-basierte Symlinks +SUBSYSTEM=="block", ENV{ID_FS_LABEL}!="", ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", \ + SYMLINK+="disk/by-ssd-label/$env{ID_FS_LABEL}" +``` + +## Vendor-spezifische Rules + +### Samsung USB-C SSDs +```bash +# Samsung-spezifische Erkennung +SUBSYSTEM=="block", ATTRS{idVendor}=="04e8", ATTRS{idProduct}=="61f*", \ + ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor samsung" +``` + +### SanDisk USB-C SSDs +```bash +# SanDisk-spezifische Erkennung +SUBSYSTEM=="block", ATTRS{idVendor}=="0781", ATTRS{idProduct}=="55*", \ + ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor sandisk" +``` + +### Generic USB 3.0+ Storage +```bash +# USB 3.0+ Devices +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{bcdUSB}=="0300|0310|0320", \ + ATTRS{removable}=="1", ACTION=="add", \ + RUN+="/usr/local/bin/ssd-detect.sh --device %k --usb3-mode" +``` + +## Systemd-Integration + +### Service-Aktivierung +```bash +# Systemd-Service für spezifische Devices +SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", ACTION=="add", \ + TAG+="systemd", ENV{SYSTEMD_WANTS}="ssd-mount@%k.service" + +# Service-Deaktivierung bei Entfernung +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/bin/systemctl stop ssd-mount@%k.service" +``` + +## Performance-Optimierungen + +### I/O-Scheduler +```bash +# Optimaler I/O-Scheduler für USB-SSDs +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ATTR{queue/scheduler}="mq-deadline" +``` + +### Read-Ahead Tuning +```bash +# Read-Ahead Buffer optimieren +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ATTR{queue/read_ahead_kb}="1024" +``` + +## Security-Features + +### Autorisierte Benutzer +```bash +# Zugriff nur für autorisierte Benutzer +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{ID_FS_TYPE}=="ntfs|exfat", \ + TEST!="/etc/ssd-management/authorized_users", \ + GROUP="root", MODE="0600" +``` + +### Device-Blacklist +```bash +# Problematische Devices ignorieren +SUBSYSTEM=="block", ATTRS{idVendor}=="0000", ATTRS{idProduct}=="0000", \ + ENV{UDISKS_IGNORE}="1" +``` + +## Environment-Variables + +### Script-Konfiguration +```bash +# Udev-Modus für alle SSD-Scripts +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{SSD_UDEV_MODE}="true", \ + ENV{SSD_LOG_LEVEL}="INFO", \ + ENV{SSD_USE_SYSLOG}="true" +``` + +### Device-Informationen +```bash +# Device-Details für Scripts +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{SSD_DEVICE_PATH}="/dev/%k", \ + ENV{SSD_DEVICE_UUID}="$env{ID_FS_UUID}", \ + ENV{SSD_DEVICE_LABEL}="$env{ID_FS_LABEL}", \ + ENV{SSD_DEVICE_TYPE}="$env{ID_FS_TYPE}" +``` + +## Debugging und Troubleshooting + +### Debug-Modus aktivieren +```bash +# Debug-Logging aktivieren (auskommentiert in Produktion) +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + RUN+="/usr/bin/logger -t udev-ssd 'Device %k: Action=%E{ACTION}, Type=%E{ID_FS_TYPE}, UUID=%E{ID_FS_UUID}'" +``` + +### Event-Monitoring +```bash +# Udev-Events in Echtzeit überwachen +sudo udevadm monitor --environment --udev + +# Spezifische Events filtern +sudo udevadm monitor --subsystem-match=block --property-match=ID_BUS=usb + +# Event-Details anzeigen +sudo udevadm info --query=all --name=/dev/sdb1 +``` + +### Rule-Testing +```bash +# Rule-Syntax testen +sudo udevadm test /sys/block/sdb + +# Spezifische Action testen +sudo udevadm test --action=add /sys/block/sdb + +# Rule-Matching prüfen +sudo udevadm test --action=add /sys/block/sdb 2>&1 | grep "RUN" +``` + +## Custom-Rules erstellen + +### Basis-Template +```bash +# Custom-Rule Template +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ENV{ID_FS_TYPE}=="ntfs", \ + ATTRS{idVendor}=="YOUR_VENDOR", \ + ACTION=="add", \ + RUN+="/path/to/your/script.sh --device %k" +``` + +### Erweiterte Matching-Kriterien +```bash +# Mehrere Kriterien kombinieren +SUBSYSTEM=="block", \ + ENV{ID_BUS}=="usb", \ + ATTRS{removable}=="1", \ + ENV{ID_FS_TYPE}=="ntfs", \ + ENV{ID_FS_LABEL}=="BACKUP*", \ + ATTRS{size}=="976773168", \ + ACTION=="add", \ + RUN+="/usr/local/bin/backup-ssd-handler.sh --device %k" +``` + +## Maintenance und Cleanup + +### Automatische Bereinigung +```bash +# Mount-Points bereinigen +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/usr/local/bin/ssd-mount-manager.sh cleanup --device %k" + +# Temporäre Dateien entfernen +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/bin/rm -f /tmp/ssd-%k-*" +``` + +### Log-Rotation +```bash +# Log-Dateien rotieren +SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \ + ACTION=="remove", \ + RUN+="/usr/sbin/logrotate -f /etc/logrotate.d/ssd-management" +``` + +## Best Practices + +### Produktionsumgebung +1. **Minimale Rules**: Nur notwendige Rules aktivieren +2. **Performance**: I/O-Optimierungen für kritische Systeme +3. **Security**: Strenge Berechtigungen und Autorisierung +4. **Logging**: Produktions-geeignetes Log-Level +5. **Testing**: Umfassende Tests vor Deployment + +### Entwicklungsumgebung +1. **Debug-Logging**: Erweiterte Logging-Rules aktivieren +2. **Flexible-Matching**: Weniger restriktive Matching-Kriterien +3. **Rapid-Testing**: Schnelle Rule-Reload-Zyklen +4. **Monitoring**: Kontinuierliche Event-Überwachung + +### Sicherheit +1. **Principle of Least Privilege**: Minimale Berechtigungen +2. **Device-Validation**: Nur vertrauenswürdige Devices +3. **Audit-Logging**: Vollständige Event-Protokollierung +4. **Access-Control**: Benutzer-basierte Zugriffskontrolle + +## Troubleshooting + +### Häufige Probleme + +#### Rules werden nicht ausgeführt +```bash +# Rules-Syntax prüfen +sudo udevadm test /sys/block/sdb + +# Rules neu laden +sudo udevadm control --reload-rules +sudo udevadm trigger + +# Permissions prüfen +ls -la /etc/udev/rules.d/99-ssd-* +``` + +#### Scripts werden nicht gefunden +```bash +# Script-Pfade prüfen +which ssd-detect.sh +ls -la /usr/local/bin/ssd-* + +# Permissions prüfen +ls -la /usr/local/bin/ssd-detect.sh +``` + +#### Device-Matching funktioniert nicht +```bash +# Device-Eigenschaften anzeigen +sudo udevadm info --query=all --name=/dev/sdb1 + +# Matching-Kriterien testen +sudo udevadm test --action=add /sys/block/sdb1 +``` + +## Changelog + +### Version 0.1.0 +- Umfassende USB-SSD Detection Rules +- Systemd-Service Integration +- Performance-Optimierungen +- Security-Features +- Vendor-spezifische Rules +- Debugging und Troubleshooting Support diff --git a/scripts/installation/README.md b/scripts/installation/README.md new file mode 100644 index 0000000..e879f10 --- /dev/null +++ b/scripts/installation/README.md @@ -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 diff --git a/scripts/ssd-detection/README.md b/scripts/ssd-detection/README.md new file mode 100644 index 0000000..a1bfc78 --- /dev/null +++ b/scripts/ssd-detection/README.md @@ -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 diff --git a/scripts/ssd-detection/ssd-safe-eject.sh b/scripts/ssd-detection/ssd-safe-eject.sh new file mode 100644 index 0000000..506b867 --- /dev/null +++ b/scripts/ssd-detection/ssd-safe-eject.sh @@ -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 "$@" diff --git a/scripts/ssd-management/README.md b/scripts/ssd-management/README.md new file mode 100644 index 0000000..091152c --- /dev/null +++ b/scripts/ssd-management/README.md @@ -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 diff --git a/scripts/ssd-management/ssd-mount-manager.sh b/scripts/ssd-management/ssd-mount-manager.sh new file mode 100644 index 0000000..59b977b --- /dev/null +++ b/scripts/ssd-management/ssd-mount-manager.sh @@ -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 "$@" diff --git a/scripts/ssd-testing/README.md b/scripts/ssd-testing/README.md new file mode 100644 index 0000000..907dc07 --- /dev/null +++ b/scripts/ssd-testing/README.md @@ -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 diff --git a/scripts/ssd-testing/ssd-test-suite.sh b/scripts/ssd-testing/ssd-test-suite.sh new file mode 100644 index 0000000..d9eea76 --- /dev/null +++ b/scripts/ssd-testing/ssd-test-suite.sh @@ -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 "$@"