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