Kapitel 13/Tutorial.md aktualisiert

Kapitel 13/Tutorial.md

@@ -118,12 +118,11 @@ nano /etc/clipper/clipper.env
 ```
 Inhalt:
 ```
-CLIPPER_INBOX=/srv/clipper/inbox
+SFTP_HOST=192.168.51.2
-CLIPPER_IN=/srv/clipper/watch
+SFTP_PORT=22
-CLIPPER_OUT=/srv/clipper/out
+SFTP_USER=sftp_uploader
-CLIPPER_TMP=/srv/clipper/temp
+SFTP_KEY=/home/clipper/.ssh/nc_sftp_ed25519
-CLIPPER_LOG=/srv/clipper/logs/clipper.log
+SFTP_DROP_BASE=incoming
-CLIPPER_NC_REMOTE="nc:<DEIN-REMOTE>/<BASISPFAD>"
 ```
 Dateirechte setzen, damit `clipper` sie lesen darf:
 ```bash
@@ -603,32 +602,27 @@ In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**. Er sorgt d
 
 8. **Vorbereitungen für VOD Download und Speicherung**
 
-      **8.1 Vorbereitung (einmalig) – rclone an Nextcloud anbinden**  
+      **8.1 Vorbereitung (einmalig) – SFTP-Verbindung testen
       Ort: Clipper-LXC Shell
-      Öffne hierzu in Proxmox, Putty, oder einer anderen Konsole den Clipper LXC und gebe die folgenden Befehele ein:   
+      Wir prüfen, ob Clipper mit dem Key des sftp_uploader auf den Nextcloud-Host kommt und die Drop-Zone erreichbar ist.  
-      ```bash
-      apt update && apt install -y rclone
-      ```
-      Hiermit installieren wie rclone, was wir später für den Upload zu Nextcloud nutzen werden
-      
-      Wechsel dann zu dem vorhin erstellten NUtzer (in diesem Tutorial Clipper) und erstelle eine WebDAV Anbindung an deine Nextcloud.
-      Hierfür verwnedest du die folgenden Befehle:
-      
       ```bash
       su - clipper
-      rclone config create nc webdav \
+      sftp -i ~/.ssh/nc_sftp_ed25519 -oBatchMode=yes -oStrictHostKeyChecking=accept-new -P 22 sftp_uploader@<IP_des_Nextcloud_LXC> <<'SFTP'
-      url=https://DEINE_DOMAIN/remote.php/dav/files/DEIN_BENUTZERNAME/ \
+      mkdir incoming
-      vendor=nextcloud \
+      mkdir incoming/_test
-      user=DEIN_BENUTZERNAME \
+      ls incoming
-      pass=$(rclone obscure 'DEIN_APP_PASSWORT')
+      rmdir incoming/_test
-      rclone ls nc: --config /home/clipper/.config/rclone/rclone.conf
+      SFTP
+      exit
       ```
+      Erwartung: die Ausgabe zeigt incoming. Dann ist die Verbindung korrekt.
 
       **8.2 Download/Upload Skript erstellen**  
       **Ort:** Clipper-LXC Shell
       
-      Noch immer in der Konsole des Clipper LXC verlässt du mit `exit` den User und bist wieder root User.
+      Wir erstellen ein Skript, das ein Twitch-VOD mit yt-dlp lädt und per SFTP nach incoming/<VOD_ID>/<VOD_ID>.mp4 auf dem Nextcloud-Host hochlädt.
-      Im Anschluss erstellst du eine neue Datei mit
+      Voraussetzung: In /etc/clipper/clipper.env sind gesetzt:
+      SFTP_HOST, SFTP_PORT, SFTP_USER, SFTP_KEY, SFTP_DROP_BASE, außerdem CLIPPER_TMP, CLIPPER_OUT.
       ```bash
       nano <clipper-ordner>/bin/clipper-vod-get
       ```
@@ -636,30 +630,31 @@ In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**. Er sorgt d
       ```bash
         #!/usr/bin/env bash
          set -euo pipefail
-   . /etc/clipper/clipper.env
+
+         ENV_FILE="/etc/clipper/clipper.env"
+         [[ -r "$ENV_FILE" ]] || { echo "ENV nicht lesbar: $ENV_FILE" >&2; exit 1; }
+         source "$ENV_FILE"
 
          ID="${1:?need VOD id}"
          URL="${2:-https://www.twitch.tv/videos/${ID}}"
 
-   TMP="${CLIPPER_TMP}"
+         TMP="${CLIPPER_TMP:-/srv/clipper/temp}"
-   OUT_BASE="${CLIPPER_OUT}/${ID}"
+         OUT_BASE="${CLIPPER_OUT:-/srv/clipper/out}/${ID}"
-   LOGDIR="${CLIPPER_LOG}/${ID}"
+         LOGDIR="/srv/clipper/logs/${ID}"
-   CONF="/home/clipper/.config/rclone/rclone.conf"
+         FILE="${TMP}/${ID}.mp4"
+         TEMP="${TMP}/${ID}.temp.mp4"
+         PART="${TMP}/${ID}.mp4.part"
+         LOCK="${TMP}/${ID}.lock"
 
-   DST="${CLIPPER_NC_REMOTE}/VODs/${ID}/"
+         DROP_BASE="${SFTP_DROP_BASE:-incoming}"
-
+         REMOTE_DIR="${DROP_BASE}/${ID}"
-   OUT="$TMP/${ID}.%(ext)s"
+         REMOTE_FILE="${REMOTE_DIR}/${ID}.mp4"
-   FILE="$TMP/${ID}.mp4"
-   TEMP="$TMP/${ID}.temp.mp4"
-   PART="$TMP/${ID}.mp4.part"
-   LOCK="$TMP/${ID}.lock"
 
          mkdir -p "$TMP" "$LOGDIR" "$OUT_BASE"
-   LOG="$LOGDIR/download.log"
+         LOG="${LOGDIR}/download.log"
-   log(){ echo "[$(date '+%F %T')] $*"; }
+         log(){ printf '[%(%F %T)T] %s\n' -1 "$*" ; }
          exec > >(tee -a "$LOG") 2>&1
 
-   # ---- atomarer Lock (kein Race zwischen zwei Starts)
          exec 9>"$LOCK"
          if ! flock -n 9; then
          log "LOCK: $ID wird bereits verarbeitet"
@@ -667,44 +662,36 @@ In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**. Er sorgt d
          fi
          trap 'flock -u 9; rm -f "$LOCK"' EXIT
 
-   log "=== Start VOD $ID ==="
+         SFTP_OPTS=(-i "${SFTP_KEY}" -P "${SFTP_PORT:-22}" -oBatchMode=yes -oStrictHostKeyChecking=accept-new)
-   log "URL: $URL"
+         SFTP_TARGET="${SFTP_USER}@${SFTP_HOST}"
-   log "DST: $DST"
 
-   # ---- Prüfe, ob die ZIELDATEI bereits existiert (nicht nur der Ordner)
+         sftp_batch() {
-   if rclone lsf "$DST" --config "$CONF" | grep -qx "${ID}.mp4"; then
+         local cmds
-   log "SKIP: $ID.mp4 bereits in Nextcloud"
+         cmds=$(printf "%s\n" "$@")
+         sftp "${SFTP_OPTS[@]}" "${SFTP_TARGET}" <<< "$cmds"
+         }
+
+         exists_remote_file() {
+         local out
+         out=$(sftp "${SFTP_OPTS[@]}" "${SFTP_TARGET}" <<< "ls -l ${REMOTE_FILE}" 2>&1 || true)
+         [[ "$out" != *"No such file"* ]] && [[ "$out" != *"not found"* ]]
+         }
+
+         log "=== Start VOD ${ID} ==="
+         log "URL: ${URL}"
+         log "DROP: ${REMOTE_FILE}"
+
+         if exists_remote_file; then
+         log "SKIP: ${REMOTE_FILE} existiert bereits"
          exit 0
          fi
 
-   # ---- Resume: unvollständigen Download sauber fortsetzen
          if [[ -s "$TEMP" && ! -s "$FILE" ]]; then
          log "RESUME: $TEMP -> $FILE"
          mv -f "$TEMP" "$FILE"
          fi
 
-   # ---- Gemeinsame rclone-Flags: Nextcloud-Chunking + robuste Timeouts
+         OUT="${TMP}/${ID}.%(ext)s"
-   export RCLONE_WEBDAV_CHUNK_SIZE=100Mi   # wirkt bei neueren rclone Versionen
-
-   rclone move "$FILE" "$DST" \
-   --config "$CONF" --create-empty-src-dirs \
-   --transfers 1 --checkers 4 \
-   --retries 10 --low-level-retries 50 --retries-sleep 30s \
-   --timeout 1h --contimeout 1m --expect-continue-timeout 10m \
-   -v
-
-   # ---- Wenn Datei schon da: nur noch hochschieben
-   if [[ -s "$FILE" ]]; then
-   log "MOVE (resume): $FILE → $DST"
-   rclone move "$FILE" "$DST" "${RCLONE_FLAGS[@]}"
-   rm -f "$PART" "$TEMP" || true
-   log "CLEANUP: $TMP"
-   rm -rf "${TMP:?}/"*
-   log "=== Done VOD $ID (resume path) ==="
-   exit 0
-   fi
-
-   # ---- Download + Remux
          yt-dlp -q --no-progress --retries 20 --fragment-retries 50 --retry-sleep 5 \
          --socket-timeout 30 --hls-prefer-ffmpeg --remux-video mp4 -o "$OUT" "$URL"
 
@@ -712,18 +699,30 @@ In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**. Er sorgt d
 
          if [[ ! -s "$FILE" ]]; then
          log "ERROR: Download fehlgeschlagen ($FILE fehlt/leer)"
-   exit 2
+         exit 10
          fi
 
-   log "MOVE: $FILE → $DST"
+         sftp_batch "mkdir ${DROP_BASE}" "mkdir ${REMOTE_DIR}"
-   rclone move "$FILE" "$DST" "${RCLONE_FLAGS[@]}"
-   rm -f "$PART" "$TEMP" || true
 
+         tries=0
+         until exists_remote_file; do
+         tries=$((tries+1))
+         log "UPLOAD Try #$tries: $FILE -> ${REMOTE_FILE}"
+         sftp_batch "reput ${FILE} ${REMOTE_FILE}" "put ${FILE} ${REMOTE_FILE}" || true
+         sleep $((2*tries))
+         [[ $tries -ge 5 ]] && break
+         done
+
+         if ! exists_remote_file; then
+         log "ERROR: Upload fehlgeschlagen"
+         exit 20
+         fi
+
+         rm -f "$PART" "$TEMP" || true
          log "CLEANUP: $TMP"
          rm -rf "${TMP:?}/"*
 
-   log "=== Done VOD $ID ==="
+         log "=== Done VOD ${ID} ==="
-   "
       ```
       Mit diesem Skript laden wir die aktuellen VODs herunter, laden sie in die Nextcloud für die weitere Verabeitung und räumen wieder auf. Zusätzlich erzeugen wir logs in `<clipper-ordner>/logs/<ID>.log`.
 
@@ -735,6 +734,85 @@ In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**. Er sorgt d
       > [!NOTE]
       > Pro VOD entsteht ein Logfile in `<clipper-ordner>/logs/<ID>.log`. Du kannst es live mit `tail -f <clipper-ordner>/logs/<ID>.log` verfolgen.
 
+   8.3 **Finalize-Skript auf dem Nextcloud-Host**
+      Nachdem der Clipper die VOD-Datei in die Drop-Zone incoming/<VOD_ID> hochgeladen hat, müssen wir diese Dateien an den endgültigen Platz in Nextcloud verschieben. Nur so erscheinen sie auch im Web-Interface. Genau dafür legen wir jetzt ein Skript an, das automatisch aufgerufen werden kann.
+
+      Das Skript übernimmt drei Aufgaben:
+      - Dateien aus der Drop-Zone verschieben in den Zielordner innerhalb von Nextcloud.
+      - Rechte setzen, damit Nextcloud (Benutzer www-data) die Dateien verwalten kann.
+      - Den Nextcloud-Dateibaum mit occ files:scan aktualisieren, damit die Dateien sofort sichtbar werden.
+
+      Wie zuvor müssen wir ein Konfigurationsdatei anlegen.
+      ```bash
+      nano /etc/nc_uploader.conf
+      ```
+      Fülle sie mit:
+      ```bash
+      NC_USER=DEIN_NC_USER                # Nextcloud-Benutzer, dem die Dateien gehören sollen
+      NC_TARGET_SUBPATH="Medien/VODs"     # Zielordner innerhalb von Nextcloud (wie er im Web erscheint)
+      NC_DATA="/var/www/nextcloud/data"   # Basis-Datenverzeichnis deiner Nextcloud-Instanz
+      DROP_BASE="/home/sftp_uploader/incoming"  # SFTP-Drop-Zone von sftp_uploader
+      PHP="/usr/bin/php"
+      OCC="/var/www/nextcloud/occ"
+      ```
+      Speichere die Datei wieder mit `STRG + O` und schließe den Editor mit `STRG + x`.
+      
+      Das folgende Skript sorgt dann dafür. dass unser eben hoch geladendes VOD an der richtigen Stelle zu finden ist und über die Weboberfläche erreichbar sein wird.
+
+      ```bash
+      nano /usr/local/bin/nc_finalize_vod.sh
+      ```
+
+      Inhalt:
+      ```bash
+      # /usr/local/bin/nc_finalize_vod.sh
+      #!/usr/bin/env bash
+      set -euo pipefail
+
+      CONF="/etc/nc_uploader.conf"
+      [[ -f "$CONF" ]] || { echo "Config fehlt: $CONF" >&2; exit 1; }
+      # shellcheck disable=SC1090
+      source "$CONF"
+
+      VOD_ID="${1:?need VOD id}"
+      FILE_BASENAME="${2:-${VOD_ID}.mp4}"
+
+      SRC_DIR="${DROP_BASE}/${VOD_ID}"
+      SRC_FILE="${SRC_DIR}/${FILE_BASENAME}"
+      DST_DIR="${NC_DATA}/${NC_USER}/files/${NC_TARGET_SUBPATH}/${VOD_ID}"
+      SCAN_PATH="${NC_USER}/files/${NC_TARGET_SUBPATH}/${VOD_ID}"
+
+      mkdir -p "$DST_DIR"
+
+      if [[ -d "$SRC_DIR" ]]; then
+      # kompletter VOD-Ordner vorhanden → verschiebe Inhalt (oder Ordner, falls leer)
+      shopt -s nullglob dotglob
+      if compgen -G "${SRC_DIR}/*" > /dev/null; then
+         mv -f "${SRC_DIR}/"* "$DST_DIR"/
+      fi
+      rmdir "$SRC_DIR" 2>/dev/null || true
+      elif [[ -f "$SRC_FILE" ]]; then
+      mv -f "$SRC_FILE" "$DST_DIR"/
+      else
+      echo "Quelle nicht gefunden: $SRC_DIR oder $SRC_FILE" >&2
+      exit 2
+      fi
+
+      chown -R www-data:www-data "$DST_DIR"
+      "$PHP" "$OCC" files:scan --path="$SCAN_PATH" --quiet
+
+      echo "OK: ${DST_DIR}"
+      ```
+      Wie zuvor auch, müssen wir die Rechte korrekt setzen, damit alles reibungslos funktioniert.
+      Gebe dazu in der Konsole
+      ```bash
+      chmod 755 /usr/local/bin/nc_finalize_vod.sh
+      chown root:root /usr/local/bin/nc_finalize_vod.sh
+      ``` 
+      ein.
+
+      Im weiteren Verlauf erstellen wir dann einen Node, der dieses Skript aufruft. Im Anschluss sollte das VOD in dem entsprechenden Ordner landen.
+
 9. **Merge – Combine** (Node-Name: `Select VODs to Download`)
    - **Node-Typ:** Merge 
    - **Mode:** Combine 
@@ -772,13 +850,24 @@ In diesem Schritt erstellen wir den eigentlichen Workflow in **n8n**. Er sorgt d
    ```bash
       <clipper-ordner>/bin/clipper-vod-get "{{$('Merge').item.json.data.id}}" "{{ $json.url || ('https://www.twitch.tv/videos/' + $('Merge').item.json.data.id) }}"
    ```
-Diese 11 Nodes werden das gesamte Grundgerüst der gesamten Automation sein. Wie aber müssen sie verbudnen werden? 
+
+13. **SSH Node 3 – Finalize** (Node-Name: Finalize VOD)
+   - Node-Typ: SSH
+   - Credentials: SSH Nextcloud (nc_runner)
+   - Operation: Execute Command
+   - Command is an Expression: ON
+   - Command:
+   ```bash
+   /usr/local/bin/nc_finalize_vod.sh {{$('Down 'n' Up').item.json.vodId}} {{$('Down 'n' Up').item.json.filename}}
+   ```
+
+Diese 12 Nodes werden das gesamte Grundgerüst der gesamten Automation sein. Wie aber müssen sie verbudnen werden? 
 Das folgende Schaubild zeigt dir die konkrete Verkabelung
 
 ```bash
-                        --- *SSH – Check State* --- *Set – File Information* --- *Set – vods in Array* --- *Split Out – vods* ------
+                        --- **SSH – Check State** --- **Set – File Information** --- **Set – vods in Array** --- **Split Out – vods** ------
                         |                                                                                                  |
-*Cron – Alle 10 Min* ---- |                                                                                                 *Select VODs to Download* --- *Einzeldurchlauf* --- *State Datei schreiben* --- *Down 'n' Up* --- (Hier folgen später weitere Nodes, aber da der Einzeldurchlauf ein Loop ist wird der letzte Node mit Einzeldurchlauf verbunden)
+**Cron – Alle 10 Min** ---- |                                                                                                 **Select VODs to Download** --- **Einzeldurchlauf** --- **State Datei schreiben** --- **Down 'n' Up** --- **Finalize VOD** (Hier folgen später weitere Nodes, aber da der Einzeldurchlauf ein Loop ist wird der letzte Node mit Einzeldurchlauf verbunden)
                         |                                                                                                  |
                         --- *Get Twitch VOD IDs* --- *Split Out* – *Twitch VOD* --------------------------------------------------
 ```