hotfix: fix tmp dir to be inside db root dir

Author: edwinkys

src/db/database.rs

@@ -53,6 +53,11 @@ impl Database {
             fs::create_dir_all(&indices_dir)?;
         }
 
+        let tmp_dir = root_dir.join("tmp");
+        if !tmp_dir.try_exists()? {
+            fs::create_dir_all(&tmp_dir)?;
+        }
+
         let state_file = root_dir.join("odbstate");
         let state = if state_file.try_exists()? {
             let mut state = DatabaseState::restore(&state_file)?;
@@ -77,7 +82,7 @@ impl Database {
 
             // Persist the new state to the state file.
             let state = DatabaseState { source, indices };
-            file::write_binary_file(state_file, &state)?;
+            file::write_binary_file(tmp_dir, state_file, &state)?;
             state
         };
 
@@ -128,7 +133,8 @@ impl Database {
         index.build(records)?;
 
         // Persist the index to a file.
-        algorithm.persist_index(&index_file, index.as_ref())?;
+        let tmp_dir = self.tmp_dir();
+        algorithm.persist_index(tmp_dir, &index_file, index.as_ref())?;
 
         // Insert the index into the pool for easy access.
         {
@@ -407,7 +413,11 @@ impl Database {
     /// When running this method with other state lock, make sure
     /// to release the lock before calling this method.
     pub fn persist_state(&self) -> Result<(), Error> {
-        file::write_binary_file(self.state_file(), &self.state()?)
+        file::write_binary_file(
+            self.tmp_dir(),
+            self.state_file(),
+            &self.state()?,
+        )
     }
 }
 
@@ -423,6 +433,11 @@ impl Database {
         self.root.join("indices")
     }
 
+    /// Returns the temporary directory path for the database.
+    fn tmp_dir(&self) -> PathBuf {
+        self.root.join("tmp")
+    }
+
     /// Persists an existing index to its file.
     /// - `name`: Index name.
     /// - `index`: Index trait object.
@@ -443,7 +458,8 @@ impl Database {
                 Error::new(code, message)
             })?;
 
-        algorithm.persist_index(file, index)
+        let tmp_dir = self.tmp_dir();
+        algorithm.persist_index(tmp_dir, file, index)
     }
 }
 
@@ -577,6 +593,7 @@ impl IndexRef {
 mod tests {
     use super::*;
     use sqlx::{Executor, Row};
+    use std::env;
     use std::sync::MutexGuard;
 
     const TABLE: &str = "embeddings";
@@ -710,7 +727,7 @@ mod tests {
             fs::remove_dir_all(&path)?;
         }
 
-        let db_path = file::get_tmp_dir()?.join("sqlite.db");
+        let db_path = get_tmp_dir()?.join("sqlite.db");
         let db_url = format!("sqlite://{}?mode=rwc", db_path.display());
 
         let mut db = Database::open(path, Some(db_url.to_owned()))?;
@@ -755,6 +772,15 @@ mod tests {
         )
     }
 
+    pub fn get_tmp_dir() -> Result<PathBuf, Error> {
+        let tmp_dir = env::temp_dir().join("oasysdb");
+        if !tmp_dir.try_exists()? {
+            fs::create_dir_all(&tmp_dir)?;
+        }
+
+        Ok(tmp_dir)
+    }
+
     async fn setup_test_source(
         url: impl Into<DatabaseURL>,
     ) -> Result<(), Error> {

src/indices/mod.rs

@@ -274,12 +274,13 @@ impl IndexAlgorithm {
     /// - `index`: Index to persist as a trait object.
     pub(crate) fn persist_index(
         &self,
+        tmp_dir: impl AsRef<Path>,
         path: impl AsRef<Path>,
         index: &dyn VectorIndex,
     ) -> Result<(), Error> {
         macro_rules! persist {
             ($index_type:ident) => {{
-                Self::_persist_index::<$index_type>(path, index)
+                Self::_persist_index::<$index_type>(tmp_dir, path, index)
             }};
         }
 
@@ -297,6 +298,7 @@ impl IndexAlgorithm {
     }
 
     fn _persist_index<T: VectorIndex + IndexOps + 'static>(
+        tmp_dir: impl AsRef<Path>,
         path: impl AsRef<Path>,
         index: &dyn VectorIndex,
     ) -> Result<(), Error> {
@@ -306,7 +308,7 @@ impl IndexAlgorithm {
             Error::new(code, message)
         })?;
 
-        index.persist(path)?;
+        index.persist(tmp_dir, path)?;
         Ok(())
     }
 }
@@ -375,8 +377,12 @@ pub trait IndexOps: Debug + Serialize + DeserializeOwned {
     }
 
     /// Serializes and persists the index to a file.
-    fn persist(&self, path: impl AsRef<Path>) -> Result<(), Error> {
-        file::write_binary_file(path, self)
+    fn persist(
+        &self,
+        tmp_dir: impl AsRef<Path>,
+        path: impl AsRef<Path>,
+    ) -> Result<(), Error> {
+        file::write_binary_file(tmp_dir, path, self)
     }
 }
 

src/utils/file.rs

@@ -1,10 +1,9 @@
 use crate::types::err::{Error, ErrorCode};
 use serde::de::DeserializeOwned;
 use serde::Serialize;
-use std::env;
 use std::fs::{self, OpenOptions};
 use std::io::{BufReader, BufWriter};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 /// Reads a binary file and deserializes its contents to a type.
 /// - `path`: Path to the binary file.
@@ -18,21 +17,20 @@ pub fn read_binary_file<T: DeserializeOwned>(
 }
 
 /// Serializes the data and writes it to a binary file.
+/// - `tmp_dir`: Temporary directory path.
 /// - `path`: Path to the binary file.
 /// - `data`: Data to write.
+///
+/// This function writes the data to a temporary file first and then renames
+/// the temporary file to the target file. This ensures that the target file
+/// is not corrupted if the operation is interrupted or fails.
 pub fn write_binary_file<T: Serialize>(
+    tmp_dir: impl AsRef<Path>,
     path: impl AsRef<Path>,
     data: &T,
 ) -> Result<(), Error> {
     let file_name = parse_file_name(&path)?;
-    let tmp_dir = get_tmp_dir()?;
-
-    // To ensure that the target file is not corrupted if
-    // the operation is interrupted or fails:
-    // 1. Write the data to a temporary file.
-    // 2. Rename the temporary file to the target file.
-
-    let tmp_file = tmp_dir.join(file_name);
+    let tmp_file = tmp_dir.as_ref().join(file_name);
     let file = OpenOptions::new()
         .write(true)
         .create(true)
@@ -46,16 +44,6 @@ pub fn write_binary_file<T: Serialize>(
     Ok(())
 }
 
-/// Returns the temporary directory path for OasysDB.
-pub fn get_tmp_dir() -> Result<PathBuf, Error> {
-    let tmp_dir = env::temp_dir().join("oasysdb");
-    if !tmp_dir.try_exists()? {
-        fs::create_dir_all(&tmp_dir)?;
-    }
-
-    Ok(tmp_dir)
-}
-
 /// Parses the file name from a path.
 /// - `path`: Path to a file.
 pub fn parse_file_name(path: impl AsRef<Path>) -> Result<String, Error> {