diff --git a/README.md b/README.md index fd71507..3872c36 100644 --- a/README.md +++ b/README.md @@ -101,9 +101,53 @@ Het `restructure.py` script heeft alle historische data omgezet naar de uniforme `front/`/`back/` structuur. Hierbij zijn bestanden gesorteerd op basis van de camera-suffix in de bestandsnaam. -## Automatisering (nog in te richten) +## Automatisering -### Systemd service +### Architectuur + +``` +USB insert → udev detecteert vendor:product 14cd:1212 + → systemd-run start mount script (niet direct vanuit udev i.v.m. rechten) + → wacht tot /dev/disk/by-uuid/00D3-7715 verschijnt + → umount eventuele stale mounts + → mount UUID op /mnt/sdcard + → start dashcam-transfer service + → Python script kopieert MP4's naar SSD +``` + +**SD kaart wordt altijd op UUID gemount** — ongeacht USB poort. + +### Configuratiebestanden op de server + +#### `/etc/udev/rules.d/99-dashcam-trigger.rules` + +```udev +ACTION=="add", SUBSYSTEM=="block", KERNEL=="sd*[0-9]", ENV{ID_VENDOR_ID}=="14cd", ENV{ID_MODEL_ID}=="1212", RUN+="/usr/bin/systemd-run --no-block --collect /usr/local/bin/dashcam-transfer-mount" +``` + +`systemd-run` draait het script in systemd context (niet udev) — essentieel voor correcte `mount`/`umount` rechten. + +#### `/usr/local/bin/dashcam-transfer-mount` + +```bash +#!/bin/bash +UUID=/dev/disk/by-uuid/00D3-7715 +logger -t dashcam-transfer Trigger: SD card detected +# Wacht tot UUID symlink beschikbaar is +for ((i=0; i<60; i++)); do + if [ -e "$UUID" ]; then break; fi + sleep 1 +done +# Verwijder stale mounts van eerdere USB-poort +while mountpoint -q /mnt/sdcard; do + umount /mnt/sdcard || break +done +# Mount via UUID (werkt ongeacht /dev/sdb1/sdd1/sde1) +mount "$UUID" /mnt/sdcard -o uid=1000,gid=1000,fmask=0000,dmask=0000 +systemctl start dashcam-transfer +``` + +#### `/etc/systemd/system/dashcam-transfer.service` ```ini [Unit] @@ -113,13 +157,23 @@ After=mnt-sdcard.mount [Service] Type=oneshot ExecStart=/usr/local/bin/dashcam-transfer +User=root ``` -### Udev rule +#### `/etc/fstab` (SD card niet in fstab — wordt gemount door trigger) -```udev -ACTION=="add", KERNEL=="sdd1", RUN+="/usr/local/bin/dashcam-transfer-trigger" +```ini +UUID=3027-8ECA /mnt/ultratouch exfat noauto,x-systemd.automount,uid=1000,gid=1000,dmask=0000,fmask=0000 0 0 ``` -Waarbij `dashcam-transfer-trigger` een kort bash-script is dat enkele seconden -wacht tot de automount actief is en dan het Python-script start. +SSD wordt gemount via systemd automount (permanent aangesloten). + +### SD kaart UUID + +Bij format verandert de UUID. Om de juiste UUID te vinden: + +```bash +sudo blkid /dev/sdX1 +``` + +Update vervolgens de `UUID=...` variabele in `/usr/local/bin/dashcam-transfer-mount`. diff --git a/docs/superpowers/plans/2026-06-02-automount-transfer.md b/docs/superpowers/plans/2026-06-02-automount-transfer.md new file mode 100644 index 0000000..75e1800 --- /dev/null +++ b/docs/superpowers/plans/2026-06-02-automount-transfer.md @@ -0,0 +1,285 @@ +# Dashcam SD Card Automount & Transfer Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Automatische dashcam transfer die betrouwbaar start zodra de SD kaart wordt ingestoken, ongeacht USB poort. + +**Architecture:** Statische systemd `.automount` + `.mount` units op UUID voor zowel SD kaart als SSD. Udev rule triggert alleen het transfer script. Trigger script pollt condition-based op mount unit status. + +**Tech Stack:** systemd (automount/mount units), udev (device detectie), bash (trigger), Python (transfer script) + +## Device info + +| Device | UUID | Vendor:Product | Label | +|---|---|---|---| +| SD kaart (partitie 1) | `00D3-7715` | `14cd:1212` (Super Top microSD reader) | — | +| SSD (partitie 2) | `3027-8ECA` | `0bc2:2065` (Seagate Ultra Touch) | Ultra Touch | + +| Pad | Device | +|---|---| +| `/mnt/sdcard` | SD kaart | +| `/mnt/ultratouch` | Seagate SSD | + +## Probleemanalyse (geleerd uit sessie) + +### 1. `systemd-mount --automount=yes` faalt +Udev rule matched op `KERNEL=="sd*[0-9]"` (device name). Transient automount units van eerdere inserties blokkeren nieuwe device names. Resultaat: exit 1. + +### 2. UUID device timeout +Na SD kaart insertie duurt het even voordat de exfat partition herkend wordt. `dev-disk-by-uuid-00D3-7715.device` kreeg een timeout in eerste tests. Mogelijk opgelost door oude udev rules te verwijderen (die vochten met de automount unit), maar dit moet geverifieerd worden. + +### 3. Concurrente systemd-mount en automount +Als zowel de oude udev rule `systemd-mount` als de nieuwe automount unit actief zijn, vechten ze om `/mnt/sdcard`. De automount unit wint niet altijd. + +### 4. `systemd-umount` via udev zet automount uit +De udev remove rule riep `systemd-umount /mnt/sdcard` aan, wat de hele automount unit deactiveerde. Na opnieuw insteken was de automount weg en moest hij handmatig herstart worden. + +--- + +## Taken + +### Task 1: SSD automount op UUID (doen vóór SD kaart — de SSD is permanent aangesloten) + +**Waarom eerst:** De SSD is permanent verbonden. Als we die eerst proper configureren, hebben we een werkende mount voor de transfer doel. De SD kaart is de variabele factor. + +**Files:** +- Create: `/etc/systemd/system/mnt-ultratouch.mount` (op server) +- Create: `/etc/systemd/system/mnt-ultratouch.automount` (op server) + +- [ ] **Step 1: Maak `/etc/systemd/system/mnt-ultratouch.mount`** + +```ini +[Unit] +Description=Mount Ultra Touch SSD + +[Mount] +What=/dev/disk/by-uuid/3027-8ECA +Where=/mnt/ultratouch +Type=exfat +Options=uid=1000,gid=1000,dmask=0000,fmask=0000 +``` + +- [ ] **Step 2: Maak `/etc/systemd/system/mnt-ultratouch.automount`** + +```ini +[Unit] +Description=Automount Ultra Touch SSD + +[Automount] +Where=/mnt/ultratouch +TimeoutIdleSec=0 + +[Install] +WantedBy=multi-user.target +``` + +- [ ] **Step 3: Stop oude transient automount (if any), enable nieuwe** + +```bash +sudo -A systemctl stop mnt-ultratouch.automount mnt-ultratouch.mount 2>/dev/null || true +sudo -A umount /mnt/ultratouch 2>/dev/null || true +sudo -A systemctl daemon-reload +sudo -A systemctl enable --now mnt-ultratouch.automount +``` + +- [ ] **Step 4: Verifieer** + +```bash +systemctl status mnt-ultratouch.automount --no-pager +ls /mnt/ultratouch/ +``` + +Verwacht: automount `active (waiting)`, ls toont bestanden en mount wordt `active (mounted)` + +--- + +### Task 2: SD card automount op UUID + +**Files:** +- Create: `/etc/systemd/system/mnt-sdcard.mount` (op server) +- Create: `/etc/systemd/system/mnt-sdcard.automount` (op server) + +- [ ] **Step 1: Maak `/etc/systemd/system/mnt-sdcard.mount`** + +```ini +[Unit] +Description=Mount SD card + +[Mount] +What=/dev/disk/by-uuid/00D3-7715 +Where=/mnt/sdcard +Type=exfat +Options=uid=1000,gid=1000,dmask=0000,fmask=0000 +``` + +- [ ] **Step 2: Maak `/etc/systemd/system/mnt-sdcard.automount`** + +```ini +[Unit] +Description=Automount SD card + +[Automount] +Where=/mnt/sdcard +TimeoutIdleSec=0 + +[Install] +WantedBy=multi-user.target +``` + +- [ ] **Step 3: Enable (SD kaart moet eruit zijn)** + +```bash +sudo -A systemctl daemon-reload +sudo -A systemctl enable --now mnt-sdcard.automount +``` + +- [ ] **Step 4: Verifieer automount actief** + +```bash +systemctl status mnt-sdcard.automount --no-pager +``` + +Verwacht: `active (waiting)` + +- [ ] **Step 5: SD kaart insteken en testen** + +```bash +ls /mnt/sdcard/Novatek/Movie/ | head -3 +systemctl status mnt-sdcard.mount --no-pager +``` + +Verwacht: bestanden zichtbaar, mount `active (mounted)` + +- [ ] **Step 6: SD kaart verwijderen en opnieuw insteken** + +Test de volledige cycle: remove → automount blijft `active (waiting)` → insert → ls trigger → mount `active (mounted)` + +**Let op:** Als de automount na remove inactive wordt, is er iets mis met de remove handling. Onderzoek dan of er ergens `systemd-umount` wordt aangeroepen. + +--- + +### Task 3: Udev rule — alleen trigger, geen mount commands + +**Belangrijk:** Deze rule mag **geen** `systemd-mount`, `systemd-umount` of andere mount commands bevatten. Alleen de trigger voor het transfer script. + +**Files:** +- Create: `/etc/udev/rules.d/99-dashcam-trigger.rules` (op server) + +- [ ] **Step 1: Maak udev rule** + +```udev +# Dashcam SD card reader — trigger transfer script +# Mounting wordt gedaan door systemd automount unit (mnt-sdcard.automount) +ACTION=="add", SUBSYSTEM=="block", KERNEL=="sd*[0-9]", ENV{ID_VENDOR_ID}=="14cd", ENV{ID_MODEL_ID}=="1212", RUN+="/usr/local/bin/dashcam-transfer-trigger" +``` + +**Geen remove rule.** De automount unit met `TimeoutIdleSec=0` zal niet automatisch unmounten. Als de SD kaart fysiek verwijderd wordt, zal systemd de mount degraderen (device verdwijnt). Bij opnieuw insteken herkent de automount unit de UUID en mount opnieuw. + +- [ ] **Step 2: Herlaad udev** + +```bash +sudo -A udevadm control --reload-rules +``` + +--- + +### Task 4: Trigger script met condition-based waiting + +**Files:** +- Create: `/usr/local/bin/dashcam-transfer-trigger` (op server) + +- [ ] **Step 1: Maak het trigger script** + +```bash +#!/bin/bash +# Trigger script for dashcam-transfer +# Wacht tot systemd automount /mnt/sdcard mounted heeft, dan start transfer +# Pollt condition-based op mnt-sdcard.mount unit status + +logger -t dashcam-transfer Trigger: SD card detected + +for ((i=0; i<180; i++)); do + if systemctl is-active --quiet mnt-sdcard.mount 2>/dev/null; then + logger -t dashcam-transfer Trigger: mounted after ${i}s, starting transfer + /usr/bin/systemd-run --no-block --unit=dashcam-transfer --description='Dashcam SD card transfer' /usr/local/bin/dashcam-transfer + exit 0 + fi + sleep 1 +done + +logger -t dashcam-transfer TRIGGER ERROR: mount not active after 180s +exit 1 +``` + +- [ ] **Step 2: Maak executable** + +```bash +sudo -A chmod +x /usr/local/bin/dashcam-transfer-trigger +``` + +--- + +### Task 5: Dashcam transfer systemd service herstellen + +**Files:** +- Create: `/etc/systemd/system/dashcam-transfer.service` (op server) + +- [ ] **Step 1: Maak service file** + +```ini +[Unit] +Description=Dashcam SD card transfer +After=mnt-sdcard.mount + +[Service] +Type=oneshot +ExecStart=/usr/local/bin/dashcam-transfer +User=root +``` + +De service wordt niet enabled — hij wordt gestart via `systemd-run` vanuit het trigger script. + +--- + +### Task 6: E2E test — SD kaart eruit en erin + +- [ ] **Step 1: SD kaart verwijderen** + +- [ ] **Step 2: Verifieer automount blijft actief** + +```bash +systemctl status mnt-sdcard.automount --no-pager +``` + +Verwacht: `active (waiting)` (niet inactive!) + +- [ ] **Step 3: Monitoring starten** + +```bash +journalctl -t dashcam-transfer -f +``` + +- [ ] **Step 4: SD kaart insteken** + +Verwachte flow: +1. udev detecteert device → roept trigger script aan +2. Trigger pollt `mnt-sdcard.mount` status +3. Automount mount automatisch zodra de UUID device beschikbaar is +4. Trigger detecteert active mount → start transfer via systemd-run +5. Transfer logt naar `/tmp/dashcam-transfer.log` + +- [ ] **Step 5: Verifieer transfer log en bestanden** + +```bash +tail -20 /tmp/dashcam-transfer.log +ls /mnt/ultratouch/dashcam/$(date +%Y%m%d)/ +``` + +--- + +## Opmerkingen + +- SD kaart UUID kan veranderen bij format. Updaten in `.mount` file. +- `TimeoutIdleSec=0` betekent: niet auto-unmounten. De SSD is permanent, de SD kaart wordt fysiek verwijderd. +- SELinux: Enforcing. exfat mounts met `uid=1000,gid=1000` zouden moeten werken. Eventuele AVC denials oplossen met SELinux policy module. +- De SSD automount neemt de functie over van de oude udev `systemd-mount` regel. Die regel hoeft niet meer.