michael/ripster
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

DOcs

Browse Source
This commit is contained in:
mboehmlaender
2026-03-11 14:54:08 +00:00
parent 3b66ca64f8
commit aabb28ee06
66 changed files with 1199 additions and 904 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
docs/api/index.md
View File

@@ -1,8 +1,6 @@
# API-Referenz
# Anhang: API-Referenz
Ripster bietet eine REST-API für Steuerung/Verwaltung sowie einen WebSocket-Endpunkt für Echtzeit-Updates.
---
REST- und WebSocket-Schnittstellen für Integration, Automatisierung und Debugging.
## Basis-URL
@@ -12,13 +10,6 @@ http://localhost:3001
API-Prefix: `/api`
Beispiele:
- `GET /api/health`
- `GET /api/pipeline/state`
---
## API-Gruppen
<div class="grid cards" markdown>
@@ -73,45 +64,6 @@ Beispiele:
</div>
---
## Hinweis
## Authentifizierung
Es gibt keine eingebaute Authentifizierung. Ripster ist für lokalen Betrieb gedacht.
---
## Fehlerformat
Fehler werden zentral als JSON geliefert:
```json
{
"error": {
"message": "Job nicht gefunden.",
"statusCode": 404,
"reqId": "req_...",
"details": [
{
"field": "name",
"message": "Name darf nicht leer sein."
}
]
}
}
```
`details` ist optional (z. B. bei Validierungsfehlern).
---
## Häufige Statuscodes
| Code | Bedeutung |
|------|-----------|
| `200` | Erfolg |
| `201` | Ressource erstellt |
| `400` | Ungültige Anfrage / Validierungsfehler |
| `404` | Ressource nicht gefunden |
| `409` | Konflikt (z. B. falscher Pipeline-Zustand, Job läuft bereits) |
| `500` | Interner Fehler |
Ripster hat keine eingebaute Authentifizierung und ist für lokalen, geschützten Betrieb gedacht.

30
docs/appendix/index.md Normal file
View File

@@ -0,0 +1,30 @@
# Technischer Anhang
Dieser Bereich enthält die technische Referenz hinter dem Benutzerhandbuch.
## Inhalt
- **Konfiguration**
- komplette Feldreferenz
- Umgebungsvariablen
- **Pipeline intern**
- Zustandsmodell
- Encode-Planung
- Playlist-Analyse
- Pre-/Post-Encode-Ausführungen
- **API-Referenz**
- REST-Endpunkte
- WebSocket-Events
- **Architektur**
- Backend-/Frontend-Aufbau
- Datenbank
- **Deployment**
- Betrieb in Entwicklung und Produktion
- **Externe Tools**
- MakeMKV, HandBrake, MediaInfo
## Wann du in den Anhang wechselst
- du integrierst Ripster mit anderen Systemen
- du betreibst mehrere Instanzen oder willst tiefer debuggen
- du brauchst Feld-/API-/Schema-Details für Automatisierung

25
docs/architecture/index.md
View File

@@ -1,6 +1,6 @@
# Architektur
# Anhang: Architektur
Ripster ist eine Client-Server-Anwendung mit REST + WebSocket.
Ripster ist eine Client-Server-Anwendung mit REST + WebSocket und externen CLI-Tools.
---
@@ -40,26 +40,7 @@ graph TB
---
## Schichten
### Backend
- `src/index.js` (Bootstrapping, Routes, WS, Services)
- `src/routes/*` (Pipeline, Settings, History, Crons)
- `src/services/*` (Business-Logik)
- `src/db/database.js` (Init/Migration)
- `src/utils/*` (Parser, Dateifunktionen, Validierung)
### Frontend
- `App.jsx` + `pages/*` (Dashboard, Settings, History)
- `components/*` (Status-/Review-/Dialog-Komponenten)
- `api/client.js` (REST-Client)
- `hooks/useWebSocket.js` (WS-Reconnect)
---
## Weiterführend
## Details
<div class="grid cards" markdown>

14
docs/configuration/index.md
View File

@@ -1,4 +1,8 @@
# Konfiguration
# Anhang: Konfiguration
Dieser Abschnitt ist die technische Referenz zu allen Konfigurationsarten in Ripster.
## Inhalte
<div class="grid cards" markdown>
@@ -6,7 +10,7 @@
---
Alle verfügbaren Einstellungen mit Typen, Standardwerten und Beschreibungen.
Vollständige Liste aller UI-Settings (Typ, Default, Hinweise).
[:octicons-arrow-right-24: Einstellungsreferenz](settings-reference.md)
@@ -14,8 +18,12 @@
---
Umgebungsvariablen für Backend und Frontend.
`backend/.env` und `frontend/.env` inkl. Prioritäten.
[:octicons-arrow-right-24: Umgebungsvariablen](environment.md)
</div>
## Zurück zum Handbuch
- [Benutzerhandbuch Überblick](../getting-started/index.md)

8
docs/deployment/index.md
View File

@@ -1,4 +1,6 @@
# Deployment
# Anhang: Deployment
Technische Betriebsdokumentation für Entwicklung und Produktion.
<div class="grid cards" markdown>
@@ -6,7 +8,7 @@
---
Lokale Entwicklungsumgebung einrichten.
Lokale Entwicklung mit Hot-Reload.
[:octicons-arrow-right-24: Entwicklung](development.md)
@@ -14,7 +16,7 @@
---
Ripster auf einem Server dauerhaft betreiben.
Installation und Betrieb auf Servern.
[:octicons-arrow-right-24: Produktion](production.md)

112
docs/deployment/production.md
View File

@@ -2,7 +2,117 @@
---
## Empfohlene Architektur
## Automatische Installation (empfohlen)
Das mitgelieferte `install.sh` richtet Ripster vollautomatisch auf Debian/Ubuntu ein – inklusive Node.js, MakeMKV, HandBrake, nginx und systemd-Dienst.
**Unterstützte Systeme:** Debian 11/12, Ubuntu 22.04/24.04
**Voraussetzung:** root-Rechte, Internetzugang
### Schnellstart via curl
```bash
curl -fsSL https://raw.githubusercontent.com/Mboehmlaender/ripster/main/install.sh | sudo bash
```
Oder mit wget:
```bash
wget -qO- https://raw.githubusercontent.com/Mboehmlaender/ripster/main/install.sh | sudo bash
```
!!! warning "Optionen nur via Datei"
Beim Pipen von curl/wget können keine Argumente übergeben werden. Für benutzerdefinierte Optionen zuerst herunterladen und dann mit `sudo bash install.sh [Optionen]` ausführen.
### Optionen
| Option | Standard | Beschreibung |
|--------|----------|--------------|
| `--branch <branch>` | `main` | Git-Branch für die Installation |
| `--dir <pfad>` | `/opt/ripster` | Installationsverzeichnis |
| `--user <benutzer>` | `ripster` | Systembenutzer für den Dienst |
| `--port <port>` | `3001` | Backend-Port |
| `--host <hostname>` | Auto (Maschinen-IP) | Hostname/IP für die Weboberfläche |
| `--no-makemkv` | – | MakeMKV-Installation überspringen |
| `--no-handbrake` | – | HandBrake-Installation überspringen |
| `--no-nginx` | – | nginx-Einrichtung überspringen |
| `--reinstall` | – | Bestehende Installation aktualisieren (Daten bleiben erhalten) |
| `-h`, `--help` | – | Hilfe anzeigen |
### Beispiele
```bash
# Standard-Installation
sudo bash install.sh
# Anderen Branch und Port verwenden
sudo bash install.sh --branch dev --port 8080
# Ohne MakeMKV (bereits installiert)
sudo bash install.sh --no-makemkv
# Bestehende Installation aktualisieren
sudo bash install.sh --reinstall
# Ohne nginx (eigener Reverse-Proxy)
sudo bash install.sh --no-nginx --host mein-server.local
```
### Was das Skript erledigt
1. **Systemprüfung** – OS-Erkennung und Root-Check
2. **Systempakete** – `curl`, `wget`, `git`, `mediainfo`, `udev` u. a.
3. **Node.js 20** – via NodeSource, falls noch nicht installiert
4. **MakeMKV** – aktuelle Version wird aus dem offiziellen Forum ermittelt und aus dem Quellcode kompiliert (kann mit `--no-makemkv` übersprungen werden)
5. **HandBrake** – interaktive Auswahl:
- **Option 1**: Standard (`apt install handbrake-cli`)
- **Option 2**: Gebündelte GPU-Version mit NVDEC aus `bin/HandBrakeCLI`
6. **Systembenutzer** `ripster` – ohne Login-Shell, Gruppen: `cdrom`, `optical`, `disk`, `video`, `render`
7. **Repository** – klont Branch nach `--dir` (bei `--reinstall`: sichert DB, pullt, stellt DB wieder her)
8. **npm-Abhängigkeiten** – Root, Backend (nur production), Frontend
9. **Frontend-Build** – `npm run build` mit relativen API-URLs (nginx-kompatibel)
10. **Backend `.env`** – wird automatisch generiert (bei `--reinstall` bleibt bestehende erhalten)
11. **Berechtigungen** – `ripster:ripster` auf Installationsverzeichnis, `600` auf `.env`
12. **systemd-Dienst** – `ripster-backend.service` erstellt, aktiviert und gestartet
13. **nginx** – konfiguriert als Reverse-Proxy für Frontend, `/api/` und `/ws` (kann mit `--no-nginx` übersprungen werden)
### Nach der Installation
```bash
# Status prüfen
sudo systemctl status ripster-backend
# Logs verfolgen
sudo journalctl -u ripster-backend -f
# Neustart
sudo systemctl restart ripster-backend
# Aktualisieren
sudo bash /opt/ripster/install.sh --reinstall
```
**Zugriff:** `http://<Maschinen-IP>` (oder der mit `--host` angegebene Hostname)
### HandBrake-Modus (GPU/NVDEC)
Bei nicht-interaktiver Ausführung (Pipe von curl) wird automatisch die Standard-Version gewählt. Für die GPU-Version zuerst herunterladen:
```bash
curl -fsSL https://raw.githubusercontent.com/Mboehmlaender/ripster/main/install.sh -o install.sh
sudo bash install.sh
# → Interaktive Auswahl: Option 2 für NVDEC
```
Das gebündelte Binary liegt unter `bin/HandBrakeCLI` und wird nach `/usr/local/bin/HandBrakeCLI` kopiert.
---
## Manuelle Installation
Die folgenden Abschnitte beschreiben die einzelnen Schritte für manuelle oder angepasste Setups.
### Empfohlene Architektur
```text
Client

120
docs/getting-started/configuration.md
View File

@@ -1,99 +1,71 @@
# Konfiguration
# Ersteinrichtung
Die Hauptkonfiguration erfolgt über die UI (`Settings`) und wird in SQLite gespeichert.
Nach der Installation erfolgt die tägliche Konfiguration fast vollständig in der GUI unter `Settings`.
---
## Ziel
## Pflichteinstellungen vor dem ersten Rip
Vor dem ersten echten Job müssen Pfade, Tools und Metadatenzugriff sauber gesetzt sein.
### 1) Pfade
## Reihenfolge (empfohlen)
| Einstellung | Beschreibung | Beispiel |
|------------|-------------|---------|
| `raw_dir` | Basisverzeichnis für RAW-Rips | `/mnt/ripster/raw` |
| `movie_dir` | Basisverzeichnis für finale Encodes | `/mnt/ripster/movies` |
| `log_dir` | Verzeichnis für Prozess-/Backend-Logs | `/mnt/ripster/logs` |
### 1. `Settings` -> Tab `Konfiguration`
Optional profilspezifisch:
Setze zuerst diese Pflichtwerte:
- `raw_dir_bluray`, `raw_dir_dvd`, `raw_dir_other`
- `movie_dir_bluray`, `movie_dir_dvd`, `movie_dir_other`
| Bereich | Wichtige Felder |
|---|---|
| Pfade | `raw_dir`, `movie_dir`, `log_dir` |
| Tools | `makemkv_command`, `handbrake_command`, `mediainfo_command` |
| Metadaten | `omdb_api_key`, optional `omdb_default_type` |
### 2) Tools
Danach `Änderungen speichern`.
| Einstellung | Standard |
|------------|---------|
| `makemkv_command` | `makemkvcon` |
| `handbrake_command` | `HandBrakeCLI` |
| `mediainfo_command` | `mediainfo` |
### 2. Medienprofile prüfen
### 3) OMDb
Wenn du Blu-ray und DVD unterschiedlich behandeln willst, pflege die profilbezogenen Felder:
| Einstellung | Beschreibung |
|------------|-------------|
| `omdb_api_key` | API-Key von omdbapi.com |
| `omdb_default_type` | `movie`, `series`, `episode` |
- `*_bluray`
- `*_dvd`
- optional `*_other`
---
Typische Beispiele:
## Encode-Konfiguration (wichtig)
- `handbrake_preset_bluray` und `handbrake_preset_dvd`
- `raw_dir_bluray` und `raw_dir_dvd`
- `filename_template_bluray` und `filename_template_dvd`
Ripster arbeitet profilspezifisch, typischerweise über:
### 3. Queue und Monitoring festlegen
- Blu-ray: `handbrake_preset_bluray`, `handbrake_extra_args_bluray`, `output_extension_bluray`, `filename_template_bluray`
- DVD: `handbrake_preset_dvd`, `handbrake_extra_args_dvd`, `output_extension_dvd`, `filename_template_dvd`
- `pipeline_max_parallel_jobs` für parallele Jobs
- `hardware_monitoring_enabled` und Intervall für Live-Metriken im Dashboard
### Template-Platzhalter
### 4. Optional: Push-Benachrichtigungen
Verfügbar in `filename_template_*` und `output_folder_template_*`:
- `${title}`
- `${year}`
- `${imdbId}`
Beispiel:
```text
${title} (${year})
-> Inception (2010).mkv
```
---
## MakeMKV-spezifisch
| Einstellung | Standard | Hinweis |
|------------|---------|--------|
| `makemkv_min_length_minutes` | `60` | Kandidaten-Filter |
| `makemkv_rip_mode_bluray` | `backup` | `mkv` oder `backup` |
| `makemkv_rip_mode_dvd` | `mkv` | `mkv` oder `backup` |
| `makemkv_registration_key` | leer | optional, wird via `makemkvcon reg` gesetzt |
---
## Monitoring & Queue
| Einstellung | Standard |
|------------|---------|
| `hardware_monitoring_enabled` | `true` |
| `hardware_monitoring_interval_ms` | `5000` |
| `pipeline_max_parallel_jobs` | `1` |
---
## PushOver (optional)
Basis:
In den Benachrichtigungsfeldern setzen:
- `pushover_enabled`
- `pushover_token`
- `pushover_user`
Zusätzlich pro Event ein/aus (z. B. `pushover_notify_job_finished`).
Dann über `PushOver Test` direkt prüfen.
---
## 2-Minuten-Funktionstest
## Verwandte Doku
1. `Dashboard` öffnen
2. Disc einlegen
3. `Analyse starten`
4. Metadaten übernehmen
5. Bis `READY_TO_ENCODE` laufen lassen
- [Einstellungsreferenz](../configuration/settings-reference.md)
- [Umgebungsvariablen](../configuration/environment.md)
Wenn diese Schritte funktionieren, ist die Grundkonfiguration korrekt.
## Wenn Werte nicht gespeichert werden
- Feld mit Fehler markieren lassen (rote Validierung im Formular)
- Pfadangaben und numerische Werte prüfen
- bei Tool-Pfaden direkt CLI-Aufruf im Terminal testen
## Weiter
- [Erster Lauf](quickstart.md)
- [GUI-Seiten im Detail](../gui/index.md)

56
docs/getting-started/index.md
View File

@@ -1,41 +1,33 @@
# Erste Schritte
# Benutzerhandbuch Überblick
Dieser Abschnitt führt dich durch die Installation und Einrichtung von Ripster.
Dieses Kapitel ist für den **Betrieb von Ripster im Alltag** geschrieben.
## Überblick
## Zielgruppe
<div class="grid cards" markdown>
- Anwender, die Discs verarbeiten wollen
- Betreiber, die den täglichen Ablauf stabil fahren möchten
- Power-User, die Queue/Skripte/Cron im UI steuern möchten
- :material-list-check: **Voraussetzungen**
## Kapitelstruktur
---
| Kapitel | Zweck |
|---|---|
| [Voraussetzungen](prerequisites.md) | Prüfen, ob System und Tools bereit sind |
| [Installation](installation.md) | Ripster aufsetzen und starten |
| [Ersteinrichtung](configuration.md) | Pfade, Tools und Metadaten korrekt setzen |
| [Erster Lauf](quickstart.md) | Ein kompletter Job von Disc bis Datei |
| [GUI-Seiten](../gui/index.md) | Alle Ansichten und Aktionen im Detail |
| [Workflows](../workflows/index.md) | Typische Abläufe und Entscheidungen aus User-Sicht |
Systemanforderungen und externe Tools, die vor der Installation benötigt werden.
## Wenn du neu startest
[:octicons-arrow-right-24: Voraussetzungen prüfen](prerequisites.md)
1. [Voraussetzungen](prerequisites.md)
2. [Installation](installation.md)
3. [Ersteinrichtung](configuration.md)
4. [Erster Lauf](quickstart.md)
- :material-download: **Installation**
## Wenn Ripster bereits läuft
---
Schritt-für-Schritt-Anleitung zur Installation von Ripster.
[:octicons-arrow-right-24: Installation starten](installation.md)
- :material-tune: **Konfiguration**
---
Einrichten von Pfaden, API-Keys und Encoding-Presets.
[:octicons-arrow-right-24: Konfigurieren](configuration.md)
- :material-rocket-launch: **Schnellstart**
---
Rippe deinen ersten Film in wenigen Minuten.
[:octicons-arrow-right-24: Loslegen](quickstart.md)
</div>
1. [GUI-Seiten](../gui/index.md)
2. [Workflows](../workflows/index.md)
3. Bei Detailfragen: [Technischer Anhang](../appendix/index.md)

131
docs/getting-started/installation.md
View File

@@ -1,103 +1,84 @@
# Installation
---
Die empfohlene Installation läuft über `install.sh` und richtet Ripster vollständig ein.
## Repository klonen
## Zielbild nach der Installation
- Ripster-Backend als `systemd`-Dienst
- Frontend über nginx erreichbar
- UI auf `http://<Server-IP>`
## Schritt-für-Schritt
### 1. Installationsskript herunterladen
```bash
git clone https://github.com/YOUR_GITHUB_USERNAME/ripster.git
cd ripster
wget -qO install.sh https://raw.githubusercontent.com/Mboehmlaender/ripster/main/install.sh
```
---
## Dev-Start (empfohlen)
### 2. Installation ausführen
```bash
./start.sh
sudo bash install.sh
```
`start.sh`:
Während der Installation wirst du nach dem HandBrake-Modus gefragt:
1. prüft Node-Version (`>= 20.19.0`)
2. installiert Dependencies (Root/Backend/Frontend)
3. startet Backend + Frontend parallel
- `1` Standard (`apt`)
- `2` GPU/NVDEC (gebündeltes Binary)
Danach:
- Backend: `http://localhost:3001`
- Frontend: `http://localhost:5173`
Stoppen: mit `Ctrl+C` im laufenden Terminal.
---
## Manuell starten
### 3. Dienststatus prüfen
```bash
npm install
npm --prefix backend install
npm --prefix frontend install
npm run dev
sudo systemctl status ripster-backend
```
Oder getrennt:
### 4. Weboberfläche öffnen
- Mit nginx: `http://<Server-IP>`
- Ohne nginx (`--no-nginx`): API auf `http://<Server-IP>:3001/api`
## Wichtige Optionen
| Option | Zweck |
|---|---|
| `--branch <branch>` | anderen Branch installieren |
| `--dir <pfad>` | Installationsverzeichnis ändern |
| `--port <port>` | Backend-Port setzen |
| `--host <hostname>` | Hostname/IP für nginx/CORS |
| `--no-makemkv` | MakeMKV nicht installieren |
| `--no-handbrake` | HandBrake nicht installieren |
| `--no-nginx` | nginx-Konfiguration überspringen |
| `--reinstall` | Update einer bestehenden Installation |
Beispiele:
```bash
npm run dev:backend
npm run dev:frontend
sudo bash install.sh --branch dev
sudo bash install.sh --port 8080 --host ripster.local
sudo bash install.sh --reinstall
```
---
## Optional: .env-Dateien anlegen
### Backend
## Betrieb im Alltag
```bash
cp backend/.env.example backend/.env
# Logs live ansehen
sudo journalctl -u ripster-backend -f
# Dienst neu starten
sudo systemctl restart ripster-backend
# Update aus bestehender Installation
sudo bash /opt/ripster/install.sh --reinstall
```
Beispiel:
## Häufige Stolperstellen
```env
PORT=3001
DB_PATH=./data/ripster.db
LOG_DIR=./logs
CORS_ORIGIN=http://localhost:5173
LOG_LEVEL=info
```
- `Permission denied` am Laufwerk: Laufwerksrechte/Gruppen prüfen
- Tools nicht gefunden: `makemkvcon`, `HandBrakeCLI`, `mediainfo` im `PATH` prüfen
- UI nicht erreichbar: nginx-Status und Port/Firewall prüfen
### Frontend
## Danach weiter
```bash
cp frontend/.env.example frontend/.env
```
Beispiel:
```env
VITE_API_BASE=/api
# optional:
# VITE_WS_URL=ws://localhost:3001/ws
```
---
## Datenbank
SQLite wird automatisch beim Backend-Start initialisiert:
```text
backend/data/ripster.db
```
Schema-Quelle: `db/schema.sql`
---
## Nächste Schritte
1. Browser öffnen: `http://localhost:5173`
2. In `Settings` Pfade/Tools/API-Keys prüfen
3. Erste Disc einlegen und Workflow starten
1. [Ersteinrichtung](configuration.md)
2. [Erster Lauf](quickstart.md)

169
docs/getting-started/prerequisites.md
View File

@@ -1,157 +1,70 @@
# Voraussetzungen
Bevor du Ripster installierst, stelle sicher, dass folgende Software auf deinem System verfügbar ist.
Diese Seite ist die praktische Checkliste vor der Installation.
---
## 1) System
## System-Anforderungen
| Punkt | Mindestwert | Empfehlung |
|---|---|---|
| Betriebssystem | Linux oder macOS | Ubuntu 22.04+ |
| Node.js | 20.19.0 | 20.x LTS |
| RAM | 4 GB | 8 GB+ |
| Freier Speicher | 50 GB | 500 GB+ |
| Anforderung | Mindestversion | Empfohlen |
|------------|----------------|-----------|
| **Betriebssystem** | Linux / macOS | Ubuntu 22.04+ |
| **Node.js** | 20.19.0 | 20.x LTS |
| **RAM** | 4 GB | 8 GB+ |
| **Festplatte** | 50 GB frei | 500 GB+ (für Roh-MKVs) |
---
## Node.js
Ripster benötigt **Node.js >= 20.19.0**.
=== "nvm (empfohlen)"
```bash
# nvm installieren
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
# Node.js 20 installieren
nvm install 20
nvm use 20
# Version prüfen
node --version # v20.x.x
```
=== "Ubuntu/Debian"
```bash
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
node --version # v20.x.x
```
=== "macOS (Homebrew)"
```bash
brew install node@20
node --version # v20.x.x
```
---
## Externe Tools
### MakeMKV
!!! warning "Lizenz erforderlich"
MakeMKV ist für den persönlichen Gebrauch kostenlos (Beta-Lizenz), benötigt aber eine gültige Lizenz.
Node-Version prüfen:
```bash
# Ubuntu/Debian - PPA verwenden
sudo add-apt-repository ppa:heyarje/makemkv-beta
sudo apt-get update
sudo apt-get install makemkv-bin makemkv-oss
node --version
```
# Installierte Version prüfen
## 2) Externe Tools
Ripster benötigt folgende CLI-Tools im `PATH`:
- `makemkvcon`
- `HandBrakeCLI`
- `mediainfo`
Schnell prüfen:
```bash
makemkvcon --version
```
[:octicons-link-external-24: MakeMKV Download](https://www.makemkv.com/download/){ .md-button }
### HandBrake CLI
```bash
# Ubuntu/Debian
sudo add-apt-repository ppa:stebbins/handbrake-releases
sudo apt-get update
sudo apt-get install handbrake-cli
# Version prüfen
HandBrakeCLI --version
# macOS
brew install handbrake
```
[:octicons-link-external-24: HandBrake Download](https://handbrake.fr/downloads2.php){ .md-button }
### MediaInfo
```bash
# Ubuntu/Debian
sudo apt-get install mediainfo
# macOS
brew install mediainfo
# Version prüfen
mediainfo --Version
```
---
## 3) Optisches Laufwerk
## Disc-Laufwerk
Ripster benötigt ein physisches **DVD- oder Blu-ray-Laufwerk**.
!!! danger "LibDriveIO-Modus erforderlich"
Das Laufwerk muss im **LibDriveIO-Modus** betrieben werden – MakeMKV greift direkt auf Rohdaten des Laufwerks zu. Ohne diesen Modus können verschlüsselte Blu-rays (insbesondere UHD) nicht gelesen werden.
Nicht alle Laufwerke unterstützen den direkten Zugriff. Eine Anleitung zur Einrichtung und Liste kompatibler Laufwerke findet sich im [MakeMKV-Forum](https://www.makemkv.com/forum/viewtopic.php?t=18856).
Für Disc-Betrieb muss ein DVD/Blu-ray-Laufwerk erreichbar sein.
```bash
# Laufwerk prüfen
ls /dev/sr*
# oder
lsblk | grep rom
```
# Laufwerk-Berechtigungen setzen (erforderlich für LibDriveIO)
Wenn nötig Rechte setzen (Beispiel):
```bash
sudo chmod a+rw /dev/sr0
```
!!! info "Blu-ray unter Linux"
MakeMKV bringt mit LibDriveIO eine eigene Entschlüsselung mit – externe Bibliotheken wie `libaacs` sind in der Regel nicht erforderlich.
## 4) OMDb API-Key
---
Für automatische Metadaten (Titel, Poster, IMDb-ID):
## OMDb API-Key
1. Key unter [omdbapi.com](https://www.omdbapi.com/apikey.aspx) anlegen
2. in den `Settings` als `omdb_api_key` eintragen
Ripster verwendet die [OMDb API](https://www.omdbapi.com/) für Filmmetadaten.
## 5) Optional: PushOver
1. Registriere dich kostenlos auf [omdbapi.com](https://www.omdbapi.com/apikey.aspx)
2. Bestätige deine E-Mail-Adresse
3. Notiere deinen API-Key – du gibst ihn später in den Einstellungen ein
Für Push-Nachrichten bei Erfolg/Fehler:
---
- Account/App auf [pushover.net](https://pushover.net)
- `pushover_token` und `pushover_user` später in den `Settings` setzen
## Optionale Voraussetzungen
## Abschluss-Checkliste
### PushOver (Benachrichtigungen)
Für mobile Push-Benachrichtigungen bei Fertigstellung oder Fehlern:
- App kaufen auf [pushover.net](https://pushover.net) (~5 USD einmalig)
- **User Key** und **API Token** notieren
---
## Checkliste
- [ ] Node.js >= 20.19.0 installiert (`node --version`)
- [ ] `makemkvcon` installiert (`makemkvcon --version`)
- [ ] `HandBrakeCLI` installiert (`HandBrakeCLI --version`)
- [ ] `mediainfo` installiert (`mediainfo --Version`)
- [ ] DVD/Blu-ray Laufwerk vorhanden (`ls /dev/sr*`)
- [ ] OMDb API-Key beschafft
- [ ] Node.js 20.x verfügbar
- [ ] `makemkvcon`, `HandBrakeCLI`, `mediainfo` ausführbar
- [ ] Laufwerk erkannt
- [ ] OMDb Key bereit

130
docs/getting-started/quickstart.md
View File

@@ -1,114 +1,70 @@
# Schnellstart – Erster kompletter Job
# Erster Lauf
Diese Seite führt durch den typischen ersten Lauf.
Dieser Ablauf zeigt einen vollständigen Job aus Anwendersicht: von Disc-Erkennung bis fertiger Datei.
---
## 1. Dashboard öffnen und Disc einlegen
## 1) Starten
Erwartung:
```bash
cd ripster
./start.sh
```
- Status wechselt auf `DISC_DETECTED` bzw. `Medium erkannt`
- im Bereich `Disk-Information` sind Laufwerksdaten sichtbar
Öffne `http://localhost:5173`.
Wenn nichts passiert: `Laufwerk neu lesen`.
---
## 2. Analyse starten
## 2) Disc einlegen
Aktion im Dashboard:
Pipeline wechselt auf `DISC_DETECTED`.
- `Analyse starten`
Falls nötig manuell neu scannen:
Erwartung:
```bash
curl -X POST http://localhost:3001/api/pipeline/rescan-disc
```
- Status `ANALYZING`
- danach Metadaten-Dialog
---
## 3. Metadaten auswählen
## 3) Analyse starten
Im Dialog `Metadaten auswählen`:
Klicke im Dashboard auf `Analyse starten`.
1. OMDb-Suche nutzen oder manuell eintragen
2. passenden Treffer markieren
3. `Auswahl übernehmen`
Intern:
## 4. Auf den nächsten Zustand reagieren
- Job wird angelegt
- MakeMKV-Analyse läuft (`ANALYZING`)
- UI wechselt in Metadatenauswahl (`METADATA_SELECTION`)
- Normalfall ohne vorhandenes RAW: `RIPPING` -> `MEDIAINFO_CHECK` -> `READY_TO_ENCODE`
- bei vorhandenem RAW: direkt `MEDIAINFO_CHECK` -> `READY_TO_ENCODE`
- bei unklarer Blu-ray-Playlist: `WAITING_FOR_USER_DECISION` (Playlist auswählen und übernehmen)
---
## 5. Review in `READY_TO_ENCODE`
## 4) Metadaten bestätigen
Im aufgeklappten Job (`Pipeline-Status`):
Im Dialog:
- Encode-Titel wählen
- Audio-/Subtitle-Spuren prüfen
- optional User-Preset auswählen
- optional Pre-/Post-Skripte bzw. Ketten hinzufügen
- OMDb-Ergebnis wählen oder manuell eintragen
- bei Playlist-Abfrage ggf. `selectedPlaylist` wählen
Dann `Encoding starten`.
Nach Bestätigung startet Ripster automatisch weiter.
## 6. Encoding überwachen
---
Während `ENCODING`:
## 5) Pipeline-Pfade
- Fortschritt + ETA im Dashboard
- Live-Log im `Pipeline-Status`
- Queue- und Skript/Cron-Status parallel beobachtbar
Abhängig von Job/RAW-Situation:
## 7. Ergebnis prüfen
- **kein RAW vorhanden** -> `RIPPING`
- **RAW vorhanden** -> `MEDIAINFO_CHECK`
- **mehrdeutige Playlist** -> `WAITING_FOR_USER_DECISION`
Bei `FINISHED`:
Wenn Parallel-Limit erreicht ist, wird der Job in die Queue eingereiht.
1. Seite `Historie` öffnen
2. Job in Details öffnen
3. Output-Pfad, Status und Log prüfen
---
## Typische Folgeaktionen
## 6) Review (`READY_TO_ENCODE`)
Im Review-Panel:
- Titel auswählen (falls mehrere)
- Audio-/Subtitle-Tracks auswählen
- optional User-Preset anwenden
- optional Pre-/Post-Skripte und Ketten hinzufügen
Mit `Encoding starten` wird `confirm-encode` + Start ausgelöst.
---
## 7) Encoding (`ENCODING`)
Während Encoding:
- Live-Fortschritt/ETA über WebSocket
- Pre-Encode-Ausführungen laufen vor HandBrake
- Post-Encode-Ausführungen laufen nach HandBrake
Wichtig:
- Pre-Encode-Fehler -> Job endet in `ERROR`
- Post-Encode-Fehler -> Job kann `FINISHED` bleiben, aber mit Fehlerhinweis im Status/Log
---
## 8) Abschluss (`FINISHED`)
Ergebnis:
- Ausgabe in `movie_dir` (ggf. profilspezifisch)
- Job in Historie sichtbar
- Logs im konfigurierten `log_dir`
---
## Nützliche API-Shortcuts
```bash
# Pipeline-Snapshot
curl http://localhost:3001/api/pipeline/state
# Queue-Snapshot
curl http://localhost:3001/api/pipeline/queue
# Jobs
curl http://localhost:3001/api/history
```
- Falsches OMDb-Match: in `Historie` -> `OMDb neu zuordnen`
- Neue Encodierung aus RAW: `RAW neu encodieren`
- Prüfung komplett neu aufbauen: `Review neu starten`

124
docs/gui/dashboard.md Normal file
View File

@@ -0,0 +1,124 @@
# Dashboard
Das Dashboard ist die **Betriebszentrale** für laufende Jobs.
## Aufbau der Seite
Die Bereiche erscheinen in dieser Reihenfolge:
1. `Hardware Monitoring`
2. `Job Queue`
3. `Skript- / Cron-Status`
4. `Job Übersicht`
5. `Disk-Information`
---
## 1) Hardware Monitoring
Zeigt live:
- CPU (gesamt + optional pro Kern)
- RAM
- GPU-Auslastung/Temperatur/VRAM
- freien Speicher in den konfigurierten Pfaden
Wichtig für den Betrieb:
- Hohe Speicherauslastung oder fast volle Zielpfade früh erkennen
- über `Settings` aktivierbar/deaktivierbar (`hardware_monitoring_*`)
## 2) Job Queue
Zwei Spalten:
- `Laufende Jobs`
- `Warteschlange`
Mögliche Aktionen:
- Queue per Drag-and-Drop umsortieren
- Queue-Job entfernen (`X`)
- zusätzliche Queue-Elemente einfügen (`+`):
- Skript
- Skriptkette
- Wartezeit
Hinweis:
- `Parallel` zeigt das aktuell konfigurierte Parallel-Limit (`pipeline_max_parallel_jobs`).
## 3) Skript- / Cron-Status
Zeigt:
- aktive Ausführungen (Skripte, Ketten, Cron)
- zuletzt abgeschlossene Ausführungen
Mögliche Aktionen:
- laufende Ketten: `Nächster Schritt`
- laufende Einträge: `Abbrechen`
- Historie der Aktivitäten: `Liste leeren`
## 4) Job Übersicht
Kompakte Jobliste mit Status, Fortschritt, ETA. Klick auf einen Job klappt die Detailsteuerung auf.
Im aufgeklappten Zustand erscheint die Karte `Pipeline-Status` mit allen zustandsabhängigen Aktionen.
### Zustandsabhängige Hauptaktionen
| Zustand | Typische Aktion |
|---|---|
| `DISC_DETECTED` / `IDLE` | `Analyse starten` |
| `METADATA_SELECTION` | `Metadaten öffnen` |
| `WAITING_FOR_USER_DECISION` | Playlist wählen und `Playlist übernehmen` |
| `READY_TO_START` | `Job starten` |
| `READY_TO_ENCODE` | Tracks/Skripte prüfen, dann `Encoding starten` |
| laufend (`ANALYZING`/`RIPPING`/`ENCODING`) | `Abbrechen` |
| `ERROR` / `CANCELLED` | `Retry Rippen`, `Disk-Analyse neu starten` |
Zusätzlich je nach Job:
- `Review neu starten`
- `Encode neu starten`
- `Aus Queue löschen`
### Titel-/Spurprüfung (`READY_TO_ENCODE`)
Im selben Block siehst du:
- Auswahl des Encode-Titels
- Audio-/Subtitle-Trackauswahl
- User-Preset-Auswahl
- Pre-/Post-Encode-Skripte und Ketten
- Preview des finalen HandBrakeCLI-Befehls
## 5) Disk-Information
Zeigt aktuelles Laufwerk und Disc-Metadaten (`Pfad`, `Modell`, `Disc-Label`, `Mount`).
Aktionen:
- `Laufwerk neu lesen`
- `Disk neu analysieren`
- `Metadaten-Modal öffnen`
---
## Wichtige Dialoge im Dashboard
### Metadaten auswählen
- OMDb-Suche + Ergebnisliste
- manuelle Eingabe als Fallback
- `Auswahl übernehmen` startet den nächsten Pipeline-Schritt
### Abbruch-Bereinigung
Nach Abbruch kann Ripster optional fragen, ob erzeugte RAW- oder Movie-Dateien gelöscht werden sollen.
### Queue-Eintrag einfügen
Erstellt gezielt einen Skript-, Ketten- oder Warte-Eintrag an einer bestimmten Queue-Position.

39
docs/gui/database.md Normal file
View File

@@ -0,0 +1,39 @@
# Database (Expert)
`/database` ist eine erweiterte Ansicht für Power-User und Recovery-Fälle.
## Zugriff
- Route direkt aufrufen: `/database`
- nicht Teil der Standard-Navigation
## Bereiche
### 1) `Historie & Datenbank`
Tabellarische Jobansicht mit:
- ID, Poster, Medium, Titel
- Status
- Start/Ende
Aktionen im Detaildialog entsprechen weitgehend der Seite `Historie` (inkl. Re-Encode, Review-Neustart, OMDb-Zuordnung, Dateilöschung).
### 2) `RAW ohne Historie`
Listet RAW-Ordner, die keinen zugehörigen Job-Eintrag haben.
Aktionen:
- `RAW prüfen` (Scan der konfigurierten RAW-Pfade)
- `Job anlegen` (Orphan-RAW in Historie importieren)
## Typischer Einsatz
- nach manuellen Dateioperationen
- nach Migrationen oder Recovery
- wenn RAW-Dateien vorhanden sind, aber kein Historieneintrag existiert
## Vorsicht
Diese Seite erlaubt Eingriffe mit direkter Auswirkung auf Datenbestand und Historie. Vor Lösch- oder Importaktionen Pfade und Zieljob sorgfältig prüfen.

62
docs/gui/history.md Normal file
View File

@@ -0,0 +1,62 @@
# Historie
Die Seite `Historie` ist für Suche, Prüfung und Nachbearbeitung bestehender Jobs.
## Hauptansicht
Filter und Werkzeuge:
- Suche (Titel/IMDb)
- Status-Filter
- Medium-Filter (`Blu-ray`, `DVD`, `Sonstiges`)
- Sortierung
- Listen-/Grid-Layout
Jeder Eintrag zeigt:
- Poster, Titel, Jahr, IMDb
- Medium-Indikator
- Status
- Start/Ende
- Verfügbarkeit von RAW/Movie
- Ratings (wenn OMDb-Daten vorhanden)
Klick auf einen Eintrag öffnet die Detailansicht.
---
## Job-Detaildialog
Bereiche:
- Film-Infos + OMDb-Details
- Job-Infos (Status, Pfade, Erfolgsflags, Fehler)
- hinterlegte Encode-Auswahl
- ausgeführter HandBrake-Befehl
- strukturierte JSON-Blöcke (OMDb/MakeMKV/MediaInfo/EncodePlan/HandBrake)
- Log-Ladefunktionen (`Tail`, `Vollständig`)
## Typische Aktionen im Detaildialog
- `OMDb neu zuordnen`
- `Encode neu starten`
- `Review neu starten`
- `RAW neu encodieren`
- `RAW löschen`, `Movie löschen`, `Beides löschen`
- `Historieneintrag löschen`
- bei Queue-Lock: `Aus Queue löschen`
## Wann welche Aktion?
| Ziel | Aktion |
|---|---|
| Metadaten korrigieren | `OMDb neu zuordnen` |
| mit gleicher bestätigter Auswahl neu encodieren | `Encode neu starten` |
| Titel-/Spurprüfung komplett neu berechnen | `Review neu starten` |
| aus vorhandenem RAW erneut encodieren | `RAW neu encodieren` |
| Speicher freigeben | Dateilöschaktionen |
## Logs
- `Tail laden (800)` für schnelle Fehleranalyse
- `Vollständiges Log laden` für vollständige Nachverfolgung

24
docs/gui/index.md Normal file
View File

@@ -0,0 +1,24 @@
# GUI-Seiten
Ripster hat drei Hauptseiten in der Navigation plus eine Expert-Seite.
## Seitenüberblick
| Seite | Zweck |
|---|---|
| [Dashboard](dashboard.md) | Live-Betrieb: Pipeline, Queue, Aktivitäten, Disc-Infos |
| [Settings](settings.md) | Konfiguration, Skripte, Ketten, Presets, Cronjobs |
| [Historie](history.md) | abgeschlossene/laufende Jobs durchsuchen und nachbearbeiten |
| [Database (Expert)](database.md) | tabellarische Rohsicht inkl. Orphan-RAW-Import |
## Empfohlene Nutzung im Alltag
1. **Start eines neuen Jobs:** `Dashboard`
2. **Regeln/Automatisierung anpassen:** `Settings`
3. **Ergebnisse prüfen oder Jobs nachbearbeiten:** `Historie`
4. **Sonderfälle/Recovery:** `Database`
## Hinweise zur Navigation
- `Dashboard`, `Settings`, `Historie` sind direkt in der Kopfnavigation.
- `Database` ist als Expert-Route verfügbar: `/database`.

92
docs/gui/settings.md Normal file
View File

@@ -0,0 +1,92 @@
# Settings
Die Seite `Settings` steuert Konfiguration und Automatisierung.
## Tabs im Überblick
| Tab | Zweck |
|---|---|
| `Konfiguration` | alle Kernsettings (Pfade, Tools, Monitoring, Metadaten, Queue, Benachrichtigungen) |
| `Scripte` | einzelne Bash-Skripte verwalten und testen |
| `Skriptketten` | Sequenzen aus Skript- und Warte-Schritten bauen |
| `Encode-Presets` | benutzerdefinierte Presets für das Review im Dashboard |
| `Cronjobs` | zeitgesteuerte Skript-/Kettenausführung |
---
## Tab `Konfiguration`
Wichtiges Bedienmuster:
1. Werte ändern
2. `Änderungen speichern`
3. bei Bedarf `Änderungen verwerfen` oder `Neu laden`
Zusätzlich:
- `PushOver Test` sendet eine Testnachricht
- Änderungen werden erst nach Speichern wirksam
- Tool-Preset-Felder bieten HandBrake-Presetauswahl direkt im Formular
## Tab `Scripte`
Funktionen:
- Skript anlegen, bearbeiten, löschen
- Skript testen (`Test`)
- Reihenfolge per Drag-and-Drop
Praxis:
- Reihenfolge ist wichtig, weil ausgewählte Skripte später sequentiell abgearbeitet werden.
- Testresultate zeigen Exit-Code, Dauer und stdout/stderr.
## Tab `Skriptketten`
Funktionen:
- Kette anlegen/bearbeiten/löschen
- Kette testen
- Reihenfolge der Ketten per Drag-and-Drop
Im Ketten-Editor:
- Bausteine links (`Warten`, vorhandene Skripte)
- Schritte rechts per Klick oder Drag-and-Drop hinzufügen
- Schrittreihenfolge im Canvas ändern
## Tab `Encode-Presets`
Ein Preset bündelt:
- optional HandBrake-Preset (`-Z`)
- optionale Extra-Args
- Medientyp (`Universell`, `Blu-ray`, `DVD`, `Sonstiges`)
Verwendung:
- Diese Presets erscheinen später im Dashboard im Review (`READY_TO_ENCODE`).
## Tab `Cronjobs`
Funktionen:
- Cronjob anlegen und bearbeiten
- Quelle wählen: Skript oder Skriptkette
- Cron-Ausdruck validieren
- `Jetzt ausführen`
- Logs je Cronjob anzeigen
- `Aktiviert` und `Pushover` toggeln
Hilfen:
- Beispiele für Cron-Ausdrücke direkt im Dialog
- Link zu `crontab.guru` im Editor
---
## Empfehlung für stabile Nutzung
1. Erst `Konfiguration` sauber setzen
2. dann Skripte/Ketten testen
3. danach Cronjobs aktivieren

148
docs/index.md
View File

@@ -1,141 +1,33 @@
# Ripster
# Ripster Handbuch
**Halbautomatische Disc-Ripping-Plattform für DVDs und Blu-rays**
Dieses Dokumentationsset ist als **Benutzerhandbuch** aufgebaut: erst Bedienung und Alltag, dann Technik im Anhang.
---
<div class="grid cards" markdown>
## Schnellstart in 3 Schritten
- :material-disc: **Automatisiertes Ripping**
---
Disc einlegen – Ripster erkennt sie automatisch und startet den Analyse-Workflow mit MakeMKV.
[:octicons-arrow-right-24: Workflow verstehen](pipeline/workflow.md)
- :material-movie-open: **Metadata-Integration**
---
Automatische Suche in der OMDb-Datenbank für Filmtitel, Poster und IMDb-IDs.
[:octicons-arrow-right-24: Konfiguration](getting-started/configuration.md)
- :material-cog: **Flexibles Encoding**
---
HandBrake-Encoding mit individueller Track-Auswahl für Audio- und Untertitelspuren.
[:octicons-arrow-right-24: Encode-Planung](pipeline/encoding.md)
- :material-history: **Job-Historie**
---
Vollständiges Audit-Trail aller Ripping-Jobs mit Logs und Re-Encode-Funktion.
[:octicons-arrow-right-24: History API](api/history.md)
</div>
1. Voraussetzungen prüfen und installieren: [Installation](getting-started/installation.md)
2. Grundkonfiguration in der UI setzen: [Ersteinrichtung](getting-started/configuration.md)
3. Ersten vollständigen Job durchlaufen: [Erster Lauf](getting-started/quickstart.md)
---
## Was ist Ripster?
## Was du hier findest
Ripster ist eine webbasierte Anwendung zur **halbautomatischen Digitalisierung** von DVDs und Blu-rays. Die Anwendung kombiniert bewährte Open-Source-Tools zu einem durchgängigen, komfortablen Workflow:
```
Disc einlegen → Erkennung → Analyse → Metadaten wählen → Rippen → Encodieren → Fertig
```
### Kernfunktionen
| Feature | Beschreibung |
|---------|-------------|
| **Echtzeit-Updates** | WebSocket-basierte Live-Statusanzeige ohne Reload |
| **Intelligente Playlist-Analyse** | Erkennt Blu-ray Playlist-Verschleierung (Fake-Playlists) |
| **Track-Auswahl** | Individuelle Auswahl von Audio- und Untertitelspuren |
| **Orphan-Recovery** | Import von bereits gerippten Dateien als Jobs |
| **PushOver-Benachrichtigungen** | Mobile Alerts bei Fertigstellung oder Fehlern |
| **DB-Korruptions-Recovery** | Automatische Quarantäne bei korrupten SQLite-Dateien |
| **Re-Encoding** | Erneutes Encodieren ohne neu rippen |
- **Benutzerhandbuch**
- Installation
- GUI-Seiten im Detail (`Dashboard`, `Settings`, `Historie`, `Database`)
- typische Arbeitsabläufe aus Anwendersicht
- **Technischer Anhang**
- vollständige Einstellungsreferenz
- Pipeline-/API-/Architekturdetails
- Deployment und Tool-Hintergründe
---
## Technologie-Stack
## Empfohlene Lesereihenfolge
=== "Backend"
- **Node.js** >= 20.19.0 mit Express.js
- **SQLite3** mit automatischen Schema-Migrationen
- **WebSocket** (`ws`) für Echtzeit-Kommunikation
- Externe CLI-Tools: `makemkvcon`, `HandBrakeCLI`, `mediainfo`
=== "Frontend"
- **React** 18.3.1 mit React Router
- **Vite** 5.4.12 als Build-Tool
- **PrimeReact** 10.9.2 als UI-Bibliothek
- WebSocket-Client für Live-Updates
=== "Externe Tools"
| Tool | Zweck |
|------|-------|
| `makemkvcon` | Disc-Analyse & MKV/Backup-Ripping |
| `HandBrakeCLI` | Video-Encoding |
| `mediainfo` | Track-Informationen aus gerippten Dateien |
| OMDb API | Filmmetadaten (Titel, Poster, IMDb-ID) |
---
## Schnellstart
```bash
# 1. Repository klonen
git clone https://github.com/YOUR_GITHUB_USERNAME/ripster.git
cd ripster
# 2. Starten (Node.js >= 20 erforderlich)
./start.sh
# 3. Browser öffnen
open http://localhost:5173
```
!!! tip "Erste Schritte"
Die vollständige Installationsanleitung mit allen Voraussetzungen findest du unter [Erste Schritte](getting-started/index.md).
---
## Pipeline-Überblick
<div class="pipeline-diagram">
```mermaid
flowchart LR
IDLE --> DD[DISC_DETECTED]
DD --> META[METADATA\nSELECTION]
META --> RTS[READY_TO\nSTART]
RTS -->|Auto-Start| RIP[RIPPING]
RTS -->|Auto-Start mit RAW| MIC
RIP --> MIC[MEDIAINFO\nCHECK]
MIC -->|Playlist offen (Backup)| WUD[WAITING_FOR\nUSER_DECISION]
WUD --> MIC
MIC --> RTE[READY_TO\nENCODE]
RTE --> ENC[ENCODING]
ENC -->|inkl. Post-Skripte| FIN([FINISHED])
ENC --> ERR([ERROR])
RIP --> ERR
style FIN fill:#e8f5e9,stroke:#66bb6a,color:#2e7d32
style ERR fill:#ffebee,stroke:#ef5350,color:#c62828
style WUD fill:#fff8e1,stroke:#ffa726,color:#e65100
style ENC fill:#f3e5f5,stroke:#ab47bc,color:#6a1b9a
```
</div>
`READY_TO_START` ist in der Praxis meist ein kurzer Übergangszustand: der Job wird nach Metadaten-Auswahl automatisch gestartet oder in die Queue eingeplant.
1. [Benutzerhandbuch Überblick](getting-started/index.md)
2. [GUI-Seiten](gui/index.md)
3. [Workflows aus Nutzersicht](workflows/index.md)
4. Bei Bedarf: [Technischer Anhang](appendix/index.md)

18
docs/pipeline/index.md
View File

@@ -1,6 +1,6 @@
# Pipeline
# Anhang: Pipeline intern
Der Pipeline-Bereich beschreibt den Kern-Workflow von Ripster.
Dieser Abschnitt beschreibt die technische Pipeline-Logik hinter den UI-Workflows.
<div class="grid cards" markdown>
@@ -8,7 +8,7 @@ Der Pipeline-Bereich beschreibt den Kern-Workflow von Ripster.
---
Zustände, Übergänge und Queue-Verhalten.
Zustandsmodell, Übergänge, Queue-Verhalten.
[:octicons-arrow-right-24: Workflow](workflow.md)
@@ -16,7 +16,7 @@ Der Pipeline-Bereich beschreibt den Kern-Workflow von Ripster.
---
Wie Titel/Tracks für HandBrake vorbereitet und bestätigt werden.
Aufbereitung von Titeln/Tracks und Bestätigungslogik.
[:octicons-arrow-right-24: Encoding](encoding.md)
@@ -24,16 +24,20 @@ Der Pipeline-Bereich beschreibt den Kern-Workflow von Ripster.
---
Bewertung mehrdeutiger Blu-ray-Playlists und manuelle Entscheidung.
Bewertung mehrdeutiger Blu-ray-Playlists.
[:octicons-arrow-right-24: Playlist-Analyse](playlist-analysis.md)
- :material-script-text: **Encode-Skripte (Pre & Post)**
- :material-script-text: **Pre-/Post-Encode-Ausführungen**
---
Skripte/Ketten vor und nach dem Encode ausführen.
Skript- und Kettenlauf vor/nach dem Encoding.
[:octicons-arrow-right-24: Encode-Skripte](post-encode-scripts.md)
</div>
## Zurück zum Handbuch
- [Workflows aus Nutzersicht](../workflows/index.md)

10
docs/tools/index.md
View File

@@ -1,6 +1,6 @@
# Externe Tools
# Anhang: Externe Tools
Ripster ist ein **Orchestrator** – die eigentliche Arbeit erledigen diese bewährten Open-Source-Tools:
Ripster orchestriert externe CLI-Tools. Dieser Abschnitt erklärt deren Rolle im Gesamtsystem.
<div class="grid cards" markdown>
@@ -8,7 +8,7 @@ Ripster ist ein **Orchestrator** – die eigentliche Arbeit erledigen diese bew
---
Disc-Analyse und Ripping. Erstellt MKV-Dateien oder vollständige Backups.
Disc-Analyse und Ripping.
[:octicons-arrow-right-24: MakeMKV](makemkv.md)
@@ -16,7 +16,7 @@ Ripster ist ein **Orchestrator** – die eigentliche Arbeit erledigen diese bew
---
Video-Encoding mit umfangreichen Preset-Optionen.
Video-Encoding inklusive Preset-Logik.
[:octicons-arrow-right-24: HandBrake](handbrake.md)
@@ -24,7 +24,7 @@ Ripster ist ein **Orchestrator** – die eigentliche Arbeit erledigen diese bew
---
Analyse von Track-Informationen in Mediendateien.
Track-/Containeranalyse für Review und Auswahl.
[:octicons-arrow-right-24: MediaInfo](mediainfo.md)

61
docs/workflows/index.md Normal file
View File

@@ -0,0 +1,61 @@
# Workflows aus Nutzersicht
Diese Seite beschreibt typische Abläufe mit den passenden UI-Aktionen.
## Workflow 1: Standardlauf (Disc -> fertige Datei)
1. `Dashboard`: Disc einlegen, `Analyse starten`
2. Metadaten im Dialog übernehmen
3. bei `READY_TO_ENCODE` Titel/Tracks prüfen
4. `Encoding starten`
5. Ergebnis in `Historie` kontrollieren
## Workflow 2: Playlist-Entscheidung bei Blu-ray
1. Job landet in `WAITING_FOR_USER_DECISION`
2. im `Pipeline-Status` Playlist-Kandidaten vergleichen
3. gewünschte Playlist auswählen
4. `Playlist übernehmen`
5. danach normal weiter bis `READY_TO_ENCODE`
## Workflow 3: Mehrere Jobs mit Queue
1. Parallel-Limit in `Settings` setzen (`pipeline_max_parallel_jobs`)
2. neue Jobs starten; überschüssige Starts gehen in `Job Queue`
3. Reihenfolge per Drag-and-Drop anpassen
4. bei Bedarf Skript/Kette/Warten als Queue-Eintrag ergänzen
## Workflow 4: Nachbearbeitung eines bestehenden Jobs
In `Historie` -> Detaildialog:
- Metadaten korrigieren: `OMDb neu zuordnen`
- gleiche Einstellungen erneut nutzen: `Encode neu starten`
- Analyse neu aufbauen: `Review neu starten`
- aus RAW erneut encodieren: `RAW neu encodieren`
## Workflow 5: Automatisierung mit Skripten und Cron
1. `Settings` -> `Scripte`: Skripte anlegen und testen
2. `Settings` -> `Skriptketten`: Ketten bauen und testen
3. im Dashboard-Review Pre-/Post-Ausführungen pro Job auswählen
4. `Settings` -> `Cronjobs`: zeitgesteuerte Ausführung konfigurieren
5. Status im Dashboard (`Skript- / Cron-Status`) überwachen
## Workflow 6: Abbruch und Recovery
### Fall A: Job wurde abgebrochen
- im Dashboard optional erzeugte RAW/Movie-Datei bereinigen
- anschließend je nach Ziel: `Retry Rippen` oder `Disk-Analyse neu starten`
### Fall B: Job steht in `READY_TO_ENCODE`, ist aber nicht aktive Session
- in `Historie` oder `Database`: `Im Dashboard öffnen`
- im Dashboard Review erneut prüfen und starten
### Fall C: RAW ohne Historieneintrag
- `/database` öffnen
- Bereich `RAW ohne Historie`
- `Job anlegen`