add function to delete old recordings when more space is requested

Author: samfreund

photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDriverStation.java

@@ -134,6 +134,56 @@ public String printMatchData() {
         return message;
     }
 
+    /**
+     * Compares two match data strings and returns a negative, 0, or a postive if the first is less
+     * than, equal to, or greater than the second.
+     *
+     * @param first
+     * @param second
+     * @return a negative, 0, or a positive if the first is less than, equal to, or greater than the
+     *     second
+     */
+    public static int compareMatchData(String first, String second) {
+        String[] firstParts = first.split(", ");
+        String[] secondParts = second.split(", ");
+
+        String firstMatchInfo = firstParts[1].split(" ")[1];
+        String secondMatchInfo = secondParts[1].split(" ")[1];
+
+        String firstType = firstMatchInfo.substring(0, 1);
+        String secondType = secondMatchInfo.substring(0, 1);
+
+        int firstCmp;
+        int secondCmp;
+        switch (firstType) {
+            case "P" -> firstCmp = 1;
+            case "Q" -> firstCmp = 2;
+            case "E" -> firstCmp = 3;
+            default -> firstCmp = 0;
+        }
+        switch (secondType) {
+            case "P" -> secondCmp = 1;
+            case "Q" -> secondCmp = 2;
+            case "E" -> secondCmp = 3;
+            default -> secondCmp = 0;
+        }
+
+        if (Integer.compare(firstCmp, secondCmp) != 0) {
+            return Integer.compare(firstCmp, secondCmp);
+        }
+
+        // same type, compare match numbers
+        int firstMatchNumber = Integer.parseInt(firstMatchInfo.substring(1));
+        int secondMatchNumber = Integer.parseInt(secondMatchInfo.substring(1));
+        if (Integer.compare(firstMatchNumber, secondMatchNumber) != 0) {
+            return Integer.compare(firstMatchNumber, secondMatchNumber);
+        }
+        // same match number, compare replay numbers
+        int firstReplay = Integer.parseInt(firstParts[2].split(" ")[1]);
+        int secondReplay = Integer.parseInt(secondParts[2].split(" ")[1]);
+        return Integer.compare(firstReplay, secondReplay);
+    }
+
     // Copied from
     // https://github.com/wpilibsuite/allwpilib/blob/07192285f65321a2f7363227a2216f09b715252d/hal/src/main/java/edu/wpi/first/hal/DriverStationJNI.java#L123C1-L140C4
     // TODO: upstream!

photon-core/src/main/java/org/photonvision/common/hardware/HardwareManager.java

@@ -20,12 +20,16 @@
 import edu.wpi.first.networktables.IntegerPublisher;
 import edu.wpi.first.networktables.IntegerSubscriber;
 import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 import org.photonvision.common.configuration.ConfigManager;
 import org.photonvision.common.configuration.HardwareConfig;
 import org.photonvision.common.configuration.HardwareSettings;
+import org.photonvision.common.configuration.PathManager;
 import org.photonvision.common.dataflow.networktables.NTDataChangeListener;
+import org.photonvision.common.dataflow.networktables.NTDriverStation;
 import org.photonvision.common.dataflow.networktables.NetworkTablesManager;
 import org.photonvision.common.hardware.GPIO.CustomGPIO;
 import org.photonvision.common.hardware.GPIO.pi.PigpioSocket;
@@ -228,4 +232,89 @@ private void statusLEDUpdate() {
     public void publishMetrics() {
         metricsManager.publishMetrics();
     }
+
+    /**
+     * Ensures there is enough space for new recordings by clearing stored recordings to free up disk
+     * space. This method should delete the oldest recordings, prioritizing recordings from matches
+     * over practice sessions regardless of age.
+     *
+     * @param requestedSpace The amount of space to free in MB
+     * @return true if enough space was cleared, false otherwise
+     */
+    public boolean reserveRecordingSpace(double requestedSpace) {
+        if (metricsManager.getDiskSpaceAvailable() > requestedSpace * 1024) {
+            return true; // Enough space already available
+        }
+
+        Path recordingsDir = PathManager.getInstance().getRootFolder().resolve("recordings");
+
+        // Create a list of all the recordings
+        ArrayList<Path> recordings = new ArrayList<>();
+        try {
+            if (!java.nio.file.Files.exists(recordingsDir)
+                    || !java.nio.file.Files.isDirectory(recordingsDir)) {
+                logger.error("Recordings directory does not exist");
+                return false; // No recordings directory
+            }
+
+            try (var cameraStream = java.nio.file.Files.list(recordingsDir)) {
+                cameraStream
+                        .filter(java.nio.file.Files::isDirectory)
+                        .forEach(
+                                cameraDir -> {
+                                    try (var recStream = java.nio.file.Files.list(cameraDir)) {
+                                        recStream.filter(java.nio.file.Files::isDirectory).forEach(recordings::add);
+                                    } catch (Exception e) {
+                                        // skip unreadable camera folder
+                                    }
+                                });
+            }
+        } catch (Exception e) {
+            return false; // Unable to list recordings
+        }
+
+        if (recordings.isEmpty()) {
+            return false; // No recordings to delete
+        }
+
+        // Create practice list and match list
+        ArrayList<Path> matchRecordings = new ArrayList<>();
+        ArrayList<Path> practiceRecordings = new ArrayList<>();
+
+        for (Path rec : recordings) {
+            String dirName = rec.getFileName().toString().toLowerCase();
+            if (dirName.startsWith("event")) {
+                matchRecordings.add(rec);
+            } else {
+                practiceRecordings.add(rec);
+            }
+        }
+
+        // Sort both lists based on solely the filename
+        matchRecordings.sort(
+                (a, b) ->
+                        NTDriverStation.compareMatchData(
+                                a.getFileName().toString(), b.getFileName().toString()));
+        practiceRecordings.sort(
+                (a, b) -> a.getFileName().toString().compareTo(b.getFileName().toString()));
+
+        while (requestedSpace * 1024
+                > HardwareManager.getInstance().metricsManager.getDiskSpaceAvailable()) {
+            Path toDelete = null;
+            if (!practiceRecordings.isEmpty()) {
+                toDelete = practiceRecordings.remove(0);
+            } else if (!matchRecordings.isEmpty()) {
+                toDelete = matchRecordings.remove(0);
+            } else {
+                return false; // No recordings left to delete
+            }
+            try {
+                java.nio.file.Files.delete(toDelete);
+            } catch (Exception e) {
+                // Ignore errors during deletion
+            }
+        }
+
+        return true;
+    }
 }