WIP: Seperate commits into each bug fix

Author: medengineer

Source/Processors/ProcessorGraph/ProcessorGraph.cpp

@@ -1083,7 +1083,7 @@ void ProcessorGraph::updateUndoableActions (int nodeId)
     for (auto action : getUndoableActions (nodeId))
     {
         GenericProcessor* p = getProcessorWithNodeId (nodeId);
-        p->update();
+        //p->update();
         action->restoreOwner (p);
     }
 }

Source/Processors/RecordNode/DiskMonitor/DiskSpaceChecker.cpp

@@ -124,7 +124,13 @@ void DiskSpaceChecker::update (float dataRate, int64 bytesFree, float timeLeft)
         if (listener != nullptr)
         {
             juce::MessageManager::callAsync ([listener, dataRate, bytesFree, timeLeft]()
-                                             { listener->update (dataRate, bytesFree, timeLeft); });
+            {
+                try {
+                    listener->update (dataRate, bytesFree, timeLeft);
+                } catch (const std::exception& e) {
+                    LOGE("Error updating disk space listener: ", e.what());
+                }
+            });
         }
     }
 }
@@ -137,7 +143,13 @@ void DiskSpaceChecker::notifyDiskSpaceRemaining (float percentage)
         if (listener != nullptr)
         {
             juce::MessageManager::callAsync ([listener, percentage]()
-                                             { listener->updateDiskSpace (percentage); });
+            {
+                try {
+                    listener->updateDiskSpace (percentage);
+                } catch (const std::exception& e) {
+                    LOGE("Error updating disk space percentage: ", e.what());
+                }
+            });
         }
     }
 }
@@ -150,7 +162,13 @@ void DiskSpaceChecker::notifyDirectoryInvalid()
         if (listener != nullptr)
         {
             juce::MessageManager::callAsync ([listener]()
-                                             { listener->directoryInvalid(); });
+            {
+                try {
+                    listener->directoryInvalid();
+                } catch (const std::exception& e) {
+                    LOGE("Error notifying directory invalid: ", e.what());
+                }
+            });
         }
     }
 }
@@ -163,7 +181,13 @@ void DiskSpaceChecker::notifyLowDiskSpace()
         if (listener != nullptr)
         {
             juce::MessageManager::callAsync ([listener]()
-                                             { listener->lowDiskSpace(); });
+            {
+                try {
+                    listener->lowDiskSpace();
+                } catch (const std::exception& e) {
+                    LOGE("Error notifying low disk space: ", e.what());
+                }
+            });
         }
     }
 }

Source/Processors/RecordNode/RecordNode.cpp

@@ -146,7 +146,8 @@ void RecordNode::parameterValueChanged (Parameter* p)
     {
         int selectedIdx = ((CategoricalParameter*) p)->getSelectedIndex();
         setEngine (getAvailableRecordEngines()[selectedIdx]->getID());
-        createNewDirectory();
+        // NOTE: Any record engine change will create a new directory for all record nodes to prevent data loss in edge cases
+        CoreServices::createNewRecordingDirectory();
     }
     else if (p->getName() == "events")
     {

Source/Utils/OpenEphysHttpServer.h

@@ -784,22 +784,31 @@ class OpenEphysHttpServer : juce::Thread
 
         svr_->Get ("/api/processors/clear", [this] (const httplib::Request&, httplib::Response& res)
                    {
-
             String return_msg;
 
             if (!CoreServices::getAcquisitionStatus())
             {
                 std::promise<void> signalChainCleared;
                 std::future<void> signalChainClearedFuture = signalChainCleared.get_future();
 
-                MessageManager::callAsync([this, &signalChainCleared] {
-                    graph_->clearSignalChain();
-                    signalChainCleared.set_value(); // Signal that loadSignalChain is finished
-                });
-
-                // Wait for loadSignalChain to finish
-                signalChainClearedFuture.wait();
-                return_msg = "Signal chain cleared successfully.";
+                try {
+                    MessageManager::callAsync([this, &signalChainCleared] {
+                        try {
+                            graph_->clearSignalChain();
+                            signalChainCleared.set_value();
+                        } catch (const std::exception& e) {
+                            LOGE("Error clearing signal chain: ", e.what());
+                            signalChainCleared.set_value();
+                        }
+                    });
+
+                    // Wait for loadSignalChain to finish
+                    signalChainClearedFuture.wait();
+                    return_msg = "Signal chain cleared successfully.";
+                } catch (const std::exception& e) {
+                    LOGE("Error in clear signal chain async call: ", e.what());
+                    return_msg = "Error clearing signal chain: " + String(e.what());
+                }
             } else {
                 return_msg = "Cannot clear signal chain while acquisition is active!";
             }