Add ability to flush written data

src/filesystem/files.rs

@@ -1,6 +1,6 @@
 use crate::{
     filesystem::{ClusterId, DirEntry, SearchId},
-    RawVolume, VolumeManager,
+    Error, RawVolume, VolumeManager,
 };
 
 /// Represents an open file on disk.
@@ -123,6 +123,11 @@ where
         core::mem::forget(self);
         f
     }
+
+    /// Flush any written data by updating the directory entry.
+    pub fn flush(&mut self) -> Result<(), Error<D::Error>> {
+        self.volume_mgr.flush_file(self.raw_file)
+    }
 }
 
 impl<'a, D, T, const MAX_DIRS: usize, const MAX_FILES: usize, const MAX_VOLUMES: usize> Drop

src/volume_mgr.rs

@@ -773,38 +773,18 @@ where
         Ok(())
     }
 
-    /// Close a file with the given full path.
+    /// Close a file with the given raw file handle.
     pub fn close_file(&mut self, file: RawFile) -> Result<(), Error<D::Error>> {
-        let mut found_idx = None;
-        for (idx, info) in self.open_files.iter().enumerate() {
-            if file == info.file_id {
-                found_idx = Some((info, idx));
-                break;
-            }
-        }
-
-        let (file_info, file_idx) = found_idx.ok_or(Error::BadHandle)?;
-
-        if file_info.dirty {
-            let volume_idx = self.get_volume_by_id(file_info.volume_id)?;
-            match self.open_volumes[volume_idx].volume_type {
-                VolumeType::Fat(ref mut fat) => {
-                    debug!("Updating FAT info sector");
-                    fat.update_info_sector(&self.block_device)?;
-                    debug!("Updating dir entry {:?}", file_info.entry);
-                    if file_info.entry.size != 0 {
-                        // If you have a length, you must have a cluster
-                        assert!(file_info.entry.cluster.0 != 0);
-                    }
-                    fat.write_entry_to_disk(&self.block_device, &file_info.entry)?;
-                }
-            };
-        }
-
+        let file_idx = self.flush_file_get_index(file)?;
         self.open_files.swap_remove(file_idx);
         Ok(())
     }
 
+    /// Flush (update the entry) for a file with the given raw file handle.
+    pub fn flush_file(&mut self, file: RawFile) -> Result<(), Error<D::Error>> {
+        self.flush_file_get_index(file).map(|_| ())
+    }
+
     /// Check if any files or folders are open.
     pub fn has_open_handles(&self) -> bool {
         !(self.open_dirs.is_empty() || self.open_files.is_empty())
@@ -1074,6 +1054,38 @@ where
         let available = Block::LEN - block_offset;
         Ok((block_idx, block_offset, available))
     }
+
+    /// Flush (update the entry) for a file with the given raw file handle and
+    /// get its index.
+    fn flush_file_get_index(&mut self, file: RawFile) -> Result<usize, Error<D::Error>> {
+        let mut found_idx = None;
+        for (idx, info) in self.open_files.iter().enumerate() {
+            if file == info.file_id {
+                found_idx = Some((info, idx));
+                break;
+            }
+        }
+
+        let (file_info, file_idx) = found_idx.ok_or(Error::BadHandle)?;
+
+        if file_info.dirty {
+            let volume_idx = self.get_volume_by_id(file_info.volume_id)?;
+            match self.open_volumes[volume_idx].volume_type {
+                VolumeType::Fat(ref mut fat) => {
+                    debug!("Updating FAT info sector");
+                    fat.update_info_sector(&self.block_device)?;
+                    debug!("Updating dir entry {:?}", file_info.entry);
+                    if file_info.entry.size != 0 {
+                        // If you have a length, you must have a cluster
+                        assert!(file_info.entry.cluster.0 != 0);
+                    }
+                    fat.write_entry_to_disk(&self.block_device, &file_info.entry)?;
+                }
+            };
+        }
+
+        Ok(file_idx)
+    }
 }
 
 /// Transform mode variants (ReadWriteCreate_Or_Append) to simple modes ReadWriteAppend or

tests/write_file.rs

@@ -55,6 +55,53 @@ fn append_file() {
     volume_mgr.close_volume(volume).expect("close volume");
 }
 
+#[test]
+fn flush_file() {
+    let time_source = utils::make_time_source();
+    let disk = utils::make_block_device(utils::DISK_SOURCE).unwrap();
+    let mut volume_mgr: VolumeManager<utils::RamDisk<Vec<u8>>, utils::TestTimeSource, 4, 2, 1> =
+        VolumeManager::new_with_limits(disk, time_source, 0xAA00_0000);
+    let volume = volume_mgr
+        .open_raw_volume(VolumeIdx(0))
+        .expect("open volume");
+    let root_dir = volume_mgr.open_root_dir(volume).expect("open root dir");
+
+    // Open with string
+    let f = volume_mgr
+        .open_file_in_dir(root_dir, "README.TXT", Mode::ReadWriteTruncate)
+        .expect("open file");
+
+    // Write some data to the file
+    let test_data = vec![0xCC; 64];
+    volume_mgr.write(f, &test_data).expect("file write");
+
+    // Check that the file length is zero in the directory entry, as we haven't
+    // flushed yet
+    let entry = volume_mgr
+        .find_directory_entry(root_dir, "README.TXT")
+        .expect("find entry");
+    assert_eq!(entry.size, 0);
+
+    volume_mgr.flush_file(f).expect("flush");
+
+    // Now check the file length again after flushing
+    let entry = volume_mgr
+        .find_directory_entry(root_dir, "README.TXT")
+        .expect("find entry");
+    assert_eq!(entry.size, 64);
+
+    // Flush more writes
+    volume_mgr.write(f, &test_data).expect("file write");
+    volume_mgr.write(f, &test_data).expect("file write");
+    volume_mgr.flush_file(f).expect("flush");
+
+    // Now check the file length again, again
+    let entry = volume_mgr
+        .find_directory_entry(root_dir, "README.TXT")
+        .expect("find entry");
+    assert_eq!(entry.size, 64 * 3);
+}
+
 // ****************************************************************************
 //
 // End Of File