scriptos/stream-recorder
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Release: v2.7.0 + Dokumentation ausgelagert

Browse Source
This commit is contained in:
Patrick Asmus
2026-09-07 12:54:53 +02:00
parent 7ddfb0e0d4
commit f3a8e20d7f
16 changed files with 1103 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/befehle.md
+103
View File
@@ -0,0 +1,103 @@
# Befehle
## Übersicht
| Befehl | Beschreibung |
|----------------------|-------------------------------------------------|
| `record <job>` | Einzelnen Stream aufzeichnen |
| `record-all` | Alle Jobs gleichzeitig aufzeichnen |
| `create` | Neuen Job interaktiv erstellen |
| `quick` | Schnellaufnahme (URL direkt eingeben) |
| `upload <datei>` | Vorhandene Datei nach Plik hochladen |
| `stop <name>` | Aufnahme stoppen (Teilaufnahme wird hochgeladen)|
| `stop-all` | Alle Aufnahmen stoppen |
| `list` | Jobs und deren Zeitpläne anzeigen |
| `status` | Laufende Aufnahmen mit Details anzeigen |
| `scheduler` | Zeitplanung prüfen und Jobs starten/stoppen |
| `logs` | Log-Ausgabe live verfolgen |
## Optionen
| Option | Beschreibung |
|--------------------------|---------------------------------------|
| `-c, --config <datei>` | Alternative Konfigurationsdatei |
| `-V, --verbose` | Ausführliche Ausgabe |
| `--foreground` | Aufnahme im Vordergrund ausführen |
| `-h, --help` | Hilfe anzeigen |
| `-v, --version` | Version anzeigen |
## Details
### record
Startet eine Aufnahme im Hintergrund (Standard) oder Vordergrund (`--foreground`).
```bash
./stream-recorder.sh record mein-stream
./stream-recorder.sh --foreground record mein-stream
./stream-recorder.sh -V record mein-stream
```
### create
Erstellt interaktiv eine neue Job-Datei. Fragt nach URL, Name, Typ, Segment-Splitting, Zeitplan und Plik-Upload.
```bash
./stream-recorder.sh create
```
### quick
Schnellaufnahme ohne Job-Datei. Fragt nach URL, Name, Typ und Dauer.
```bash
./stream-recorder.sh quick
```
### stop / stop-all
Stoppt eine laufende Aufnahme. Wenn Plik aktiviert ist, wird die Teilaufnahme hochgeladen. Bei Segment-Splitting werden alle verbleibenden Segmente hochgeladen.
```bash
./stream-recorder.sh stop mein-stream
./stream-recorder.sh stop-all
```
### status
Zeigt detaillierte Informationen zu laufenden Aufnahmen:
- Stream-Name und Typ
- PID und Startmodus (manuell/geplant)
- Startzeit und bisherige Laufzeit
- Dateigröße bzw. Anzahl der Segmente und Gesamtgröße
- Scheduler-Status (systemd-Timer)
```bash
./stream-recorder.sh status
```
### list
Zeigt alle konfigurierten Jobs mit Status, Zeitplan, Segment-Einstellungen und Plik-Konfiguration.
```bash
./stream-recorder.sh list
```
### logs
Verfolgt die Log-Ausgabe in Echtzeit (`tail -f`).
```bash
./stream-recorder.sh logs
```
## Logging
Logs werden nach `LOG_DIR` geschrieben (Standard: `/var/log/stream-recorder/`):
| Datei | Inhalt |
|----------------------------|---------------------------------|
| `stream-recorder.log` | Alle Operationen des Scripts |
| `ffmpeg_<job-id>.log` | ffmpeg-Ausgabe pro Job |
| `nohup_<job-id>.log` | Ausgabe im Hintergrund-Modus |
docs/beispiele.md
+157
View File
@@ -0,0 +1,157 @@
# Praxisbeispiele
## RTMP-Livestream täglich aufzeichnen
Tägliche Aufnahme eines Twitch-/YouTube-/RTMP-Streams von 20:00 bis 22:00 Uhr mit Plik-Upload:
```bash
# jobs/abend-livestream.job
STREAM_NAME="Abend-Livestream"
STREAM_URL="rtmp://example.com/live/stream-key"
STREAM_TYPE="auto"
OUTPUT_FORMAT=""
MAX_DURATION=""
EXTRA_FFMPEG_ARGS=""
SEGMENT_DURATION=""
SCHEDULE_ENABLED=true
SCHEDULE_DAYS="*"
SCHEDULE_START="20:00"
SCHEDULE_STOP="22:00"
PLIK_ENABLED=true
DELETE_AFTER_UPLOAD=false
```
## Radio-Mitschnitt werktags
Werktags um 18:00 Uhr eine Stunde Radio mitschneiden:
```bash
# jobs/radio-abends.job
STREAM_NAME="Radio-Abendshow"
STREAM_URL="https://example.com/stream.mp3"
STREAM_TYPE="auto"
OUTPUT_FORMAT=""
MAX_DURATION="1h"
EXTRA_FFMPEG_ARGS=""
SEGMENT_DURATION=""
SCHEDULE_ENABLED=true
SCHEDULE_DAYS="Mo-Fr"
SCHEDULE_START="18:00"
SCHEDULE_STOP=""
PLIK_ENABLED=false
```
## 24/7-Stream mit stündlichem Upload
Ein Überwachungsstream, der dauerhaft läuft und stündlich Segmente zu Plik hochlädt. Lokale Dateien werden nach dem Upload gelöscht:
```bash
# jobs/ueberwachung.job
STREAM_NAME="Kamera-Front"
STREAM_URL="rtmp://192.168.1.100/live/cam1"
STREAM_TYPE="auto"
OUTPUT_FORMAT="mp4"
MAX_DURATION=""
EXTRA_FFMPEG_ARGS=""
SEGMENT_DURATION="1h"
SCHEDULE_ENABLED=false
PLIK_ENABLED=true
DELETE_AFTER_UPLOAD=true
```
Starten mit:
```bash
./stream-recorder.sh record ueberwachung
```
## Podcast-/HLS-Stream in 2-Stunden-Blöcken
Ein langer HLS-Livestream (z.B. Konferenz) in 2-Stunden-Segmenten aufzeichnen, jedes Segment wird sofort hochgeladen:
```bash
# jobs/konferenz.job
STREAM_NAME="Dev-Konferenz-2026"
STREAM_URL="https://example.com/live/playlist.m3u8"
STREAM_TYPE="hls"
OUTPUT_FORMAT="mp4"
MAX_DURATION="10h"
EXTRA_FFMPEG_ARGS=""
SEGMENT_DURATION="2h"
SCHEDULE_ENABLED=false
PLIK_ENABLED=true
DELETE_AFTER_UPLOAD=false
```
## Einmalige Aufnahme zu einem bestimmten Termin
Ein Event am 15.09.2026 um 21:00 Uhr aufnehmen, 2 Stunden:
```bash
# jobs/einmaliges-event.job
STREAM_NAME="Einmaliges-Event"
STREAM_URL="https://example.com/live/playlist.m3u8"
STREAM_TYPE="hls"
OUTPUT_FORMAT="mp4"
MAX_DURATION="2h"
EXTRA_FFMPEG_ARGS=""
SEGMENT_DURATION=""
SCHEDULE_ENABLED=true
SCHEDULE_ONCE=true
SCHEDULE_DATE="2026-09-15"
SCHEDULE_START="21:00"
SCHEDULE_STOP=""
PLIK_ENABLED=true
DELETE_AFTER_UPLOAD=false
```
## Schnellaufnahme ohne Job-Datei
Für spontane Aufnahmen ohne Konfiguration:
```bash
./stream-recorder.sh quick
```
Das Script fragt interaktiv nach URL, Name, Typ und Dauer.
## Typischer Workflow
```bash
# 1. Konfiguration erstellen (einmalig)
cp config/stream-recorder.conf.dist config/stream-recorder.conf
nano config/stream-recorder.conf
# 2. Scheduler installieren (einmalig)
sudo install/install.sh
# 3. Job erstellen
./stream-recorder.sh create
# 4. Jobs anzeigen
./stream-recorder.sh list
# 5. Status prüfen
./stream-recorder.sh status
# 6. Logs verfolgen
./stream-recorder.sh logs
# 7. Aufnahme stoppen (falls nötig)
./stream-recorder.sh stop mein-stream
```
docs/benachrichtigungen.md
+41
View File
@@ -0,0 +1,41 @@
# NTFY-Benachrichtigungen
Push-Nachrichten via [ntfy](https://ntfy.sh) (selbst gehostet oder öffentlich) bei wichtigen Ereignissen.
## Einrichtung
In `config/stream-recorder.conf`:
```bash
NTFY_URL="https://ntfy.sh/mein-stream-topic"
NTFY_TOKEN="" # Optional, nur bei geschützten Topics
NTFY_EVENTS="start,stop,error" # Kommasepariert
```
## Events
| Event | Auslöser | Priorität |
|----------|-----------------------------------------------------|-----------|
| `start` | Aufnahme wurde gestartet | Normal |
| `stop` | Aufnahme beendet (regulär oder manuell) | Normal |
| `error` | Verbindung verloren oder max. Versuche erreicht | Hoch |
| `upload` | Datei auf Plik hochgeladen (mit Download-Link) | Normal |
## Alle Events aktivieren
```bash
NTFY_EVENTS="start,stop,error,upload"
```
## Nur Fehler (Standard)
```bash
NTFY_EVENTS="error"
```
## Hinweise
- Benachrichtigungen werden asynchron im Hintergrund gesendet
- Ein fehlgeschlagener Versand blockiert die Aufnahme nicht
- curl muss installiert sein (`sudo apt install curl`)
- Ohne gesetzte `NTFY_URL` sind Benachrichtigungen komplett deaktiviert
docs/installation.md
+65
View File
@@ -0,0 +1,65 @@
# Installation
## Voraussetzungen
| Komponente | Anforderung |
|------------------|------------------------------------------|
| Betriebssystem | Linux (getestet unter Ubuntu/Debian) |
| Bash | Version 4.0 oder neuer |
| ffmpeg | Pflicht (`sudo apt install ffmpeg`) |
| curl | Optional, für NTFY und Plik-Upload |
## Installation
```bash
# Repository klonen
git clone https://git.techniverse.net/scriptos/stream-recorder.git /opt/stream-recorder
cd /opt/stream-recorder
# Konfiguration aus Vorlage erstellen und anpassen
cp config/stream-recorder.conf.dist config/stream-recorder.conf
nano config/stream-recorder.conf
# Scheduler installieren (systemd-Timer)
sudo install/install.sh
```
Das Install-Script:
- Macht das Hauptscript ausführbar
- Installiert fehlende Abhängigkeiten (ffmpeg)
- Erstellt die Konfigurationsdatei aus der Vorlage (falls nicht vorhanden)
- Richtet einen systemd-Timer ein, der jede Minute die Zeitpläne prüft
## Updates
Da die Konfiguration als Kopie (`stream-recorder.conf`) vorliegt und die Vorlage (`stream-recorder.conf.dist`) getrennt gepflegt wird, gehen eigene Einstellungen bei einem `git pull` nicht verloren.
```bash
cd /opt/stream-recorder
git pull
```
Nach einem Update sollte man prüfen, ob in `stream-recorder.conf.dist` neue Parameter hinzugekommen sind, und diese ggf. in die eigene `stream-recorder.conf` übernehmen.
## Deinstallation
```bash
sudo install/uninstall.sh
```
Entfernt den systemd-Timer und stoppt optional alle laufenden Aufnahmen. Job-Dateien, Konfiguration und Aufnahmen bleiben erhalten.
## Ohne systemd
Das Script funktioniert auch ohne Scheduler. In dem Fall muss man Aufnahmen manuell starten:
```bash
./stream-recorder.sh record mein-stream
```
Oder den Scheduler manuell per Cron aufrufen:
```bash
# crontab -e
* * * * * /opt/stream-recorder/stream-recorder.sh scheduler
```
docs/jobs.md
+76
View File
@@ -0,0 +1,76 @@
# Job-Dateien
Jeder Stream wird durch eine `.job`-Datei im `jobs/`-Verzeichnis definiert. Vorlagen befinden sich unter `jobs/templates/`.
## Job erstellen
### Interaktiv (empfohlen)
```bash
./stream-recorder.sh create
```
Das Script fragt Schritt für Schritt nach URL, Name, Typ, Segment-Splitting, Zeitplan und Plik-Upload und erstellt die Job-Datei automatisch.
### Aus Vorlage
```bash
# Vorlage kopieren
cp jobs/templates/example-rtmp.job.dist jobs/mein-stream.job
# Anpassen
nano jobs/mein-stream.job
```
Verfügbare Vorlagen:
| Vorlage | Beschreibung |
|----------------------------|-------------------------|
| `example-rtmp.job.dist` | RTMP/RTMPS-Stream |
| `example-hls.job.dist` | HLS/m3u8-Stream |
| `example-mp3.job.dist` | HTTP-Audio (MP3/Radio) |
## Stream-Parameter
| Parameter | Pflicht | Beschreibung |
|----------------------|---------|-----------------------------------------------------|
| `STREAM_NAME` | Ja | Name des Streams (wird für Dateinamen verwendet) |
| `STREAM_URL` | Ja | URL des Streams |
| `STREAM_TYPE` | Nein | `auto`, `rtmp`, `hls`, `mp3`, `aac`, `ogg`, `flac` |
| `OUTPUT_FORMAT` | Nein | Dateiendung (z.B. `mp4`, `mp3`) — sonst automatisch |
| `MAX_DURATION` | Nein | Aufnahmedauer (z.B. `1h`, `30m`, `1d12h`, `3600`) |
| `EXTRA_FFMPEG_ARGS` | Nein | Zusätzliche ffmpeg-Parameter |
| `SEGMENT_DURATION` | Nein | Segment-Splitting (z.B. `1h`, `2h`) — siehe [Segment-Splitting](segment-splitting.md) |
| `PLIK_ENABLED` | Nein | Plik-Upload aktivieren (`true`/`false`) |
| `DELETE_AFTER_UPLOAD` | Nein | Lokale Datei nach Upload löschen (`true`/`false`) |
### Dauerformate
Die Dauer kann in verschiedenen Formaten angegeben werden:
| Format | Bedeutung |
|----------|------------------|
| `3600` | 3600 Sekunden |
| `1h` | 1 Stunde |
| `30m` | 30 Minuten |
| `1h30m` | 90 Minuten |
| `2d` | 2 Tage |
| `1d12h` | 36 Stunden |
## Job-Angabe beim Starten
Der `record`-Befehl akzeptiert verschiedene Formate:
```bash
./stream-recorder.sh record jobs/mein-stream.job # Vollständiger Pfad
./stream-recorder.sh record mein-stream.job # Nur Dateiname
./stream-recorder.sh record mein-stream # Nur Job-Name (ohne .job)
```
## Jobs anzeigen
```bash
./stream-recorder.sh list
```
Zeigt alle Jobs mit Stream-Typ, URL, Status, Zeitplan, Segment-Einstellungen und Plik-Konfiguration.
docs/konfiguration.md
+66
View File
@@ -0,0 +1,66 @@
# Konfiguration
Die Konfigurationsdatei liegt unter `config/stream-recorder.conf`. Sie wird aus der Vorlage `config/stream-recorder.conf.dist` erstellt:
```bash
cp config/stream-recorder.conf.dist config/stream-recorder.conf
nano config/stream-recorder.conf
```
Die `.conf`-Datei wird von Git ignoriert und bleibt bei Updates erhalten.
## Parameter
### Basis-Einstellungen
| Parameter | Standard | Beschreibung |
|-----------------|------------------------------|-------------------------------------------|
| `DOWNLOAD_PATH` | `/home/downloads/recordings` | Basis-Verzeichnis für Aufnahmen |
| `LOG_DIR` | `/var/log/stream-recorder` | Log-Verzeichnis |
| `LOG_LEVEL` | `INFO` | Log-Level: `DEBUG`, `INFO`, `WARN`, `ERROR` |
| `PID_DIR` | `/tmp/stream-recorder` | PID-Dateien für laufende Aufnahmen |
| `STATE_DIR` | `/var/lib/stream-recorder` | Status für bereits gestartete Zeitpläne |
### Reconnect
| Parameter | Standard | Beschreibung |
|---------------|----------|-------------------------------------------|
| `MAX_RETRIES` | `0` | Wiederholungsversuche (0 = unbegrenzt) |
| `RETRY_DELAY` | `5` | Wartezeit zwischen Versuchen (Sekunden) |
Bei Verbindungsabbrüchen versucht das Script automatisch, die Verbindung wiederherzustellen. Bei jedem Reconnect wird eine neue Datei mit aktuellem Zeitstempel erzeugt.
- `MAX_RETRIES=0` — Unbegrenzte Versuche (empfohlen für Langzeitaufnahmen)
- `MAX_RETRIES=5` — Maximal 5 Versuche, danach Abbruch mit Benachrichtigung
### NTFY-Benachrichtigungen
Push-Nachrichten via [ntfy](https://ntfy.sh) (selbst gehostet oder öffentlich).
| Parameter | Standard | Beschreibung |
|---------------|----------|-------------------------------------------|
| `NTFY_URL` | (leer) | NTFY Server-URL inkl. Topic |
| `NTFY_TOKEN` | (leer) | NTFY Access-Token (optional) |
| `NTFY_EVENTS` | `error` | Benachrichtigungs-Events (kommasepariert) |
Siehe [Benachrichtigungen](benachrichtigungen.md) für Details zu den Events.
### Plik-Upload
Fertige Aufnahmen auf einen [Plik](https://github.com/root-gg/plik)-Server hochladen.
| Parameter | Standard | Beschreibung |
|----------------|----------|-------------------------------------------|
| `PLIK_URL` | (leer) | Plik Server-URL |
| `PLIK_API_KEY` | (leer) | Plik API-Key (optional) |
| `PLIK_TTL` | `30d` | Gültigkeitsdauer: `30d`, `24h`, Sekunden |
Siehe [Plik-Upload](plik-upload.md) für die Einrichtung pro Job.
## Alternative Konfigurationsdatei
Eine andere Konfigurationsdatei kann per `-c` übergeben werden:
```bash
./stream-recorder.sh -c /pfad/zur/config.conf record mein-stream
```
docs/plik-upload.md
+62
View File
@@ -0,0 +1,62 @@
# Plik-Upload
Fertige Aufnahmen können automatisch auf einen [Plik](https://github.com/root-gg/plik)-Server hochgeladen werden. Die Browser-URL zum Download wird im Log und optional per NTFY-Benachrichtigung ausgegeben.
## Einrichtung
### 1. Plik-Server konfigurieren
In `config/stream-recorder.conf`:
```bash
PLIK_URL="https://plik.example.com"
PLIK_API_KEY="" # Optional, nur bei geschützten Servern
PLIK_TTL="30d" # Gültigkeitsdauer: 30d, 24h, oder Sekunden
```
### 2. Pro Job aktivieren
In der Job-Datei:
```bash
PLIK_ENABLED=true
```
### 3. Optional: Datei nach Upload löschen
```bash
DELETE_AFTER_UPLOAD=true
```
## Verhalten
- Upload nach jeder regulär abgeschlossenen Aufnahme
- Upload nach manuellem Stop (`stop`-Befehl) — die Teilaufnahme wird hochgeladen
- Upload nach Verbindungsabbruch, wenn eine Teildatei vorhanden ist
- Browser-Link und Datei-URL werden ins Log geschrieben
- Optional wird der Link per NTFY gesendet (Event: `upload`)
## Mit Segment-Splitting
Bei aktiviertem [Segment-Splitting](segment-splitting.md) wird jedes Segment einzeln hochgeladen:
- Fertige Segmente werden während der Aufnahme hochgeladen (alle 60s geprüft)
- Das letzte Segment wird nach Ende der Aufnahme hochgeladen
- `DELETE_AFTER_UPLOAD=true` löscht jedes Segment nach dem Upload
## Manueller Upload
Eine vorhandene Datei kann auch manuell hochgeladen werden:
```bash
./stream-recorder.sh upload /pfad/zur/aufnahme.mp4 "Stream-Name"
```
## Download-Link per Push
Um den Plik-Link automatisch als Push-Nachricht zu erhalten:
```bash
# In config/stream-recorder.conf
NTFY_EVENTS="start,stop,error,upload"
```
docs/segment-splitting.md
+76
View File
@@ -0,0 +1,76 @@
# Segment-Splitting
Lange Aufnahmen (z.B. 8-Stunden-Streams) können automatisch in kleinere Dateien geteilt werden. Jedes Segment wird einzeln nach Plik hochgeladen, sobald es fertig ist.
## Einrichtung
In der Job-Datei `SEGMENT_DURATION` setzen:
```bash
# Aufnahme alle 2 Stunden teilen
SEGMENT_DURATION="2h"
# Plik-Upload aktivieren (empfohlen)
PLIK_ENABLED=true
```
## Dauerformate
| Format | Bedeutung |
|----------|------------------|
| `30m` | Alle 30 Minuten |
| `1h` | Stündlich |
| `2h` | Alle 2 Stunden |
| `3600` | 3600 Sekunden |
## So funktioniert's
1. ffmpeg teilt die Aufnahme automatisch in Segmente der angegebenen Länge
2. Ein Hintergrund-Prozess prüft alle 60 Sekunden auf fertige Segmente
3. Fertige Segmente werden sofort nach Plik hochgeladen (falls aktiviert)
4. Beim Beenden (regulär oder per `stop`) wird das letzte Segment noch hochgeladen
### Dateinamen
Segmente erhalten fortlaufende Nummern:
```
Mein-Stream_20260907_200000_seg000.mp4
Mein-Stream_20260907_200000_seg001.mp4
Mein-Stream_20260907_200000_seg002.mp4
```
## Kombination mit Plik
Segment-Splitting ist besonders nützlich in Kombination mit Plik-Upload:
```bash
SEGMENT_DURATION="1h"
PLIK_ENABLED=true
DELETE_AFTER_UPLOAD=true # Lokale Segmente nach Upload löschen
```
So wird jede Stunde ein Segment hochgeladen und lokal gelöscht. Das spart Speicherplatz bei langen Aufnahmen.
## Kombination mit Zeitplanung
Segment-Splitting und Zeitplanung lassen sich kombinieren:
```bash
SCHEDULE_ENABLED=true
SCHEDULE_DAYS="*"
SCHEDULE_START="08:00"
SCHEDULE_STOP="20:00"
SEGMENT_DURATION="2h"
PLIK_ENABLED=true
```
Die 12-Stunden-Aufnahme wird in 6 Segmente zu je 2 Stunden geteilt, jedes wird nach Fertigstellung hochgeladen.
## Verhalten bei Reconnect
Wenn die Verbindung abbricht und wiederhergestellt wird, werden die bisherigen Segmente hochgeladen und eine neue Segment-Serie mit neuem Zeitstempel begonnen.
## Status
Mit `./stream-recorder.sh status` werden bei segmentierten Aufnahmen die Anzahl der Segmente und die Gesamtgröße angezeigt.
docs/zeitplanung.md
+80
View File
@@ -0,0 +1,80 @@
# Zeitplanung
Die Zeitplanung wird direkt in der Job-Datei konfiguriert — kein Cron-Wissen nötig. Ein systemd-Timer prüft jede Minute alle Jobs und startet/stoppt Aufnahmen automatisch.
## Einrichtung
1. **Job-Datei erstellen** und `SCHEDULE_*`-Parameter setzen
2. **Scheduler installieren** mit `sudo install/install.sh` (einmalig)
3. Fertig — der Timer prüft jede Minute alle Jobs
## Zeitplan-Parameter
| Parameter | Standard | Beschreibung |
|--------------------|----------|-------------------------------------------------|
| `SCHEDULE_ENABLED` | `false` | Zeitplan aktivieren (`true`/`false`) |
| `SCHEDULE_ONCE` | `false` | Einmaliger Termin statt wöchentlichem Zeitplan |
| `SCHEDULE_DATE` | (leer) | Datum für einmalige Termine (`YYYY-MM-DD`) |
| `SCHEDULE_DAYS` | `*` | Aufnahmetage für wöchentliche Zeitpläne |
| `SCHEDULE_START` | (leer) | Startzeit im Format `HH:MM` |
| `SCHEDULE_STOP` | (leer) | Endzeit im Format `HH:MM` (leer = kein Auto-Stop)|
## Tagesformate
| Format | Bedeutung |
|--------------|----------------------------|
| `*` | Täglich |
| `Mo-Fr` | Montag bis Freitag |
| `Sa,So` | Samstag und Sonntag |
| `Mo,Mi,Fr` | Einzelne Tage |
| `Mo-Fr,So` | Kombiniert |
Die Tagesangaben funktionieren auf Deutsch (Mo, Di, Mi, Do, Fr, Sa, So) und Englisch (Mon, Tue, Wed, Thu, Fri, Sat, Sun).
## Verhalten
- **Start + Stop gesetzt:** Aufnahme läuft im angegebenen Zeitfenster
- **Nur Start gesetzt:** Aufnahme startet zur angegebenen Zeit, läuft bis `MAX_DURATION` oder manueller Stop
- **Einmalig:** Mit `SCHEDULE_ONCE=true` und `SCHEDULE_DATE="YYYY-MM-DD"` startet der Job nur an diesem Datum
- **Manuell gestartete Aufnahmen** werden vom Scheduler nicht beeinflusst
- **Nach Neustart** des Servers erkennt der Scheduler automatisch, welche Aufnahmen laufen sollten
- **Nachtübergreifend:** Start- und Stoppzeiten können über Mitternacht gehen (z.B. `23:00` bis `02:00`)
## Beispiele
### Tägliche Aufnahme von 20:00 bis 22:00
```bash
SCHEDULE_ENABLED=true
SCHEDULE_DAYS="*"
SCHEDULE_START="20:00"
SCHEDULE_STOP="22:00"
```
### Werktags um 18:00, 1 Stunde
```bash
SCHEDULE_ENABLED=true
SCHEDULE_DAYS="Mo-Fr"
SCHEDULE_START="18:00"
MAX_DURATION="1h"
```
### Nur am Wochenende
```bash
SCHEDULE_ENABLED=true
SCHEDULE_DAYS="Sa,So"
SCHEDULE_START="14:00"
SCHEDULE_STOP="18:00"
```
### Einmalige Aufnahme am 15.09.2026
```bash
SCHEDULE_ENABLED=true
SCHEDULE_ONCE=true
SCHEDULE_DATE="2026-09-15"
SCHEDULE_START="21:00"
MAX_DURATION="30m"
```