Feature releases

color-coded storage bar, user-controlled keep-awake timer, clip deletion snapshot sync

Author: ChadR23

server/api/drives.go

@@ -199,11 +199,11 @@ func archiveLog(format string, args ...interface{}) {
 	fmt.Fprintf(f, "%s: [drive-map] %s\n", time.Now().Format("Mon 02 Jan 15:04:05 MST 2006"), msg)
 }
 
-// isArchiving returns true if the archiveloop is currently archiving files.
+// IsArchiving returns true if the archiveloop is currently archiving files.
 // The archive_progress_monitor updates the status file every 5s, so if it
 // hasn't been touched in over 120s, treat it as stale (archiveloop crashed
 // or forgot to clear it).
-func isArchiving() bool {
+func IsArchiving() bool {
 	const statusFile = "/tmp/archive_status.json"
 	info, err := os.Stat(statusFile)
 	if err != nil {
@@ -262,7 +262,7 @@ func (dh *DriveHandlers) processFiles(w http.ResponseWriter, r *http.Request) {
 	// post_archive=1 is set by post-archive-process.sh which runs after
 	// archiving is complete.  Skip the stale-file check in that case.
 	postArchive := r.URL.Query().Get("post_archive") == "1"
-	if !postArchive && isArchiving() {
+	if !postArchive && IsArchiving() {
 		writeError(w, http.StatusConflict, "archive is currently running — please wait until it finishes")
 		return
 	}
@@ -346,7 +346,7 @@ func (dh *DriveHandlers) reprocessAll(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusConflict, "processing already in progress")
 		return
 	}
-	if isArchiving() {
+	if IsArchiving() {
 		writeError(w, http.StatusConflict, "archive is currently running — please wait until it finishes")
 		return
 	}
@@ -409,7 +409,7 @@ func (dh *DriveHandlers) processingStatus(w http.ResponseWriter, r *http.Request
 		"running":         dh.processor.IsRunning(),
 		"routes_count":    dh.store.RouteCount(),
 		"processed_count": dh.store.ProcessedCount(),
-		"archiving":       isArchiving(),
+		"archiving":       IsArchiving(),
 	}
 
 	if archive := readArchiveStatus(); archive != nil {
@@ -503,18 +503,18 @@ func (dh *DriveHandlers) driveStats(w http.ResponseWriter, r *http.Request) {
 	}
 
 	writeJSON(w, http.StatusOK, map[string]interface{}{
-		"drives_count":          len(allDrives),
-		"routes_count":          len(routes),
-		"processed_count":       dh.store.ProcessedCount(),
-		"total_distance_km":     math.Round(totalDistKm*100) / 100,
-		"total_distance_mi":     math.Round(totalDistMi*100) / 100,
-		"total_duration_ms":     totalDurationMs,
-		"fsd_engaged_ms":        totalFSDEngagedMs,
-		"fsd_distance_km":       math.Round(totalFSDDistKm*100) / 100,
-		"fsd_distance_mi":       math.Round(totalFSDDistMi*100) / 100,
-		"fsd_percent":           fsdPercent,
-		"fsd_disengagements":    totalDisengagements,
-		"fsd_accel_pushes":      totalAccelPushes,
+		"drives_count":       len(allDrives),
+		"routes_count":       len(routes),
+		"processed_count":    dh.store.ProcessedCount(),
+		"total_distance_km":  math.Round(totalDistKm*100) / 100,
+		"total_distance_mi":  math.Round(totalDistMi*100) / 100,
+		"total_duration_ms":  totalDurationMs,
+		"fsd_engaged_ms":     totalFSDEngagedMs,
+		"fsd_distance_km":    math.Round(totalFSDDistKm*100) / 100,
+		"fsd_distance_mi":    math.Round(totalFSDDistMi*100) / 100,
+		"fsd_percent":        fsdPercent,
+		"fsd_disengagements": totalDisengagements,
+		"fsd_accel_pushes":   totalAccelPushes,
 	})
 }
 
@@ -561,12 +561,12 @@ func (dh *DriveHandlers) fsdAnalytics(w http.ResponseWriter, r *http.Request) {
 
 	// Daily breakdown
 	type dayStats struct {
-		Date             string  `json:"date"`
-		DayName          string  `json:"dayName"`
-		Disengagements   int     `json:"disengagements"`
-		AccelPushes      int     `json:"accelPushes"`
-		FSDPercent       float64 `json:"fsdPercent"`
-		Drives           int     `json:"drives"`
+		Date           string  `json:"date"`
+		DayName        string  `json:"dayName"`
+		Disengagements int     `json:"disengagements"`
+		AccelPushes    int     `json:"accelPushes"`
+		FSDPercent     float64 `json:"fsdPercent"`
+		Drives         int     `json:"drives"`
 	}
 	dailyMap := make(map[string]*dayStats)
 

server/api/files.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -225,6 +226,13 @@ func (h *handlers) deleteFile(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// If deleted path was under SavedClips or SentryClips, clean up
+	// matching symlinks in snapshot directories so those clips won't
+	// be re-synced on next archive. RecentClips are left untouched.
+	if strings.Contains(cleanPath, "/SavedClips/") || strings.Contains(cleanPath, "/SentryClips/") {
+		go cleanupSnapshotSymlinks(cleanPath)
+	}
+
 	writeOK(w)
 }
 
@@ -330,3 +338,109 @@ func (h *handlers) downloadZip(w http.ResponseWriter, r *http.Request) {
 
 	w.Write([]byte(output))
 }
+
+// cleanupSnapshotSymlinks removes symlinks in snapshot directories that
+// correspond to a deleted SavedClips or SentryClips path. This prevents
+// deleted clips from being re-archived on the next sync.
+//
+// The snapshot layout is:
+//
+//	/backingfiles/snapshots/snap-NNNNNN/mnt/TeslaCam/{SavedClips,SentryClips}/<event>/<file>.mp4
+//
+// and the mutable layout is:
+//
+//	/mutable/TeslaCam/{SavedClips,SentryClips}/<event>/<file>.mp4
+//
+// Both contain symlinks pointing into the snapshot mount.
+func cleanupSnapshotSymlinks(deletedPath string) {
+	// Determine the clip type and event folder name from the deleted path.
+	// Expected patterns:
+	//   /mutable/TeslaCam/SavedClips/<event>
+	//   /mutable/TeslaCam/SentryClips/<event>
+	//   /mutable/TeslaCam/SavedClips/<event>/<file>
+	var clipType, eventName string
+	for _, ct := range []string{"SavedClips", "SentryClips"} {
+		marker := "/" + ct + "/"
+		idx := strings.Index(deletedPath, marker)
+		if idx >= 0 {
+			clipType = ct
+			rest := deletedPath[idx+len(marker):]
+			parts := strings.SplitN(rest, "/", 2)
+			if len(parts) > 0 {
+				eventName = parts[0]
+			}
+			break
+		}
+	}
+
+	if clipType == "" || eventName == "" {
+		return
+	}
+
+	log.Printf("[files] Cleaning up snapshot symlinks for %s/%s", clipType, eventName)
+
+	// Walk all snapshot directories looking for matching event folders
+	snapshotsBase := "/backingfiles/snapshots"
+	entries, err := os.ReadDir(snapshotsBase)
+	if err != nil {
+		return
+	}
+
+	for _, snapEntry := range entries {
+		if !snapEntry.IsDir() || !strings.HasPrefix(snapEntry.Name(), "snap-") {
+			continue
+		}
+
+		// Check for the event folder in this snapshot's clip type directory
+		eventDir := filepath.Join(snapshotsBase, snapEntry.Name(), "mnt", "TeslaCam", clipType, eventName)
+		if _, err := os.Stat(eventDir); err != nil {
+			continue
+		}
+
+		// Remove all symlinks in this event directory
+		clipEntries, err := os.ReadDir(eventDir)
+		if err != nil {
+			continue
+		}
+		for _, ce := range clipEntries {
+			linkPath := filepath.Join(eventDir, ce.Name())
+			fi, err := os.Lstat(linkPath)
+			if err != nil {
+				continue
+			}
+			if fi.Mode()&os.ModeSymlink != 0 {
+				os.Remove(linkPath)
+			}
+		}
+
+		// Remove the event directory if now empty
+		remaining, _ := os.ReadDir(eventDir)
+		if len(remaining) == 0 {
+			os.Remove(eventDir)
+		}
+	}
+
+	// Also clean up broken symlinks in /mutable/TeslaCam/<clipType>/<eventName>
+	mutableEventDir := filepath.Join("/mutable/TeslaCam", clipType, eventName)
+	if entries, err := os.ReadDir(mutableEventDir); err == nil {
+		for _, e := range entries {
+			linkPath := filepath.Join(mutableEventDir, e.Name())
+			fi, err := os.Lstat(linkPath)
+			if err != nil {
+				continue
+			}
+			if fi.Mode()&os.ModeSymlink != 0 {
+				// Check if target still exists
+				if _, err := os.Stat(linkPath); err != nil {
+					os.Remove(linkPath)
+				}
+			}
+		}
+		remaining, _ := os.ReadDir(mutableEventDir)
+		if len(remaining) == 0 {
+			os.Remove(mutableEventDir)
+		}
+	}
+
+	log.Printf("[files] Snapshot symlink cleanup complete for %s/%s", clipType, eventName)
+}