eddy/dashcam-transfer
Watch
1
0
Fork
You've already forked dashcam-transfer
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

docs: documenteer dashcam automount configuratie op nextcloud

Browse source
This commit is contained in:
Eddy de Vink 2026-06-02 21:46:10 +02:00
commit e69b9de577
2 changed files with 346 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

68
README.md
View file

@ -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 `front/`/`back/` structuur. Hierbij zijn bestanden gesorteerd op basis van de
camera-suffix in de bestandsnaam. 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 ```ini
[Unit] [Unit]
@ -113,13 +157,23 @@ After=mnt-sdcard.mount
[Service] [Service]
Type=oneshot Type=oneshot
ExecStart=/usr/local/bin/dashcam-transfer ExecStart=/usr/local/bin/dashcam-transfer
User=root
``` ```
### Udev rule #### `/etc/fstab` (SD card niet in fstab — wordt gemount door trigger)
```udev ```ini
ACTION=="add", KERNEL=="sdd1", RUN+="/usr/local/bin/dashcam-transfer-trigger" 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 SSD wordt gemount via systemd automount (permanent aangesloten).
wacht tot de automount actief is en dan het Python-script start.
### 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`.

285
docs/superpowers/plans/2026-06-02-automount-transfer.md Normal file
View file

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