Fixes #433 do not stop recording when deleting a past entry

daemon/src/diag.rs

@@ -20,7 +20,7 @@ use tokio_util::task::TaskTracker;
 
 use crate::analysis::{AnalysisCtrlMessage, AnalysisWriter};
 use crate::display;
-use crate::qmdl_store::{RecordingStore, RecordingStoreError};
+use crate::qmdl_store::{EntryType, RecordingStore, RecordingStoreError};
 use crate::server::ServerState;
 
 pub enum DiagDeviceCtrlMessage {
@@ -199,20 +199,16 @@ pub async fn delete_recording(
     }
     let mut qmdl_store = state.qmdl_store_lock.write().await;
     match qmdl_store.delete_entry(&qmdl_name).await {
-        Err(RecordingStoreError::NoSuchEntryError) => {
-            return Err((
+        Err(RecordingStoreError::NoSuchEntryError) => Err((
             StatusCode::BAD_REQUEST,
             format!("no recording with name {qmdl_name}"),
-            ));
-        }
-        Err(e) => {
-            return Err((
+        )),
+        Err(e) => Err((
             StatusCode::INTERNAL_SERVER_ERROR,
             format!("couldn't delete recording: {e}"),
-            ));
-        }
-        Ok(_) => {}
-    }
+        )),
+        Ok(entry_type) => {
+            if entry_type == EntryType::Current {
                 state
                     .diag_device_ctrl_sender
                     .send(DiagDeviceCtrlMessage::StopRecording)
@@ -233,7 +229,10 @@ pub async fn delete_recording(
                             format!("couldn't send ui update message: {e}"),
                         )
                     })?;
+            }
             Ok((StatusCode::ACCEPTED, "ok".to_string()))
+        }
+    }
 }
 
 pub async fn delete_all_recordings(

daemon/src/qmdl_store.rs

@@ -56,6 +56,12 @@ pub struct ManifestEntry {
     pub arch: Option<String>,
 }
 
+#[derive(PartialEq, Eq)]
+pub enum EntryType {
+    Current,
+    Past,
+}
+
 impl ManifestEntry {
     fn new() -> Self {
         let now = Local::now();
@@ -341,20 +347,24 @@ impl RecordingStore {
         Some((entry_index, &self.manifest.entries[entry_index]))
     }
 
-    pub async fn delete_entry(&mut self, name: &str) -> Result<ManifestEntry, RecordingStoreError> {
+    pub async fn delete_entry(&mut self, name: &str) -> Result<EntryType, RecordingStoreError> {
         let entry_to_delete_idx = self
             .manifest
             .entries
             .iter()
             .position(|entry| entry.name == name)
             .ok_or(RecordingStoreError::NoSuchEntryError)?;
-        if let Some(current_entry) = self.current_entry {
-            if current_entry == entry_to_delete_idx {
+        let is_current = match self.current_entry {
+            Some(current_entry) if current_entry == entry_to_delete_idx => {
                 self.close_current_entry().await?;
-            } else {
+                EntryType::Current
+            }
+            Some(current_entry) => {
                 self.current_entry = Some(current_entry - 1);
+                EntryType::Past
             }
-        }
+            None => EntryType::Past,
+        };
         let entry_to_delete = self.manifest.entries.remove(entry_to_delete_idx);
         self.write_manifest().await?;
         let qmdl_filepath = entry_to_delete.get_qmdl_filepath(&self.path);
@@ -365,7 +375,7 @@ impl RecordingStore {
         remove_file_if_exists(&analysis_filepath)
             .await
             .map_err(RecordingStoreError::DeleteFileError)?;
-        Ok(entry_to_delete)
+        Ok(is_current)
     }
 
     pub async fn delete_all_entries(&mut self) -> Result<(), RecordingStoreError> {