Add file validation and error handling in BinaryRecording and RecordNode

Fixes #679

Author: anjaldoshi

Source/Processors/RecordNode/BinaryFormat/BinaryRecording.cpp

@@ -26,6 +26,7 @@
 #include "../../Settings/DataStream.h"
 #include "../../Settings/InfoObject.h"
 
+#include "../../../CoreServices.h"
 #include "../../Events/Spike.h"
 
 #define TIC std::chrono::high_resolution_clock::now()
@@ -95,7 +96,7 @@ void BinaryRecording::openFiles (File rootFolder, int experimentNumber, int reco
         if (streamId != lastStreamId)
         {
             wroteFirstSampleNumber[streamId] = false;
-            
+
             firstChannels.add (channelInfo);
             streamIndex++;
 
@@ -120,7 +121,7 @@ void BinaryRecording::openFiles (File rootFolder, int experimentNumber, int reco
         singleChannelJSON->setProperty ("history", channelInfo->getHistoryString());
         singleChannelJSON->setProperty ("bit_volts", channelInfo->getBitVolts());
         singleChannelJSON->setProperty ("units", channelInfo->getUnits());
-        singleChannelJSON->setProperty ("type", static_cast<int>(channelInfo->getChannelType()));
+        singleChannelJSON->setProperty ("type", static_cast<int> (channelInfo->getChannelType()));
         createChannelMetadata (channelInfo, singleChannelJSON);
 
         singleStreamJSON.add (var (singleChannelJSON));
@@ -140,11 +141,14 @@ void BinaryRecording::openFiles (File rootFolder, int experimentNumber, int reco
         String datPath = getProcessorString (ch);
         String filename = contPath + datPath + "continuous.dat";
 
-        LOGD ("Creating file: ", contPath, datPath, "sample_numbers.npy");
-        ScopedPointer<NpyFile> tFile = new NpyFile (contPath + datPath + "sample_numbers.npy", NpyType (BaseType::INT64, 1));
+        String samplesPath = contPath + datPath + "sample_numbers.npy";
+        LOGD ("Creating file: ", samplesPath);
+        ScopedPointer<NpyFile> tFile = new NpyFile (samplesPath, NpyType (BaseType::INT64, 1));
         m_dataTimestampFiles.add (tFile.release());
 
-        ScopedPointer<NpyFile> syncTimestampFile = new NpyFile (contPath + datPath + "timestamps.npy", NpyType (BaseType::DOUBLE, 1));
+        String syncTimestampPath = contPath + datPath + "timestamps.npy";
+        LOGD ("Creating file: ", syncTimestampPath);
+        ScopedPointer<NpyFile> syncTimestampFile = new NpyFile (syncTimestampPath, NpyType (BaseType::DOUBLE, 1));
         m_dataSyncTimestampFiles.add (syncTimestampFile.release());
 
         DynamicObject::Ptr fileJSON = new DynamicObject();
@@ -332,7 +336,113 @@ void BinaryRecording::openFiles (File rootFolder, int experimentNumber, int reco
 
     settingsJSON->writeAsJSON (settingsFileStream, JSON::FormatOptions {}.withIndentLevel (2).withSpacing (JSON::Spacing::multiLine).withMaxDecimalPlaces (10));
 
-    
+    // Validate that all files were opened successfully
+    if (! validateOpenFiles())
+    {
+        String errorMsg = "Recording stopped! Failed to open one or more recording files. Please check disk space and write permissions.";
+
+        LOGE ("BinaryRecording::openFiles: ", errorMsg);
+
+        // Stop recording and show error message on the message thread
+        CoreServices::setRecordingStatus (false);
+        MessageManager::callAsync ([]
+                                   { CoreServices::sendStatusMessage ("Unable to start recording. Please check the console for errors."); });
+    }
+}
+
+bool BinaryRecording::validateOpenFiles() const
+{
+    bool allFilesValid = true;
+
+    // Check continuous data files (SequentialBlockFile)
+    for (int i = 0; i < m_continuousFiles.size(); i++)
+    {
+        if (m_continuousFiles[i] == nullptr)
+        {
+            allFilesValid = false;
+        }
+    }
+
+    // Check timestamp files
+    for (int i = 0; i < m_dataTimestampFiles.size(); i++)
+    {
+        if (m_dataTimestampFiles[i] == nullptr || ! m_dataTimestampFiles[i]->isOpen())
+        {
+            allFilesValid = false;
+        }
+    }
+
+    // Check sync timestamp files
+    for (int i = 0; i < m_dataSyncTimestampFiles.size(); i++)
+    {
+        if (m_dataSyncTimestampFiles[i] == nullptr || ! m_dataSyncTimestampFiles[i]->isOpen())
+        {
+            allFilesValid = false;
+        }
+    }
+
+    // Check event files
+    for (int i = 0; i < m_eventFiles.size(); i++)
+    {
+        EventRecording* rec = m_eventFiles[i];
+        if (rec != nullptr)
+        {
+            if (rec->data == nullptr || ! rec->data->isOpen())
+            {
+                allFilesValid = false;
+            }
+            if (rec->samples == nullptr || ! rec->samples->isOpen())
+            {
+                allFilesValid = false;
+            }
+            if (rec->timestamps == nullptr || ! rec->timestamps->isOpen())
+            {
+                allFilesValid = false;
+            }
+            // extraFile is optional (only for TTL full words)
+            if (rec->extraFile != nullptr && ! rec->extraFile->isOpen())
+            {
+                allFilesValid = false;
+            }
+        }
+    }
+
+    // Check spike files
+    for (int i = 0; i < m_spikeFiles.size(); i++)
+    {
+        EventRecording* rec = m_spikeFiles[i];
+        if (rec != nullptr)
+        {
+            if (rec->data == nullptr || ! rec->data->isOpen())
+            {
+                allFilesValid = false;
+            }
+            if (rec->samples == nullptr || ! rec->samples->isOpen())
+            {
+                allFilesValid = false;
+            }
+            if (rec->timestamps == nullptr || ! rec->timestamps->isOpen())
+            {
+                allFilesValid = false;
+            }
+            if (rec->channels == nullptr || ! rec->channels->isOpen())
+            {
+                allFilesValid = false;
+            }
+            if (rec->extraFile == nullptr || ! rec->extraFile->isOpen())
+            {
+                allFilesValid = false;
+            }
+        }
+    }
+
+    // Check sync text file
+    if (m_syncTextFile == nullptr)
+    {
+        allFilesValid = false;
+    }
+
+    return allFilesValid;
 }
 
 std::unique_ptr<NpyFile> BinaryRecording::createEventMetadataFile (const MetadataEventObject* channel, String filename, DynamicObject* jsonFile)
@@ -549,6 +659,9 @@ void BinaryRecording::writeContinuousData (int writeChannel,
     /* Get the file index that belongs to the current recording channel */
     int fileIndex = m_fileIndexes[writeChannel];
 
+    if (! m_continuousFiles[fileIndex])
+        return;
+
     /* Write the data to that file */
     m_continuousFiles[fileIndex]->writeChannel (
         m_samplesWritten[writeChannel],
@@ -565,7 +678,7 @@ void BinaryRecording::writeContinuousData (int writeChannel,
 
         uint32 streamId = getContinuousChannel (realChannel)->getStreamId();
 
-        if (! wroteFirstSampleNumber[streamId] )
+        if (! wroteFirstSampleNumber[streamId])
         {
             firstSampleNumber[streamId] = baseSampleNumber;
             wroteFirstSampleNumber[streamId] = true;
@@ -682,11 +795,11 @@ void BinaryRecording::writeTimestampSyncText (uint64 streamId, int64 sampleNumbe
 
     int64 fsn = firstSampleNumber[streamId];
 
-    if(streamId > 0)
+    if (streamId > 0)
         jassert (fsn == sampleNumber);
 
     m_syncTextFile->writeText (syncString + "\r\n", false, false, nullptr);
-    
+
     m_syncTextFile->flush();
 }
 

Source/Processors/RecordNode/BinaryFormat/BinaryRecording.h

@@ -89,6 +89,10 @@ class BinaryRecording : public RecordEngine
     void createChannelMetadata (const MetadataObject* channel, DynamicObject* jsonObject);
     void writeEventMetadata (const MetadataEvent* event, NpyFile* file);
     void increaseEventCounts (EventRecording* rec);
+    
+    /** Validates that all recording files were opened successfully. 
+        Returns true if all files are valid, false otherwise. */
+    bool validateOpenFiles () const;
 
     bool m_saveTTLWords { true };
 

Source/Processors/RecordNode/BinaryFormat/NpyFile.cpp

@@ -70,7 +70,7 @@ bool NpyFile::openFile (String path)
     Result res = file.create();
     if (res.failed())
     {
-        std::cerr << "Error creating file " << path << ":" << res.getErrorMessage() << std::endl;
+        LOGD ("Error creating file ", path, ": ", res.getErrorMessage());
         file.deleteFile();
         Result res = file.create();
         LOGD ("Re-creating file: ", path);
@@ -108,7 +108,7 @@ void NpyFile::writeHeader (const Array<NpyType>& typeList)
     String magicStr = "NUMPY";
     uint16 ver = 0x0001;
     // magic = magic number + magic string + magic version
-    int magicLen = int( sizeof (uint8) + magicStr.getNumBytesAsUTF8() + sizeof (uint16));
+    int magicLen = int (sizeof (uint8) + magicStr.getNumBytesAsUTF8() + sizeof (uint16));
     int nbytesAlign = 64; // header should use an integer multiple of this many bytes
 
     bool multiValue = typeList.size() > 1;
@@ -157,7 +157,7 @@ void NpyFile::writeHeader (const Array<NpyType>& typeList)
 
 void NpyFile::updateHeader()
 {
-    if (true)
+    if (m_okOpen) // only update if file opened successfully
     {
         // overwrite the shape part of the header - even without explicitly calling
         // m_file->flush(), overwriting seems to trigger a flush to disk,
@@ -251,7 +251,7 @@ int NpyType::getTypeLength() const
     if (type == BaseType::CHAR)
         return 1;
     else
-        return int(length);
+        return int (length);
 }
 
 String NpyType::getName() const

Source/Processors/RecordNode/BinaryFormat/NpyFile.h

@@ -99,6 +99,9 @@ class PLUGIN_API NpyFile
     /** Increases the count of the number of records in the file (must match the number of samples written) */
     void increaseRecordCount (int count = 1);
 
+    /** Returns true if the file was opened successfully */
+    bool isOpen() const { return m_okOpen; }
+
 private:
     /** Opens the file at a specified path */
     bool openFile (String path);

Source/Processors/RecordNode/BinaryFormat/SequentialBlockFile.cpp

@@ -44,7 +44,8 @@ SequentialBlockFile::~SequentialBlockFile()
     }
 
     //manually flush the last one to avoid trailing zeroes
-    m_memBlocks[0]->partialFlush (m_lastBlockFill * m_nChannels);
+    if (m_memBlocks.size() > 0)
+        m_memBlocks[0]->partialFlush (m_lastBlockFill * m_nChannels);
 }
 
 bool SequentialBlockFile::openFile (String filename)
@@ -53,7 +54,7 @@ bool SequentialBlockFile::openFile (String filename)
     Result res = file.create();
     if (res.failed())
     {
-        std::cerr << "Error creating file " << filename << ":" << res.getErrorMessage() << std::endl;
+        LOGD ("Error creating file ", filename, ": ", res.getErrorMessage());
         file.deleteFile();
         Result res = file.create();
         LOGD ("Re-creating file: ", filename);
@@ -104,7 +105,7 @@ bool SequentialBlockFile::writeChannel (uint64 startPos, int channel, int16* dat
     while (writtenSamples < nSamples)
     {
         int16* blockPtr = m_memBlocks[bIndex]->getData();
-        int samplesToWrite = jmin ((nSamples - writtenSamples), (m_samplesPerBlock - int(startIdx)));
+        int samplesToWrite = jmin ((nSamples - writtenSamples), (m_samplesPerBlock - int (startIdx)));
 
         for (int i = 0; i < samplesToWrite; i++)
         {

Source/Processors/RecordNode/RecordNode.cpp

@@ -865,7 +865,24 @@ void RecordNode::startRecording()
 
     if (! rootFolder.exists())
     {
-        rootFolder.createDirectory();
+        Result res = rootFolder.createDirectory();
+        if (res.failed())
+        {
+            LOGE ("Record Node " + String (getNodeId()) + ": Could not create directory: " + rootFolder.getFullPathName(), " -- ", res.getErrorMessage());
+
+            CoreServices::setRecordingStatus (false);
+
+            if (! headlessMode)
+            {
+                AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon,
+                                                  "Recording Error",
+                                                  "Record Node " + String (getNodeId()) + " - Could not create recording directory:\n\n"
+                                                      + rootFolder.getFullPathName() + "\n\n"
+                                                      + res.getErrorMessage());
+            }
+
+            return;
+        }
     }
 
     recordThread->setFileComponents (rootFolder, experimentNumber, recordingNumber);
@@ -889,6 +906,9 @@ void RecordNode::startRecording()
 // called by GenericProcessor::setRecording() and CoreServices::setRecordingStatus()
 void RecordNode::stopRecording()
 {
+    if (! isRecording)
+        return;
+
     isRecording = false;
     hasRecorded = true;
     recordingNumber++; // increment recording number within this directory; should be zero for first recording

Source/UI/ControlPanel.cpp

@@ -1048,10 +1048,10 @@ void ControlPanel::startRecording()
 
     filenameComponent->setEnabled (false);
 
-    graph->setRecordState (true);
-
     LOGC ("Starting recording");
 
+    graph->setRecordState (true);
+
     repaint();
 }