[WIP] rebase on main

meilisearch-http/src/index_controller/uuid_resolver/store.rs

@@ -1,6 +1,6 @@
-use std::path::{Path, PathBuf};
 use std::collections::HashSet;
 use std::fs::create_dir_all;
+use std::path::{Path, PathBuf};
 
 use heed::{
     types::{ByteSlice, Str},
@@ -25,6 +25,7 @@ pub trait UuidStore {
     async fn get_size(&self) -> Result<u64>;
 }
 
+#[derive(Clone)]
 pub struct HeedUuidStore {
     env: Env,
     db: Database<Str, ByteSlice>,
@@ -40,150 +41,168 @@ impl HeedUuidStore {
         let db = env.create_database(None)?;
         Ok(Self { env, db })
     }
+
+    pub fn create_uuid(&self, name: String, err: bool) -> Result<Uuid> {
+        let env = self.env.clone();
+        let db = self.db;
+        let mut txn = env.write_txn()?;
+        match db.get(&txn, &name)? {
+            Some(uuid) => {
+                if err {
+                    Err(UuidError::NameAlreadyExist)
+                } else {
+                    let uuid = Uuid::from_slice(uuid)?;
+                    Ok(uuid)
+                }
+            }
+            None => {
+                let uuid = Uuid::new_v4();
+                db.put(&mut txn, &name, uuid.as_bytes())?;
+                txn.commit()?;
+                Ok(uuid)
+            }
+        }
+    }
+
+    pub fn get_uuid(&self, name: String) -> Result<Option<Uuid>> {
+        let env = self.env.clone();
+        let db = self.db;
+        let txn = env.read_txn()?;
+        match db.get(&txn, &name)? {
+            Some(uuid) => {
+                let uuid = Uuid::from_slice(uuid)?;
+                Ok(Some(uuid))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn delete(&self, uid: String) -> Result<Option<Uuid>> {
+        let env = self.env.clone();
+        let db = self.db;
+        let mut txn = env.write_txn()?;
+        match db.get(&txn, &uid)? {
+            Some(uuid) => {
+                let uuid = Uuid::from_slice(uuid)?;
+                db.delete(&mut txn, &uid)?;
+                txn.commit()?;
+                Ok(Some(uuid))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn list(&self) -> Result<Vec<(String, Uuid)>> {
+        let env = self.env.clone();
+        let db = self.db;
+        let txn = env.read_txn()?;
+        let mut entries = Vec::new();
+        for entry in db.iter(&txn)? {
+            let (name, uuid) = entry?;
+            let uuid = Uuid::from_slice(uuid)?;
+            entries.push((name.to_owned(), uuid))
+        }
+        Ok(entries)
+    }
+
+    pub fn insert(&self, name: String, uuid: Uuid) -> Result<()> {
+        let env = self.env.clone();
+        let db = self.db;
+        let mut txn = env.write_txn()?;
+        db.put(&mut txn, &name, uuid.as_bytes())?;
+        txn.commit()?;
+        Ok(())
+    }
+
+    // TODO: we should merge this function and the following function for the dump. it's exactly
+    // the same code
+    pub fn snapshot(&self, mut path: PathBuf) -> Result<Vec<Uuid>> {
+        let env = self.env.clone();
+        let db = self.db;
+        // Write transaction to acquire a lock on the database.
+        let txn = env.write_txn()?;
+        let mut entries = HashSet::new();
+        for entry in db.iter(&txn)? {
+            let (_, uuid) = entry?;
+            let uuid = Uuid::from_slice(uuid)?;
+            entries.insert(uuid);
+        }
+
+        // only perform snapshot if there are indexes
+        if !entries.is_empty() {
+            path.push("index_uuids");
+            create_dir_all(&path).unwrap();
+            path.push("data.mdb");
+            env.copy_to_path(path, CompactionOption::Enabled)?;
+        }
+        Ok(entries)
+    }
+
+    pub fn dump(&self, mut path: PathBuf) -> Result<Vec<Uuid>> {
+        let env = self.env.clone();
+        let db = self.db;
+        // Write transaction to acquire a lock on the database.
+        let txn = env.write_txn()?;
+        let mut entries = Vec::new();
+        for entry in db.iter(&txn)? {
+            let (_, uuid) = entry?;
+            let uuid = Uuid::from_slice(uuid)?;
+            entries.push(uuid)
+        }
+
+        // only perform dump if there are indexes
+        if !entries.is_empty() {
+            path.push("index_uuids");
+            create_dir_all(&path).unwrap();
+            path.push("data.mdb");
+            env.copy_to_path(path, CompactionOption::Enabled)?;
+        }
+        Ok(entries)
+    }
+
+    pub fn get_size(&self) -> Result<u64> {
+        Ok(self.env.size())
+    }
 }
 
 #[async_trait::async_trait]
 impl UuidStore for HeedUuidStore {
     async fn create_uuid(&self, name: String, err: bool) -> Result<Uuid> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            let mut txn = env.write_txn()?;
-            match db.get(&txn, &name)? {
-                Some(uuid) => {
-                    if err {
-                        Err(UuidError::NameAlreadyExist)
-                    } else {
-                        let uuid = Uuid::from_slice(uuid)?;
-                        Ok(uuid)
-                    }
-                }
-                None => {
-                    let uuid = Uuid::new_v4();
-                    db.put(&mut txn, &name, uuid.as_bytes())?;
-                    txn.commit()?;
-                    Ok(uuid)
-                }
-            }
-        })
-        .await?
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.create_uuid(name, err)).await?
     }
 
     async fn get_uuid(&self, name: String) -> Result<Option<Uuid>> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            let txn = env.read_txn()?;
-            match db.get(&txn, &name)? {
-                Some(uuid) => {
-                    let uuid = Uuid::from_slice(uuid)?;
-                    Ok(Some(uuid))
-                }
-                None => Ok(None),
-            }
-        })
-        .await?
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.get_uuid(name)).await?
     }
 
     async fn delete(&self, uid: String) -> Result<Option<Uuid>> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            let mut txn = env.write_txn()?;
-            match db.get(&txn, &uid)? {
-                Some(uuid) => {
-                    let uuid = Uuid::from_slice(uuid)?;
-                    db.delete(&mut txn, &uid)?;
-                    txn.commit()?;
-                    Ok(Some(uuid))
-                }
-                None => Ok(None),
-            }
-        })
-        .await?
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.delete(uid)).await?
     }
 
     async fn list(&self) -> Result<Vec<(String, Uuid)>> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            let txn = env.read_txn()?;
-            let mut entries = Vec::new();
-            for entry in db.iter(&txn)? {
-                let (name, uuid) = entry?;
-                let uuid = Uuid::from_slice(uuid)?;
-                entries.push((name.to_owned(), uuid))
-            }
-            Ok(entries)
-        })
-        .await?
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.list()).await?
     }
 
     async fn insert(&self, name: String, uuid: Uuid) -> Result<()> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            let mut txn = env.write_txn()?;
-            db.put(&mut txn, &name, uuid.as_bytes())?;
-            txn.commit()?;
-            Ok(())
-        })
-        .await?
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.insert(name, uuid)).await?
     }
 
-    // TODO: we should merge this function and the following function for the dump. it's exactly
-    // the same code
-    async fn snapshot(&self, mut path: PathBuf) -> Result<HashSet<Uuid>> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            // Write transaction to acquire a lock on the database.
-            let txn = env.write_txn()?;
-            let mut entries = HashSet::new();
-            for entry in db.iter(&txn)? {
-                let (_, uuid) = entry?;
-                let uuid = Uuid::from_slice(uuid)?;
-                entries.insert(uuid);
-            }
-
-            // only perform snapshot if there are indexes
-            if !entries.is_empty() {
-                path.push("index_uuids");
-                create_dir_all(&path).unwrap();
-                path.push("data.mdb");
-                env.copy_to_path(path, CompactionOption::Enabled)?;
-            }
-            Ok(entries)
-        })
-        .await?
+    async fn snapshot(&self, path: PathBuf) -> Result<Vec<Uuid>> {
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.snapshot(path)).await?
     }
 
-    async fn dump(&self, mut path: PathBuf) -> Result<Vec<Uuid>> {
-        let env = self.env.clone();
-        let db = self.db;
-        tokio::task::spawn_blocking(move || {
-            // Write transaction to acquire a lock on the database.
-            let txn = env.write_txn()?;
-            let mut entries = Vec::new();
-            for entry in db.iter(&txn)? {
-                let (_, uuid) = entry?;
-                let uuid = Uuid::from_slice(uuid)?;
-                entries.push(uuid)
-            }
-
-            // only perform dump if there are indexes
-            if !entries.is_empty() {
-                path.push("index_uuids");
-                create_dir_all(&path).unwrap();
-                path.push("data.mdb");
-                env.copy_to_path(path, CompactionOption::Enabled)?;
-            }
-            Ok(entries)
-        })
-        .await?
+    async fn dump(&self, path: PathBuf) -> Result<Vec<Uuid>> {
+        let this = self.clone();
+        tokio::task::spawn_blocking(move || this.dump(path)).await?
     }
 
     async fn get_size(&self) -> Result<u64> {
-        Ok(self.env.size())
+        self.get_size()
     }
 }