KMU/usb-ssd
Template
SHA256
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Setup installation

Browse Source
This commit is contained in:
Axel Druschel
2025-08-07 19:28:22 +02:00
parent e3f6363844
commit 17d74b261d
19 changed files with 6144 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

479
docs/api-reference.md Normal file
View File

@@ -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.

439
docs/installation-guide.md Normal file
View File

@@ -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.

660
docs/troubleshooting.md Normal file
View File

@@ -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.

570
docs/usage-guide.md Normal file
View File

@@ -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

490
examples/smb-configuration/setup-smb.sh Normal file
View File

@@ -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 "$@"

338
examples/smb-configuration/smb.conf.example Normal file
View File

@@ -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

287
examples/systemd-services/README.md Normal file
View File

@@ -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

45
examples/systemd-services/ssd-automount.service Normal file
View File

@@ -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

42
examples/systemd-services/ssd-detection.service Normal file
View File

@@ -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

38
examples/systemd-services/ssd-mount@.service Normal file
View File

@@ -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

158
examples/udev-rules/99-ssd-automount.rules Normal file
View File

@@ -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-*"

343
examples/udev-rules/README.md Normal file
View File

@@ -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

372
scripts/installation/README.md Normal file
View File

@@ -0,0 +1,372 @@
# Installation Module
## Übersicht
Das Installation Module bietet eine vollautomatische Master-Installation für das USB-SSD Management System. Es konfiguriert alle Abhängigkeiten, erstellt System-Services und richtet die komplette Infrastruktur für den produktiven Einsatz ein.
## Hauptkomponenten
### `install.sh`
**Zweck**: Master-Installation mit vollständiger System-Konfiguration
**Installationsschritte**:
- System-Abhängigkeiten installieren
- Scripts in System-Pfade kopieren
- Systemd-Services konfigurieren
- Udev-Rules einrichten
- Benutzer-Berechtigungen setzen
- Logging-Infrastruktur aufbauen
## Installation
### Schnell-Installation
```bash
# Repository klonen
git clone https://git.gitcover.de/KMU/usb-ssd.git
cd usb-ssd
# Master-Installation ausführen
sudo ./scripts/installation/install.sh
```
### Erweiterte Installation
```bash
# Installation mit Custom-Konfiguration
sudo ./scripts/installation/install.sh --config /path/to/config.conf
# Installation ohne Systemd-Services
sudo ./scripts/installation/install.sh --no-systemd
# Installation mit Debug-Modus
sudo ./scripts/installation/install.sh --debug --verbose
```
### Interaktive Installation
```bash
# Schritt-für-Schritt Installation mit Benutzer-Eingaben
sudo ./scripts/installation/install.sh --interactive
# Nur bestimmte Komponenten installieren
sudo ./scripts/installation/install.sh --components "detection,management"
```
## Installationsoptionen
### Standard-Installation
```bash
# Vollständige Installation (empfohlen)
sudo ./install.sh
# Installiert:
# - Alle System-Abhängigkeiten
# - Scripts nach /usr/local/bin/
# - Systemd-Services
# - Udev-Rules
# - Log-Rotation
# - Bash-Completion
```
### Custom-Installation
```bash
# Spezifische Installationspfade
sudo ./install.sh --prefix /opt/ssd-tools
# Custom-Konfiguration
sudo ./install.sh --config-dir /etc/ssd-management
# Benutzer-spezifische Installation
./install.sh --user-install
```
### Komponenten-basierte Installation
```bash
# Nur Detection-Module
sudo ./install.sh --component detection
# Nur Management-Module
sudo ./install.sh --component management
# Nur Testing-Module
sudo ./install.sh --component testing
# Mehrere Komponenten
sudo ./install.sh --components "detection,management,testing"
```
## System-Abhängigkeiten
### Automatisch installierte Packages
#### Ubuntu/Debian
```bash
# Core-Packages
ntfs-3g # NTFS-Dateisystem Support
util-linux # Mount/Unmount Utilities
parted # Partitionstabellen-Management
bc # Berechnungen in Scripts
eject # Hardware-Eject Funktionalität
# Optional-Packages
smartmontools # SSD-Health Monitoring
hdparm # Hardware-Parameter Tuning
fio # Performance-Testing
samba-common # SMB-Integration
```
#### CentOS/RHEL
```bash
# Core-Packages
ntfs-3g
util-linux
parted
bc
eject
# EPEL-Repository für zusätzliche Tools
sudo yum install epel-release
```
### Manuelle Abhängigkeits-Installation
```bash
# Ubuntu/Debian
sudo apt update
sudo apt install ntfs-3g util-linux parted bc eject smartmontools hdparm fio
# CentOS/RHEL
sudo yum install ntfs-3g util-linux parted bc eject smartmontools hdparm fio
# Arch Linux
sudo pacman -S ntfs-3g util-linux parted bc eject smartmontools hdparm fio
```
## Systemd-Integration
### Installierte Services
#### `ssd-detection.service`
```ini
[Unit]
Description=USB-C SSD Detection Service
After=local-fs.target
[Service]
Type=oneshot
ExecStart=/usr/local/bin/ssd-detect.sh --monitor
Restart=on-failure
[Install]
WantedBy=multi-user.target
```
#### `ssd-automount.service`
```ini
[Unit]
Description=Automatic SSD Mounting
After=ssd-detection.service
[Service]
Type=forking
ExecStart=/usr/local/bin/ssd-mount-manager.sh --auto-mount
ExecStop=/usr/local/bin/ssd-safe-eject.sh --all
[Install]
WantedBy=multi-user.target
```
### Service-Management
```bash
# Services aktivieren
sudo systemctl enable ssd-detection.service
sudo systemctl enable ssd-automount.service
# Services starten
sudo systemctl start ssd-detection.service
sudo systemctl start ssd-automount.service
# Status prüfen
sudo systemctl status ssd-detection.service
```
## Udev-Rules
### Automatische USB-Erkennung
```bash
# /etc/udev/rules.d/99-ssd-automount.rules
SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="add", RUN+="/usr/local/bin/ssd-detect.sh --device %k"
SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="remove", RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k"
```
### Udev-Rules aktivieren
```bash
# Rules neu laden
sudo udevadm control --reload-rules
sudo udevadm trigger
# Test der Rules
sudo udevadm test /sys/block/sdb
```
## Benutzer-Berechtigungen
### Gruppe-Konfiguration
```bash
# SSD-Management Gruppe erstellen
sudo groupadd ssd-users
# Benutzer zur Gruppe hinzufügen
sudo usermod -a -G ssd-users $USER
# Disk-Gruppe für Hardware-Zugriff
sudo usermod -a -G disk $USER
```
### Sudo-Konfiguration
```bash
# /etc/sudoers.d/ssd-management
%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-mount-manager.sh
%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-safe-eject.sh
%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-detect.sh
```
## Logging-Konfiguration
### Log-Rotation
```bash
# /etc/logrotate.d/ssd-management
/var/log/ssd-*.log {
daily
rotate 30
compress
delaycompress
missingok
notifempty
create 644 root root
}
```
### Syslog-Integration
```bash
# /etc/rsyslog.d/50-ssd-management.conf
:programname, isequal, "ssd-detect" /var/log/ssd-detection.log
:programname, isequal, "ssd-mount" /var/log/ssd-management.log
:programname, isequal, "ssd-test" /var/log/ssd-testing.log
& stop
```
## Bash-Completion
### Auto-Completion aktivieren
```bash
# /etc/bash_completion.d/ssd-tools
_ssd_detect() {
local cur prev opts
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
opts="--verbose --ntfs-only --device --output --monitor --debug"
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
}
complete -F _ssd_detect ssd-detect.sh
```
## Deinstallation
### Vollständige Deinstallation
```bash
# Deinstallations-Script ausführen
sudo ./scripts/installation/uninstall.sh
# Manuelle Deinstallation
sudo systemctl stop ssd-detection.service ssd-automount.service
sudo systemctl disable ssd-detection.service ssd-automount.service
sudo rm /etc/systemd/system/ssd-*.service
sudo rm /usr/local/bin/ssd-*
sudo rm /etc/udev/rules.d/99-ssd-automount.rules
```
### Konfiguration beibehalten
```bash
# Nur Scripts entfernen, Konfiguration behalten
sudo ./scripts/installation/uninstall.sh --keep-config
```
## Upgrade-Prozess
### In-Place Upgrade
```bash
# Repository aktualisieren
git pull origin main
# Upgrade ausführen
sudo ./scripts/installation/install.sh --upgrade
# Services neu starten
sudo systemctl restart ssd-detection.service
```
### Backup vor Upgrade
```bash
# Konfiguration sichern
sudo cp -r /etc/ssd-management /etc/ssd-management.backup
# Scripts sichern
sudo cp /usr/local/bin/ssd-* /tmp/ssd-backup/
```
## Troubleshooting
### Installations-Probleme
```bash
# Installation mit Debug-Output
sudo ./install.sh --debug --verbose
# Abhängigkeits-Probleme prüfen
./install.sh --check-dependencies
# Berechtigungs-Probleme
sudo ./install.sh --fix-permissions
```
### Häufige Probleme
1. **Permission denied**: Installation mit `sudo` ausführen
2. **Package not found**: Repository-Updates durchführen
3. **Service failed**: Systemd-Logs prüfen (`journalctl -u ssd-detection.service`)
### Diagnose-Tools
```bash
# System-Diagnose
./install.sh --diagnose
# Installations-Status prüfen
./install.sh --status
# Konfiguration validieren
./install.sh --validate
```
## Best Practices
### Produktionsumgebung
1. **Vollständige Installation** mit allen Komponenten
2. **Systemd-Services aktivieren** für automatisches Management
3. **Log-Rotation konfigurieren** für Langzeit-Betrieb
4. **Monitoring einrichten** für Service-Überwachung
5. **Backup-Strategie** für Konfigurationsdateien
### Entwicklungsumgebung
1. **Komponenten-basierte Installation** für spezifische Tests
2. **Debug-Modus aktivieren** für Entwicklung
3. **User-Installation** für isolierte Tests
4. **Häufige Upgrades** für aktuelle Features
## Changelog
### Version 0.1.0
- Master-Installation Script
- Systemd-Service Integration
- Udev-Rules Konfiguration
- Benutzer-Berechtigungen Setup
- Logging-Infrastruktur
- Bash-Completion Support

170
scripts/ssd-detection/README.md Normal file
View File

@@ -0,0 +1,170 @@
# SSD Detection Module
## Übersicht
Das SSD Detection Module ist verantwortlich für die automatische Erkennung und Identifikation von USB-C SSDs im System. Es bietet robuste Hardware-Erkennung mit NTFS-Partition-Support.
## Hauptkomponenten
### `ssd-detect.sh`
**Zweck**: Automatische USB-C SSD Identifikation und NTFS-Partition Erkennung
**Hauptfunktionen**:
- Erkennung neu angeschlossener USB-Storage-Devices
- NTFS-Dateisystem Validierung
- UUID-basierte Geräte-Identifikation
- Hardware-Kompatibilitätsprüfung
- Logging aller Erkennungsvorgänge
## Verwendung
### Grundlegende Erkennung
```bash
# Automatische SSD-Erkennung
./ssd-detect.sh
# Verbose-Modus mit detailliertem Output
./ssd-detect.sh --verbose
# Nur NTFS-Partitionen anzeigen
./ssd-detect.sh --ntfs-only
```
### Erweiterte Optionen
```bash
# Spezifisches Device prüfen
./ssd-detect.sh --device /dev/sdb1
# JSON-Output für Automation
./ssd-detect.sh --output json
# Kontinuierliche Überwachung
./ssd-detect.sh --monitor
```
## Ausgabe-Format
### Standard-Output
```
[INFO] USB-C SSD detected: /dev/sdb1
[INFO] Filesystem: NTFS
[INFO] UUID: 1234-5678-9ABC-DEF0
[INFO] Size: 500GB
[INFO] Label: BACKUP_SSD
[SUCCESS] Device ready for mounting
```
### JSON-Output
```json
{
"device": "/dev/sdb1",
"filesystem": "ntfs",
"uuid": "1234-5678-9ABC-DEF0",
"size": "500GB",
"label": "BACKUP_SSD",
"status": "ready"
}
```
## Konfiguration
### Environment Variables
```bash
# Standardmäßige Erkennungszeit (Sekunden)
export SSD_DETECT_TIMEOUT=30
# Log-Level (DEBUG, INFO, WARN, ERROR)
export SSD_LOG_LEVEL=INFO
# Unterstützte Dateisysteme
export SSD_SUPPORTED_FS="ntfs,exfat,ext4"
```
## Fehlerbehandlung
### Häufige Probleme
1. **Keine SSD erkannt**: USB-Verbindung prüfen, Device-Permissions kontrollieren
2. **NTFS nicht unterstützt**: `ntfs-3g` Package installieren
3. **Permission denied**: Script mit `sudo` ausführen
### Debug-Modus
```bash
# Erweiterte Diagnose
./ssd-detect.sh --debug
# System-Logs prüfen
journalctl -f | grep ssd-detect
```
## Integration
### Systemd-Service
```bash
# Automatische Erkennung bei Boot
sudo systemctl enable ssd-detect.service
```
### Udev-Rules
```bash
# Automatische Erkennung bei USB-Events
# Siehe examples/udev-rules/
```
## Abhängigkeiten
### Erforderliche Packages
- `util-linux` - Device-Management
- `ntfs-3g` - NTFS-Support
- `parted` - Partitionstabellen
- `udev` - Hardware-Events
### Installation
```bash
# Ubuntu/Debian
sudo apt install util-linux ntfs-3g parted udev
# CentOS/RHEL
sudo yum install util-linux ntfs-3g parted systemd-udev
```
## Sicherheit
### Best Practices
- Immer UUID-basierte Identifikation verwenden
- Device-Permissions vor Zugriff prüfen
- Logging für Audit-Trails aktivieren
- Read-Only Modus für kritische Prüfungen
### Berechtigungen
```bash
# Minimale Berechtigungen für Detection
sudo usermod -a -G disk $USER
```
## Entwicklung
### Testing
```bash
# Unit-Tests ausführen
./test-ssd-detect.sh
# Integration-Tests
./test-ssd-detect-integration.sh
```
### Debugging
```bash
# Trace-Modus
bash -x ./ssd-detect.sh
# Profiling
time ./ssd-detect.sh --benchmark
```
## Changelog
### Version 0.1.0
- Initiale Implementierung
- NTFS-Support
- UUID-basierte Erkennung
- JSON-Output Format

334
scripts/ssd-detection/ssd-safe-eject.sh Normal file
View File

@@ -0,0 +1,334 @@
#!/bin/bash
# ssd-safe-eject.sh - Safe Eject Extension für USB-C SSDs
# Zweck: Sichere Entfernung von USB-C SSDs mit vollständigem Sync und Hardware-Eject
set -e
# Konfiguration
MOUNT_POINT="/mnt/ssd-storage"
LOG_FILE="/var/log/ssd-mount.log"
# Farben für Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Logging-Funktion
log_message() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - SAFE-EJECT: $1" | sudo tee -a "$LOG_FILE"
echo -e "${BLUE}[SAFE-EJECT]${NC} $1"
}
log_success() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" | sudo tee -a "$LOG_FILE"
echo -e "${GREEN}[✓]${NC} $1"
}
log_warning() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" | sudo tee -a "$LOG_FILE"
echo -e "${YELLOW}[!]${NC} $1"
}
log_error() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" | sudo tee -a "$LOG_FILE"
echo -e "${RED}[✗]${NC} $1"
}
# Schritt 1: Pre-Eject Validierung
validate_pre_eject() {
log_message "Validiere Pre-Eject Status..."
if ! mountpoint -q "$MOUNT_POINT"; then
log_warning "Keine SSD auf $MOUNT_POINT gemountet"
return 1
fi
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
log_success "Gemountetes Device identifiziert: $mounted_device"
# Prüfe ob Device USB-Device ist
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
log_success "USB-Device bestätigt: $device_base"
echo "$mounted_device"
return 0
else
log_error "Device ist kein USB-Device - Safe-Eject nicht anwendbar"
return 1
fi
}
# Schritt 2: Aktive Prozesse prüfen
check_active_processes() {
local device="$1"
log_message "Prüfe aktive Prozesse auf $MOUNT_POINT..."
# Prozesse finden die das Mount-Point verwenden
active_processes=$(lsof "$MOUNT_POINT" 2>/dev/null || true)
if [ -n "$active_processes" ]; then
log_warning "Aktive Prozesse gefunden:"
echo "$active_processes"
echo ""
echo "Prozesse beenden? (y/n/s für skip)"
read -r response
case "$response" in
"y"|"Y")
log_message "Beende Prozesse..."
lsof -t "$MOUNT_POINT" 2>/dev/null | xargs -r sudo kill -TERM
sleep 2
# Prüfe erneut
remaining=$(lsof "$MOUNT_POINT" 2>/dev/null || true)
if [ -n "$remaining" ]; then
log_warning "Einige Prozesse laufen noch - Force Kill..."
lsof -t "$MOUNT_POINT" 2>/dev/null | xargs -r sudo kill -KILL
fi
log_success "Prozesse beendet"
;;
"s"|"S")
log_warning "Prozesse werden nicht beendet - Fortfahren auf eigene Gefahr"
;;
*)
log_message "Safe-Eject abgebrochen"
return 1
;;
esac
else
log_success "Keine aktiven Prozesse gefunden"
fi
return 0
}
# Schritt 3: Vollständiger Daten-Sync
perform_full_sync() {
log_message "Führe vollständigen Daten-Sync durch..."
# Globaler Sync
log_message "Globaler Sync..."
sync
# Warte auf Dirty Pages Flush
log_message "Warte auf Buffer-Flush..."
local timeout=30
local count=0
while [ $count -lt $timeout ]; do
dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
writeback_pages=$(cat /proc/meminfo | grep "Writeback:" | awk '{print $2}')
if [ "$dirty_pages" -le 4 ] && [ "$writeback_pages" -le 4 ]; then
log_success "Buffer-Flush abgeschlossen (Dirty: ${dirty_pages}kB, Writeback: ${writeback_pages}kB)"
break
fi
if [ $((count % 5)) -eq 0 ]; then
log_message "Warte auf Buffer-Flush... (Dirty: ${dirty_pages}kB, Writeback: ${writeback_pages}kB)"
fi
sleep 1
count=$((count + 1))
done
if [ $count -ge $timeout ]; then
log_warning "Buffer-Flush Timeout erreicht - Fortfahren..."
fi
# Finaler Sync
log_message "Finaler Sync..."
sync
sleep 2
log_success "Vollständiger Sync abgeschlossen"
}
# Schritt 4: Filesystem Unmount
perform_unmount() {
local device="$1"
log_message "Unmounte Dateisystem: $device"
# Lazy Unmount falls normal unmount fehlschlägt
if ! sudo umount "$MOUNT_POINT" 2>/dev/null; then
log_warning "Normaler Unmount fehlgeschlagen - versuche Lazy Unmount..."
if sudo umount -l "$MOUNT_POINT" 2>/dev/null; then
log_success "Lazy Unmount erfolgreich"
else
log_error "Unmount fehlgeschlagen"
return 1
fi
else
log_success "Unmount erfolgreich"
fi
# Verifikation
if mountpoint -q "$MOUNT_POINT"; then
log_error "Mount-Point noch aktiv nach Unmount"
return 1
else
log_success "Mount-Point erfolgreich getrennt"
return 0
fi
}
# Schritt 5: Hardware-Eject
perform_hardware_eject() {
local device="$1"
local device_base=$(echo "$device" | sed 's/[0-9]*$//')
log_message "Hardware-Eject für Device: $device_base"
# Prüfe ob eject verfügbar ist
if ! command -v eject >/dev/null; then
log_warning "eject Befehl nicht verfügbar - installiere eject..."
sudo apt update && sudo apt install -y eject
fi
# Hardware-Eject durchführen
if sudo eject "$device_base" 2>/dev/null; then
log_success "Hardware-Eject erfolgreich: $device_base"
else
log_warning "Hardware-Eject fehlgeschlagen - möglicherweise nicht unterstützt"
# Alternative: USB-Device über sysfs deaktivieren
usb_device=$(udevadm info --query=path --name="$device_base" 2>/dev/null | sed 's|/block/.*||')
if [ -n "$usb_device" ]; then
log_message "Versuche USB-Device Deaktivierung über sysfs..."
if echo 1 | sudo tee "/sys$usb_device/remove" >/dev/null 2>&1; then
log_success "USB-Device über sysfs deaktiviert"
else
log_warning "USB-Device Deaktivierung fehlgeschlagen"
fi
fi
fi
}
# Schritt 6: Post-Eject Validierung
validate_post_eject() {
local device="$1"
local device_base=$(echo "$device" | sed 's/[0-9]*$//')
log_message "Post-Eject Validierung..."
# Prüfe ob Mount-Point noch aktiv
if mountpoint -q "$MOUNT_POINT"; then
log_error "Mount-Point noch aktiv - Safe-Eject unvollständig"
return 1
fi
# Prüfe ob Device noch sichtbar
sleep 3 # Kurze Wartezeit für System-Update
if [ -b "$device_base" ]; then
log_warning "Device noch im System sichtbar: $device_base"
log_message "Device kann möglicherweise manuell entfernt werden"
else
log_success "Device nicht mehr im System sichtbar"
fi
log_success "Post-Eject Validierung abgeschlossen"
return 0
}
# Safe-Eject Status anzeigen
show_eject_status() {
echo ""
echo "=== Safe-Eject Status ==="
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
echo "✓ Gemountetes Device: $mounted_device"
echo "✓ Hardware Device: $device_base"
# USB-Status prüfen
if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
echo "✓ USB-Device: Ja"
echo "✓ Safe-Eject: Verfügbar"
else
echo "✗ USB-Device: Nein"
echo "✗ Safe-Eject: Nicht verfügbar"
fi
# Aktive Prozesse prüfen
active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
if [ "$active_count" -gt 0 ]; then
echo "! Aktive Prozesse: $active_count"
else
echo "✓ Aktive Prozesse: Keine"
fi
else
echo "✗ Kein Device gemountet"
echo "✗ Safe-Eject: Nicht erforderlich"
fi
echo ""
}
# Hauptfunktion Safe-Eject
safe_eject_main() {
echo "=== USB-C SSD Safe-Eject ==="
echo "Version: 1.0"
echo ""
# Pre-Validierung
device=$(validate_pre_eject)
if [ $? -ne 0 ]; then
return 1
fi
echo "=== Safe-Eject Prozess gestartet für: $device ==="
echo ""
# Aktive Prozesse prüfen
if ! check_active_processes "$device"; then
return 1
fi
# Vollständiger Sync
perform_full_sync
# Unmount
if ! perform_unmount "$device"; then
return 1
fi
# Hardware-Eject
perform_hardware_eject "$device"
# Post-Validierung
validate_post_eject "$device"
echo ""
echo "=== Safe-Eject abgeschlossen ==="
echo "USB-C SSD kann jetzt sicher entfernt werden."
echo ""
return 0
}
# Hauptfunktion
main() {
case "${1:-eject}" in
"eject")
safe_eject_main
;;
"status")
show_eject_status
;;
*)
echo "Verwendung: $0 {eject|status}"
echo ""
echo "Befehle:"
echo " eject - Sichere SSD-Entfernung durchführen"
echo " status - Safe-Eject Status anzeigen"
;;
esac
}
# Script ausführen
main "$@"

264
scripts/ssd-management/README.md Normal file
View File

@@ -0,0 +1,264 @@
# SSD Management Module
## Übersicht
Das SSD Management Module verwaltet den kompletten Lifecycle von USB-C SSDs - von Mount-Operationen bis zur sicheren Entfernung. Es bietet flexibles Mounting mit konstantem Mount-Point und umfassende Sicherheitsfeatures.
## Hauptkomponenten
### `ssd-mount-manager.sh`
**Zweck**: Flexibles Mount-Lifecycle Management mit konstantem Mount-Point
**Hauptfunktionen**:
- Automatisches Mounting auf `/mnt/ssd-storage`
- NTFS-Kompatibilität mit optimierten Mount-Optionen
- UUID-basierte Geräte-Zuordnung
- Mount-Status Überwachung
- Fehlerbehandlung und Recovery
### `ssd-safe-eject.sh`
**Zweck**: Sichere Hardware-Entfernung mit Datenintegritäts-Schutz
**Hauptfunktionen**:
- Buffer-Flush Überwachung
- Prozess-Detection vor Eject
- Hardware-Eject Funktionalität
- Cleanup von Mount-Points
- Audit-Logging
## Verwendung
### Mount-Manager
#### Grundlegende Mount-Operationen
```bash
# Automatisches Mounting der erkannten SSD
./ssd-mount-manager.sh mount
# Spezifische SSD mounten
./ssd-mount-manager.sh mount --device /dev/sdb1
# Read-Only Mount für kritische Prüfungen
./ssd-mount-manager.sh mount --readonly
# Mount-Status prüfen
./ssd-mount-manager.sh status
```
#### Erweiterte Mount-Optionen
```bash
# Custom Mount-Point
./ssd-mount-manager.sh mount --mountpoint /custom/path
# Spezifische NTFS-Optionen
./ssd-mount-manager.sh mount --options "uid=1000,gid=1000,umask=022"
# Automatisches Remounting
./ssd-mount-manager.sh remount
```
### Safe-Eject
#### Sichere Entfernung
```bash
# Standard Safe-Eject
./ssd-safe-eject.sh
# Force-Eject (bei hängenden Prozessen)
./ssd-safe-eject.sh --force
# Eject mit Prozess-Übersicht
./ssd-safe-eject.sh --show-processes
# Nur Unmount (ohne Hardware-Eject)
./ssd-safe-eject.sh --unmount-only
```
#### Erweiterte Eject-Optionen
```bash
# Timeout für Buffer-Flush
./ssd-safe-eject.sh --timeout 60
# Verbose-Modus
./ssd-safe-eject.sh --verbose
# Dry-Run (Simulation)
./ssd-safe-eject.sh --dry-run
```
## Konfiguration
### Mount-Manager Konfiguration
```bash
# Standard Mount-Point
export SSD_MOUNT_POINT="/mnt/ssd-storage"
# Standard NTFS-Optionen
export SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022,windows_names"
# Timeout für Mount-Operationen
export SSD_MOUNT_TIMEOUT=30
```
### Safe-Eject Konfiguration
```bash
# Buffer-Flush Timeout
export SSD_EJECT_TIMEOUT=60
# Prozess-Kill Timeout
export SSD_PROCESS_TIMEOUT=10
# Hardware-Eject aktivieren
export SSD_HARDWARE_EJECT=true
```
## Mount-Point Management
### Konstanter Mount-Point
Das System verwendet einen konstanten logischen Mount-Point (`/mnt/ssd-storage`), unabhängig von der physischen SSD:
```bash
# Immer derselbe Pfad, verschiedene SSDs
/mnt/ssd-storage/ # SSD A
/mnt/ssd-storage/ # SSD B (nach Wechsel)
/mnt/ssd-storage/ # SSD C (nach Wechsel)
```
### SMB-Freigabe Vorbereitung
```bash
# Optimierte Berechtigungen für SMB
./ssd-mount-manager.sh mount --smb-ready
# Automatische SMB-Konfiguration
./ssd-mount-manager.sh mount --configure-smb
```
## Sicherheitsfeatures
### Prozess-Detection
```bash
# Aktive Prozesse vor Eject anzeigen
lsof /mnt/ssd-storage
# Automatische Prozess-Beendigung
./ssd-safe-eject.sh --kill-processes
```
### Buffer-Flush Überwachung
```bash
# Manueller Sync vor Eject
sync && echo 3 > /proc/sys/vm/drop_caches
# Automatische Buffer-Überwachung
./ssd-safe-eject.sh --monitor-buffers
```
### Datenintegritäts-Prüfung
```bash
# Filesystem-Check vor Mount
./ssd-mount-manager.sh mount --fsck
# Readonly-Test vor produktivem Mount
./ssd-mount-manager.sh test-mount
```
## Fehlerbehandlung
### Mount-Fehler
```bash
# Häufige Mount-Probleme diagnostizieren
./ssd-mount-manager.sh diagnose
# Mount-Point Cleanup
./ssd-mount-manager.sh cleanup
# Recovery-Modus
./ssd-mount-manager.sh recover
```
### Eject-Fehler
```bash
# Hängende Prozesse identifizieren
./ssd-safe-eject.sh --list-blocking-processes
# Force-Unmount
./ssd-safe-eject.sh --force-unmount
# Hardware-Reset
./ssd-safe-eject.sh --hardware-reset
```
## Logging und Monitoring
### Log-Konfiguration
```bash
# Log-Level setzen
export SSD_LOG_LEVEL=INFO
# Log-Datei konfigurieren
export SSD_LOG_FILE="/var/log/ssd-management.log"
# Syslog-Integration
export SSD_USE_SYSLOG=true
```
### Monitoring-Integration
```bash
# Prometheus-Metriken
./ssd-mount-manager.sh --metrics
# Status-JSON für Monitoring
./ssd-mount-manager.sh status --json
```
## Systemd-Integration
### Service-Templates
```bash
# Mount-Service aktivieren
sudo systemctl enable ssd-mount@.service
# Auto-Mount bei USB-Events
sudo systemctl enable ssd-automount.service
```
### Service-Konfiguration
```ini
# /etc/systemd/system/ssd-mount@.service
[Unit]
Description=SSD Mount Manager for %i
After=local-fs.target
[Service]
Type=oneshot
ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --device %i
ExecStop=/usr/local/bin/ssd-safe-eject.sh --device %i
RemainAfterExit=yes
[Install]
WantedBy=multi-user.target
```
## Best Practices
### Produktionsumgebung
1. **Immer Safe-Eject verwenden** statt direkter `umount`
2. **Mount-Status überwachen** vor kritischen Operationen
3. **Logs regelmäßig prüfen** für Anomalien
4. **Backup vor Mount-Operationen** bei kritischen Daten
5. **Systemd-Services nutzen** für automatisches Management
### Entwicklungsumgebung
1. **Dry-Run Modus** für Tests verwenden
2. **Verbose-Logging** für Debugging aktivieren
3. **Recovery-Scripte** bereithalten
4. **Test-SSDs** für Entwicklung verwenden
## Changelog
### Version 0.1.0
- Initiale Implementierung
- Mount-Manager mit konstantem Mount-Point
- Safe-Eject mit Prozess-Detection
- NTFS-Optimierungen
- Systemd-Integration

347
scripts/ssd-management/ssd-mount-manager.sh Normal file
View File

@@ -0,0 +1,347 @@
#!/bin/bash
# ssd-mount-manager.sh - USB-C SSD Mount Management
# Zweck: Flexibles Mounting verschiedener SSDs auf konstanten Mount-Point
set -e
# Konfiguration
MOUNT_POINT="/mnt/ssd-storage"
CONFIG_FILE="/etc/ssd-mount.conf"
LOG_FILE="/var/log/ssd-mount.log"
# Logging-Funktion
log_message() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | sudo tee -a "$LOG_FILE"
echo "$1"
}
# Konfigurationsdatei erstellen
create_config() {
log_message "Erstelle Konfigurationsdatei..."
sudo tee "$CONFIG_FILE" > /dev/null << EOF
# SSD Mount Manager Konfiguration
# Erstellt: $(date)
# Standard Mount-Point
MOUNT_POINT="$MOUNT_POINT"
# Standard Mount-Optionen für NTFS
MOUNT_OPTIONS="defaults,uid=1000,gid=1000,umask=002,fmask=111,noatime"
# Automatisches Unmounting bei Shutdown
AUTO_UMOUNT=true
# Backup der letzten gemounteten SSD
LAST_DEVICE=""
LAST_UUID=""
EOF
log_message "Konfiguration erstellt: $CONFIG_FILE"
}
# Konfiguration laden
load_config() {
if [ -f "$CONFIG_FILE" ]; then
source "$CONFIG_FILE"
else
create_config
source "$CONFIG_FILE"
fi
}
# Mount-Point vorbereiten
prepare_mount_point() {
log_message "Bereite Mount-Point vor: $MOUNT_POINT"
if [ ! -d "$MOUNT_POINT" ]; then
sudo mkdir -p "$MOUNT_POINT"
log_message "Mount-Point erstellt: $MOUNT_POINT"
fi
sudo chown root:root "$MOUNT_POINT"
sudo chmod 755 "$MOUNT_POINT"
log_message "Mount-Point Berechtigungen gesetzt"
}
# Aktuelle Mounts prüfen
check_current_mount() {
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
log_message "Aktuell gemountet: $mounted_device auf $MOUNT_POINT"
return 0
else
log_message "Kein Device auf $MOUNT_POINT gemountet"
return 1
fi
}
# Device unmounten
unmount_device() {
log_message "Unmounte Device von $MOUNT_POINT..."
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
log_message "Unmounte $mounted_device..."
sudo umount "$MOUNT_POINT"
log_message "Device erfolgreich unmountet"
# Letztes Device in Config speichern
update_last_device ""
else
log_message "Kein Device zum Unmounten gefunden"
fi
}
# Safe-Eject Funktion
safe_eject_device() {
log_message "Starte Safe-Eject Prozess..."
# Externes Safe-Eject Script aufrufen
if command -v ssd-safe-eject >/dev/null; then
ssd-safe-eject eject
else
# Fallback: Integrierte Safe-Eject Funktionalität
perform_integrated_safe_eject
fi
}
# Integrierte Safe-Eject Funktionalität
perform_integrated_safe_eject() {
if ! mountpoint -q "$MOUNT_POINT"; then
log_message "Keine SSD gemountet - Safe-Eject nicht erforderlich"
return 1
fi
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
log_message "Safe-Eject für $mounted_device..."
# Vollständiger Sync
log_message "Führe Sync durch..."
sync
sleep 2
# Unmount
log_message "Unmounte Device..."
if sudo umount "$MOUNT_POINT"; then
log_success "Unmount erfolgreich"
else
log_error "Unmount fehlgeschlagen"
return 1
fi
# Hardware-Eject
log_message "Hardware-Eject..."
if command -v eject >/dev/null; then
if sudo eject "$device_base" 2>/dev/null; then
log_success "Hardware-Eject erfolgreich"
else
log_warning "Hardware-Eject fehlgeschlagen"
fi
else
log_warning "eject Befehl nicht verfügbar"
fi
# Finaler Sync
sync
log_success "Safe-Eject abgeschlossen - SSD kann entfernt werden"
update_last_device ""
}
# Device mounten
mount_device() {
local device="$1"
if [ -z "$device" ]; then
log_message "Fehler: Kein Device angegeben"
return 1
fi
if [ ! -b "$device" ]; then
log_message "Fehler: Device $device existiert nicht"
return 1
fi
log_message "Mounte Device: $device"
# Prüfe ob bereits etwas gemountet ist
if mountpoint -q "$MOUNT_POINT"; then
log_message "Mount-Point bereits belegt - unmounte zuerst..."
unmount_device
fi
# Device mounten
log_message "Mounte $device auf $MOUNT_POINT mit Optionen: $MOUNT_OPTIONS"
sudo mount -t ntfs-3g -o "$MOUNT_OPTIONS" "$device" "$MOUNT_POINT"
if [ $? -eq 0 ]; then
log_message "Mount erfolgreich: $device auf $MOUNT_POINT"
# Device-Info speichern
device_uuid=$(sudo blkid -s UUID -o value "$device")
update_last_device "$device" "$device_uuid"
# Mount-Status anzeigen
show_mount_status
return 0
else
log_message "Fehler beim Mounten von $device"
return 1
fi
}
# Letztes Device in Config updaten
update_last_device() {
local device="$1"
local uuid="$2"
sudo sed -i "s|LAST_DEVICE=.*|LAST_DEVICE=\"$device\"|" "$CONFIG_FILE"
sudo sed -i "s|LAST_UUID=.*|LAST_UUID=\"$uuid\"|" "$CONFIG_FILE"
}
# Mount-Status anzeigen
show_mount_status() {
echo ""
echo "=== Mount-Status ==="
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
echo "✓ Gemountet: $mounted_device"
echo "✓ Mount-Point: $MOUNT_POINT"
# Speicherplatz anzeigen
df -h "$MOUNT_POINT"
echo ""
# Device-Details
device_uuid=$(sudo blkid -s UUID -o value "$mounted_device")
device_label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null || echo "Kein Label")
echo "UUID: $device_uuid"
echo "Label: $device_label"
# Zugriffstest
if [ -r "$MOUNT_POINT" ]; then
echo "✓ Lesezugriff: OK"
else
echo "✗ Lesezugriff: Fehler"
fi
if [ -w "$MOUNT_POINT" ]; then
echo "✓ Schreibzugriff: OK"
else
echo "✗ Schreibzugriff: Fehler"
fi
else
echo "✗ Kein Device gemountet auf $MOUNT_POINT"
fi
echo ""
}
# Verfügbare NTFS-Devices auflisten
list_ntfs_devices() {
echo "=== Verfügbare NTFS-Devices ==="
lsblk -f | grep ntfs | while IFS= read -r line; do
device=$(echo "$line" | awk '{print "/dev/" $1}')
uuid=$(echo "$line" | awk '{print $3}')
label=$(echo "$line" | awk '{print $4}')
size=$(lsblk -o SIZE "$device" 2>/dev/null | tail -1)
echo "$device | $size | UUID: $uuid | Label: $label"
done
echo ""
}
# Automatisches Device-Detection
auto_detect_device() {
log_message "Automatische Device-Erkennung..."
# Suche nach NTFS-Partitionen auf USB-Devices
for device in /dev/sd[a-z][0-9]*; do
if [ -b "$device" ]; then
fstype=$(lsblk -o FSTYPE "$device" 2>/dev/null | tail -1 | xargs)
if [ "$fstype" = "ntfs" ]; then
size=$(lsblk -b -o SIZE "$device" 2>/dev/null | tail -1)
size_gb=$((size / 1024 / 1024 / 1024))
# Nur Devices > 100GB berücksichtigen (typisch für SSDs)
if [ $size_gb -gt 100 ]; then
log_message "NTFS-SSD gefunden: $device (${size_gb}GB)"
echo "$device"
return 0
fi
fi
fi
done
log_message "Keine geeignete NTFS-SSD gefunden"
return 1
}
# Hauptfunktion
main() {
echo "=== USB-C SSD Mount Manager ==="
echo "Version: 1.0"
echo ""
load_config
prepare_mount_point
case "${1:-status}" in
"mount")
if [ -n "$2" ]; then
mount_device "$2"
else
# Auto-Detection
auto_device=$(auto_detect_device)
if [ -n "$auto_device" ]; then
echo "Auto-erkanntes Device: $auto_device"
echo "Mounten? (y/n)"
read -r response
if [ "$response" = "y" ] || [ "$response" = "Y" ]; then
mount_device "$auto_device"
fi
else
echo "Kein Device auto-erkannt. Verfügbare Devices:"
list_ntfs_devices
fi
fi
;;
"unmount"|"umount")
unmount_device
;;
"safe-eject"|"eject")
safe_eject_device
;;
"status")
show_mount_status
;;
"list")
list_ntfs_devices
;;
"remount")
if check_current_mount; then
unmount_device
sleep 2
fi
auto_device=$(auto_detect_device)
if [ -n "$auto_device" ]; then
mount_device "$auto_device"
fi
;;
*)
echo "Verwendung: $0 {mount [device]|unmount|safe-eject|status|list|remount}"
echo ""
echo "Befehle:"
echo " mount [device] - Device mounten (auto-detect wenn kein device)"
echo " unmount - Device unmounten (einfach)"
echo " safe-eject - Sichere USB-C SSD Entfernung mit Hardware-Eject"
echo " status - Mount-Status anzeigen"
echo " list - Verfügbare NTFS-Devices auflisten"
echo " remount - Unmount + Auto-detect + Mount"
;;
esac
}
# Script ausführen
main "$@"

349
scripts/ssd-testing/README.md Normal file
View File

@@ -0,0 +1,349 @@
# SSD Testing Module
## Übersicht
Das SSD Testing Module bietet umfassende Qualitätssicherung für USB-C SSDs mit 11 spezialisierten Tests, Performance-Messung und SMB-Bereitschaftsprüfung. Es gewährleistet die Zuverlässigkeit und Kompatibilität der Storage-Infrastruktur.
## Hauptkomponenten
### `ssd-test-suite.sh`
**Zweck**: Umfassende Qualitätssicherung und Performance-Messung
**Test-Kategorien**:
- **Hardware-Tests**: Connectivity, Power, Temperature
- **Filesystem-Tests**: NTFS-Integrität, Permissions, Capacity
- **Performance-Tests**: Read/Write Speed, IOPS, Latency
- **Integration-Tests**: SMB-Bereitschaft, Mount-Stabilität
- **Security-Tests**: Access-Control, Encryption-Support
## Test-Suite Übersicht
### Die 11 Kern-Tests
| Test-ID | Name | Zweck | Dauer |
|---------|------|-------|-------|
| `T01` | **Hardware Detection** | USB-C Connectivity und Device-Recognition | 5s |
| `T02` | **NTFS Filesystem** | Dateisystem-Integrität und Kompatibilität | 10s |
| `T03` | **Mount Stability** | Mount/Unmount Zyklen und Stabilität | 30s |
| `T04` | **Read Performance** | Sequential und Random Read-Geschwindigkeit | 60s |
| `T05` | **Write Performance** | Sequential und Random Write-Geschwindigkeit | 60s |
| `T06` | **File Operations** | Create, Copy, Delete, Rename Operationen | 45s |
| `T07` | **Permission System** | Linux-Permissions und NTFS-ACLs | 15s |
| `T08` | **SMB Readiness** | SMB-Freigabe Kompatibilität und Performance | 30s |
| `T09` | **Capacity Verification** | Verfügbarer Speicher und Fragmentierung | 20s |
| `T10` | **Error Handling** | Fehlerbehandlung und Recovery-Mechanismen | 25s |
| `T11` | **Security Scan** | Access-Control und Encryption-Support | 40s |
## Verwendung
### Grundlegende Test-Ausführung
```bash
# Alle Tests ausführen
./ssd-test-suite.sh all
# Spezifischen Test ausführen
./ssd-test-suite.sh T01
# Test-Kategorie ausführen
./ssd-test-suite.sh --category hardware
./ssd-test-suite.sh --category performance
./ssd-test-suite.sh --category integration
```
### Erweiterte Test-Optionen
```bash
# Schnelle Tests (nur kritische)
./ssd-test-suite.sh --quick
# Umfassende Tests (alle mit erweiterten Parametern)
./ssd-test-suite.sh --comprehensive
# Performance-Benchmark
./ssd-test-suite.sh --benchmark
# Kontinuierliche Tests
./ssd-test-suite.sh --continuous --interval 300
```
### Output-Formate
```bash
# Standard-Output (Human-readable)
./ssd-test-suite.sh all
# JSON-Output für Automation
./ssd-test-suite.sh all --output json
# XML-Report für CI/CD
./ssd-test-suite.sh all --output xml
# CSV für Datenanalyse
./ssd-test-suite.sh all --output csv
```
## Test-Konfiguration
### Environment Variables
```bash
# Test-Timeout (Sekunden)
export SSD_TEST_TIMEOUT=300
# Performance-Test Größe (MB)
export SSD_TEST_SIZE=100
# Test-Wiederholungen
export SSD_TEST_ITERATIONS=3
# Benchmark-Modus
export SSD_BENCHMARK_MODE=true
```
### Konfigurationsdatei
```bash
# /etc/ssd-test/config.conf
TEST_MOUNT_POINT="/mnt/ssd-storage"
TEST_DATA_SIZE="100MB"
PERFORMANCE_THRESHOLD_READ="50MB/s"
PERFORMANCE_THRESHOLD_WRITE="30MB/s"
SMB_TEST_ENABLED=true
SECURITY_SCAN_ENABLED=true
```
## Test-Details
### Hardware-Tests (T01-T03)
#### T01: Hardware Detection
```bash
# Prüft USB-C Connectivity
- Device-Erkennung im System
- USB-Version und Geschwindigkeit
- Power-Management Status
- Device-Descriptor Validierung
```
#### T02: NTFS Filesystem
```bash
# Validiert NTFS-Kompatibilität
- Dateisystem-Typ Verifikation
- NTFS-Version Kompatibilität
- Journal-Status Prüfung
- Cluster-Size Optimierung
```
#### T03: Mount Stability
```bash
# Testet Mount/Unmount Zyklen
- 10x Mount/Unmount Zyklen
- Concurrent-Access Tests
- Mount-Option Validierung
- Recovery nach Fehlern
```
### Performance-Tests (T04-T06)
#### T04: Read Performance
```bash
# Sequential Read Test
dd if=/mnt/ssd-storage/testfile of=/dev/null bs=1M count=100
# Random Read Test (4K Blocks)
fio --name=random-read --ioengine=libaio --rw=randread --bs=4k --size=100M
```
#### T05: Write Performance
```bash
# Sequential Write Test
dd if=/dev/zero of=/mnt/ssd-storage/testfile bs=1M count=100
# Random Write Test (4K Blocks)
fio --name=random-write --ioengine=libaio --rw=randwrite --bs=4k --size=100M
```
#### T06: File Operations
```bash
# Standard File-Operations
- 1000 kleine Dateien erstellen (1KB)
- 100 mittlere Dateien erstellen (1MB)
- 10 große Dateien erstellen (10MB)
- Copy, Move, Delete Operationen
- Symlink und Hardlink Tests
```
### Integration-Tests (T07-T09)
#### T07: Permission System
```bash
# Linux-Permissions testen
chmod 755 /mnt/ssd-storage/testdir
chown user:group /mnt/ssd-storage/testfile
# NTFS-ACL Kompatibilität
setfacl -m u:user:rwx /mnt/ssd-storage/testdir
```
#### T08: SMB Readiness
```bash
# SMB-Kompatibilität prüfen
- Windows-Filename Kompatibilität
- Extended Attributes Support
- Case-Sensitivity Tests
- Unicode-Filename Support
- SMB-Performance Simulation
```
#### T09: Capacity Verification
```bash
# Speicher-Analyse
df -h /mnt/ssd-storage
du -sh /mnt/ssd-storage/*
# Fragmentierung prüfen
fsck.ntfs -f /dev/sdb1
```
### Security-Tests (T10-T11)
#### T10: Error Handling
```bash
# Fehlerbehandlung testen
- Disk-Full Simulation
- Permission-Denied Scenarios
- Network-Interruption (bei SMB)
- Hardware-Disconnect Simulation
```
#### T11: Security Scan
```bash
# Security-Features prüfen
- Access-Control Lists (ACLs)
- Encryption-Support Detection
- Secure-Delete Capabilities
- Audit-Trail Funktionalität
```
## Benchmark-Modus
### Performance-Metriken
```bash
# Detaillierte Performance-Analyse
./ssd-test-suite.sh --benchmark --detailed
# Vergleich mit Referenz-Werten
./ssd-test-suite.sh --benchmark --compare baseline.json
# Performance-Trend Analyse
./ssd-test-suite.sh --benchmark --trend --days 30
```
### Benchmark-Output
```json
{
"device": "/dev/sdb1",
"timestamp": "2025-08-07T19:10:00Z",
"performance": {
"sequential_read": "120 MB/s",
"sequential_write": "85 MB/s",
"random_read_4k": "15000 IOPS",
"random_write_4k": "8000 IOPS",
"latency_avg": "2.5ms"
},
"health": {
"temperature": "45°C",
"wear_level": "2%",
"error_count": 0
}
}
```
## CI/CD Integration
### Jenkins Pipeline
```groovy
pipeline {
agent any
stages {
stage('SSD Tests') {
steps {
sh './ssd-test-suite.sh all --output xml'
publishTestResults testResultsPattern: 'ssd-test-results.xml'
}
}
}
}
```
### GitHub Actions
```yaml
name: SSD Tests
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run SSD Tests
run: ./ssd-test-suite.sh all --output json
```
## Monitoring Integration
### Prometheus-Metriken
```bash
# Metriken exportieren
./ssd-test-suite.sh --prometheus-metrics
# Grafana-Dashboard
# Siehe examples/monitoring/grafana-dashboard.json
```
### Alerting
```bash
# Performance-Alerts
if [ $READ_SPEED -lt 50 ]; then
alert "SSD Read Performance below threshold"
fi
# Health-Alerts
if [ $ERROR_COUNT -gt 0 ]; then
alert "SSD Errors detected"
fi
```
## Troubleshooting
### Häufige Test-Fehler
1. **T01 Failed**: USB-Verbindung prüfen, Treiber aktualisieren
2. **T04/T05 Slow**: SSD-Health prüfen, USB-Port wechseln
3. **T08 Failed**: SMB-Packages installieren, Firewall prüfen
### Debug-Modus
```bash
# Erweiterte Diagnose
./ssd-test-suite.sh all --debug --verbose
# Test-Logs analysieren
tail -f /var/log/ssd-test.log
```
## Best Practices
### Produktionsumgebung
1. **Regelmäßige Tests** (täglich/wöchentlich) einrichten
2. **Performance-Baselines** etablieren und überwachen
3. **Test-Ergebnisse archivieren** für Trend-Analyse
4. **Automatische Alerts** bei Test-Fehlern konfigurieren
### Entwicklungsumgebung
1. **Quick-Tests** vor Code-Changes ausführen
2. **Comprehensive-Tests** vor Releases durchführen
3. **Benchmark-Vergleiche** für Performance-Regression
4. **Test-Coverage** für alle SSD-Typen sicherstellen
## Changelog
### Version 0.1.0
- 11 umfassende Test-Kategorien
- Performance-Benchmark Integration
- SMB-Bereitschaftsprüfung
- CI/CD Pipeline Support
- Prometheus-Metriken Export

419
scripts/ssd-testing/ssd-test-suite.sh Normal file
View File

@@ -0,0 +1,419 @@
#!/bin/bash
# ssd-test-suite.sh - USB-C SSD Test Suite
# Zweck: Umfassende Tests für gemountete SSDs
set -e
# Konfiguration
MOUNT_POINT="/mnt/ssd-storage"
TEST_DIR="$MOUNT_POINT/.ssd-tests"
LOG_FILE="/var/log/ssd-tests.log"
# Farben für Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Logging und Ausgabe
log_test() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - TEST: $1" >> "$LOG_FILE"
echo -e "${BLUE}[TEST]${NC} $1"
}
log_success() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" >> "$LOG_FILE"
echo -e "${GREEN}[✓]${NC} $1"
}
log_warning() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" >> "$LOG_FILE"
echo -e "${YELLOW}[!]${NC} $1"
}
log_error() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" >> "$LOG_FILE"
echo -e "${RED}[✗]${NC} $1"
}
# Test 1: Mount-Status prüfen
test_mount_status() {
log_test "Prüfe Mount-Status..."
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
log_success "SSD ist gemountet: $mounted_device auf $MOUNT_POINT"
return 0
else
log_error "Keine SSD auf $MOUNT_POINT gemountet"
return 1
fi
}
# Test 2: Dateisystem-Typ prüfen
test_filesystem_type() {
log_test "Prüfe Dateisystem-Typ..."
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
fs_type=$(lsblk -o FSTYPE "$mounted_device" | tail -1 | xargs)
if [ "$fs_type" = "ntfs" ]; then
log_success "Dateisystem: NTFS ✓"
return 0
else
log_warning "Dateisystem: $fs_type (erwartet: NTFS)"
return 1
fi
else
log_error "Kein gemountetes Device für Filesystem-Test"
return 1
fi
}
# Test 3: Lesezugriff prüfen
test_read_access() {
log_test "Prüfe Lesezugriff..."
if [ -r "$MOUNT_POINT" ]; then
# Versuche Verzeichnis-Listing
file_count=$(ls -1 "$MOUNT_POINT" 2>/dev/null | wc -l)
log_success "Lesezugriff OK - $file_count Objekte gefunden"
return 0
else
log_error "Kein Lesezugriff auf $MOUNT_POINT"
return 1
fi
}
# Test 4: Schreibzugriff prüfen
test_write_access() {
log_test "Prüfe Schreibzugriff..."
test_file="$MOUNT_POINT/.write_test_$(date +%s).tmp"
if echo "Write test - $(date)" > "$test_file" 2>/dev/null; then
if [ -f "$test_file" ]; then
content=$(cat "$test_file")
rm -f "$test_file"
log_success "Schreibzugriff OK"
return 0
else
log_error "Datei konnte nicht erstellt werden"
return 1
fi
else
log_error "Kein Schreibzugriff auf $MOUNT_POINT"
return 1
fi
}
# Test 5: Verzeichnis-Operationen
test_directory_operations() {
log_test "Prüfe Verzeichnis-Operationen..."
# Test-Verzeichnis erstellen
if mkdir -p "$TEST_DIR" 2>/dev/null; then
log_success "Verzeichnis erstellen: OK"
# Test-Unterverzeichnis
sub_dir="$TEST_DIR/subdir_$(date +%s)"
if mkdir "$sub_dir" 2>/dev/null; then
log_success "Unterverzeichnis erstellen: OK"
# Verzeichnis löschen
if rmdir "$sub_dir" 2>/dev/null; then
log_success "Verzeichnis löschen: OK"
else
log_warning "Verzeichnis löschen: Fehler"
fi
else
log_warning "Unterverzeichnis erstellen: Fehler"
fi
# Test-Verzeichnis aufräumen
rmdir "$TEST_DIR" 2>/dev/null || log_warning "Test-Verzeichnis Cleanup: Fehler"
return 0
else
log_error "Verzeichnis-Operationen: Fehler"
return 1
fi
}
# Test 6: Performance-Test (Schreibgeschwindigkeit)
test_write_performance() {
log_test "Prüfe Schreibperformance..."
test_file="$MOUNT_POINT/.performance_test_$(date +%s).tmp"
# 100MB Test-Datei schreiben
start_time=$(date +%s.%N)
if dd if=/dev/zero of="$test_file" bs=1M count=100 2>/dev/null; then
end_time=$(date +%s.%N)
duration=$(echo "$end_time - $start_time" | bc -l 2>/dev/null || echo "0")
if [ -f "$test_file" ]; then
file_size=$(stat -c%s "$test_file" 2>/dev/null || echo "0")
rm -f "$test_file"
if command -v bc >/dev/null && [ "$duration" != "0" ]; then
speed=$(echo "scale=2; ($file_size / 1024 / 1024) / $duration" | bc -l)
log_success "Schreibgeschwindigkeit: ${speed} MB/s"
else
log_success "Performance-Test abgeschlossen (Zeit: ${duration}s)"
fi
else
log_warning "Performance-Test: Datei nicht erstellt"
fi
return 0
else
log_error "Performance-Test: Schreibfehler"
return 1
fi
}
# Test 7: Speicherplatz prüfen
test_disk_space() {
log_test "Prüfe Speicherplatz..."
if mountpoint -q "$MOUNT_POINT"; then
space_info=$(df -h "$MOUNT_POINT" | tail -1)
total=$(echo "$space_info" | awk '{print $2}')
used=$(echo "$space_info" | awk '{print $3}')
available=$(echo "$space_info" | awk '{print $4}')
usage=$(echo "$space_info" | awk '{print $5}')
log_success "Speicherplatz - Total: $total, Belegt: $used, Verfügbar: $available, Auslastung: $usage"
# Warnung bei hoher Auslastung
usage_percent=$(echo "$usage" | sed 's/%//')
if [ "$usage_percent" -gt 90 ]; then
log_warning "Hohe Speicherauslastung: $usage"
fi
return 0
else
log_error "Speicherplatz-Check: Kein gemountetes Device"
return 1
fi
}
# Test 8: NTFS-spezifische Eigenschaften
test_ntfs_features() {
log_test "Prüfe NTFS-Features..."
if mountpoint -q "$MOUNT_POINT"; then
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
# UUID prüfen
uuid=$(sudo blkid -s UUID -o value "$mounted_device" 2>/dev/null)
if [ -n "$uuid" ]; then
log_success "NTFS UUID: $uuid"
else
log_warning "NTFS UUID nicht ermittelbar"
fi
# Label prüfen
label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null)
if [ -n "$label" ]; then
log_success "NTFS Label: $label"
else
log_success "NTFS Label: (kein Label gesetzt)"
fi
# NTFS-spezifische Mount-Optionen prüfen
mount_options=$(mount | grep "$MOUNT_POINT" | sed 's/.*(\(.*\)).*/\1/')
log_success "Mount-Optionen: $mount_options"
return 0
else
log_error "NTFS-Features: Kein gemountetes Device"
return 1
fi
}
# Test 9: SMB-Bereitschaft prüfen
test_smb_readiness() {
log_test "Prüfe SMB-Bereitschaft..."
# Benutzer-/Gruppen-Zugriff prüfen
user_id=$(id -u)
group_id=$(id -g)
if [ -r "$MOUNT_POINT" ] && [ -w "$MOUNT_POINT" ]; then
log_success "Benutzer-Zugriff (UID: $user_id, GID: $group_id): OK"
# Test-Datei für SMB-Zugriff erstellen
smb_test_file="$MOUNT_POINT/.smb_test_$(date +%s).txt"
if echo "SMB Test - $(date)" > "$smb_test_file" 2>/dev/null; then
if [ -f "$smb_test_file" ]; then
rm -f "$smb_test_file"
log_success "SMB-Test-Datei: OK"
fi
fi
return 0
else
log_error "SMB-Bereitschaft: Unzureichende Zugriffsrechte"
return 1
fi
}
# Test 10: Safe-Eject Bereitschaft prüfen
test_safe_eject_readiness() {
log_test "Prüfe Safe-Eject Bereitschaft..."
if ! mountpoint -q "$MOUNT_POINT"; then
log_warning "Safe-Eject: Kein Device gemountet"
return 1
fi
mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
# USB-Device prüfen
if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
log_success "USB-Device erkannt: Safe-Eject verfügbar"
# eject Befehl prüfen
if command -v eject >/dev/null; then
log_success "eject Befehl: Verfügbar"
else
log_warning "eject Befehl: Nicht installiert (installierbar mit: sudo apt install eject)"
fi
# Aktive Prozesse prüfen
active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
if [ "$active_count" -eq 0 ]; then
log_success "Aktive Prozesse: Keine (Safe-Eject bereit)"
else
log_warning "Aktive Prozesse: $active_count (Safe-Eject mit Vorsicht)"
fi
# Buffer-Status prüfen
dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
if [ "$dirty_pages" -le 100 ]; then
log_success "System Buffer: Sauber (${dirty_pages}kB)"
else
log_warning "System Buffer: Dirty Pages vorhanden (${dirty_pages}kB)"
fi
return 0
else
log_warning "Kein USB-Device - Safe-Eject nicht erforderlich"
return 1
fi
}
# Test 11: Gesamtsystem-Status
test_system_status() {
log_test "Prüfe Gesamtsystem-Status..."
# NTFS-3G prüfen
if command -v mount.ntfs-3g >/dev/null; then
log_success "NTFS-3G: Installiert"
else
log_error "NTFS-3G: Nicht installiert"
fi
# Kernel-Module prüfen
if lsmod | grep -q ntfs; then
log_success "NTFS Kernel-Modul: Geladen"
else
log_warning "NTFS Kernel-Modul: Nicht erkannt"
fi
# System-Load prüfen
load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
log_success "System Load: $load_avg"
return 0
}
# Alle Tests ausführen
run_all_tests() {
echo "=== USB-C SSD Test Suite ==="
echo "Version: 1.0"
echo "Zeitstempel: $(date)"
echo "Mount-Point: $MOUNT_POINT"
echo ""
total_tests=11
passed_tests=0
# Test-Log initialisieren
echo "=== Test-Session gestartet: $(date) ===" >> "$LOG_FILE"
# Tests ausführen
test_mount_status && ((passed_tests++))
test_filesystem_type && ((passed_tests++))
test_read_access && ((passed_tests++))
test_write_access && ((passed_tests++))
test_directory_operations && ((passed_tests++))
test_write_performance && ((passed_tests++))
test_disk_space && ((passed_tests++))
test_ntfs_features && ((passed_tests++))
test_smb_readiness && ((passed_tests++))
test_safe_eject_readiness && ((passed_tests++))
test_system_status && ((passed_tests++))
echo ""
echo "=== Test-Zusammenfassung ==="
echo "Tests bestanden: $passed_tests/$total_tests"
if [ $passed_tests -eq $total_tests ]; then
log_success "Alle Tests bestanden - SSD ist bereit für SMB-Freigabe!"
echo "=== ALLE TESTS BESTANDEN ===" >> "$LOG_FILE"
return 0
else
failed_tests=$((total_tests - passed_tests))
log_warning "$failed_tests Tests fehlgeschlagen - Überprüfung erforderlich"
echo "=== $failed_tests TESTS FEHLGESCHLAGEN ===" >> "$LOG_FILE"
return 1
fi
}
# Hauptfunktion
main() {
case "${1:-all}" in
"all")
run_all_tests
;;
"quick")
echo "=== Quick Test ==="
test_mount_status && test_read_access && test_write_access
;;
"mount")
test_mount_status
;;
"access")
test_read_access && test_write_access
;;
"performance")
test_write_performance
;;
"smb")
test_smb_readiness
;;
"safe-eject"|"eject")
test_safe_eject_readiness
;;
*)
echo "Verwendung: $0 {all|quick|mount|access|performance|smb|safe-eject}"
echo ""
echo "Tests:"
echo " all - Alle Tests ausführen (empfohlen)"
echo " quick - Schnelle Basis-Tests"
echo " mount - Nur Mount-Status prüfen"
echo " access - Nur Zugriff prüfen"
echo " performance - Nur Performance-Test"
echo " smb - Nur SMB-Bereitschaft prüfen"
echo " safe-eject - Nur Safe-Eject Bereitschaft prüfen"
;;
esac
}
# Script ausführen
main "$@"