resolve merge

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

@@ -26,11 +26,8 @@ impl<S: UuidStore> UuidResolverActor<S> {
                 Some(Create { uid: name, ret }) => {
                     let _ = ret.send(self.handle_create(name).await);
                 }
-                Some(GetOrCreate { uid: name, ret }) => {
+                Some(Get { uid: name, ret }) => {
-                    let _ = ret.send(self.handle_get_or_create(name).await);
+                    let _ = ret.send(self.handle_get(name).await);
-                }
-                Some(Resolve { uid: name, ret }) => {
-                    let _ = ret.send(self.handle_resolve(name).await);
                 }
                 Some(Delete { uid: name, ret }) => {
                     let _ = ret.send(self.handle_delete(name).await);
@@ -38,6 +35,9 @@ impl<S: UuidStore> UuidResolverActor<S> {
                 Some(List { ret }) => {
                     let _ = ret.send(self.handle_list().await);
                 }
+                Some(Insert { ret, uuid, name }) => {
+                    let _ = ret.send(self.handle_insert(name, uuid).await);
+                }
                 Some(SnapshotRequest { path, ret }) => {
                     let _ = ret.send(self.handle_snapshot(path).await);
                 }
@@ -56,14 +56,7 @@ impl<S: UuidStore> UuidResolverActor<S> {
         self.store.create_uuid(uid, true).await
     }
 
-    async fn handle_get_or_create(&self, uid: String) -> Result<Uuid> {
+    async fn handle_get(&self, uid: String) -> Result<Uuid> {
-        if !is_index_uid_valid(&uid) {
-            return Err(UuidError::BadlyFormatted(uid));
-        }
-        self.store.create_uuid(uid, false).await
-    }
-
-    async fn handle_resolve(&self, uid: String) -> Result<Uuid> {
         self.store
             .get_uuid(uid.clone())
             .await?
@@ -85,6 +78,14 @@ impl<S: UuidStore> UuidResolverActor<S> {
     async fn handle_snapshot(&self, path: PathBuf) -> Result<Vec<Uuid>> {
         self.store.snapshot(path).await
     }
+
+    async fn handle_insert(&self, uid: String, uuid: Uuid) -> Result<()> {
+        if !is_index_uid_valid(&uid) {
+            return Err(UuidError::BadlyFormatted(uid));
+        }
+        self.store.insert(uid, uuid).await?;
+        Ok(())
+    }
 }
 
 fn is_index_uid_valid(uid: &str) -> bool {

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

@@ -22,18 +22,9 @@ impl UuidResolverHandleImpl {
 
 #[async_trait::async_trait]
 impl UuidResolverHandle for UuidResolverHandleImpl {
-    async fn resolve(&self, name: String) -> anyhow::Result<Uuid> {
+    async fn get(&self, name: String) -> Result<Uuid> {
         let (ret, receiver) = oneshot::channel();
-        let msg = UuidResolveMsg::Resolve { uid: name, ret };
+        let msg = UuidResolveMsg::Get { uid: name, ret };
-        let _ = self.sender.send(msg).await;
-        Ok(receiver
-            .await
-            .expect("Uuid resolver actor has been killed")?)
-    }
-
-    async fn get_or_create(&self, name: String) -> Result<Uuid> {
-        let (ret, receiver) = oneshot::channel();
-        let msg = UuidResolveMsg::GetOrCreate { uid: name, ret };
         let _ = self.sender.send(msg).await;
         Ok(receiver
             .await
@@ -67,6 +58,15 @@ impl UuidResolverHandle for UuidResolverHandleImpl {
             .expect("Uuid resolver actor has been killed")?)
     }
 
+    async fn insert(&self, name: String, uuid: Uuid) -> anyhow::Result<()> {
+        let (ret, receiver) = oneshot::channel();
+        let msg = UuidResolveMsg::Insert { ret, name, uuid };
+        let _ = self.sender.send(msg).await;
+        Ok(receiver
+            .await
+            .expect("Uuid resolver actor has been killed")?)
+    }
+
     async fn snapshot(&self, path: PathBuf) -> Result<Vec<Uuid>> {
         let (ret, receiver) = oneshot::channel();
         let msg = UuidResolveMsg::SnapshotRequest { path, ret };

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

@@ -4,14 +4,8 @@ use tokio::sync::oneshot;
 use uuid::Uuid;
 
 use super::Result;
-
-#[derive(Debug)]
 pub enum UuidResolveMsg {
-    Resolve {
+    Get {
-        uid: String,
-        ret: oneshot::Sender<Result<Uuid>>,
-    },
-    GetOrCreate {
         uid: String,
         ret: oneshot::Sender<Result<Uuid>>,
     },
@@ -26,6 +20,11 @@ pub enum UuidResolveMsg {
     List {
         ret: oneshot::Sender<Result<Vec<(String, Uuid)>>>,
     },
+    Insert {
+        uuid: Uuid,
+        name: String,
+        ret: oneshot::Sender<Result<()>>,
+    },
     SnapshotRequest {
         path: PathBuf,
         ret: oneshot::Sender<Result<Vec<Uuid>>>,

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

@@ -24,8 +24,8 @@ pub type Result<T> = std::result::Result<T, UuidError>;
 #[async_trait::async_trait]
 #[cfg_attr(test, automock)]
 pub trait UuidResolverHandle {
-    async fn resolve(&self, name: String) -> anyhow::Result<Uuid>;
+    async fn get(&self, name: String) -> Result<Uuid>;
-    async fn get_or_create(&self, name: String) -> Result<Uuid>;
+    async fn insert(&self, name: String, uuid: Uuid) -> anyhow::Result<()>;
     async fn create(&self, name: String) -> anyhow::Result<Uuid>;
     async fn delete(&self, name: String) -> anyhow::Result<Uuid>;
     async fn list(&self) -> anyhow::Result<Vec<(String, Uuid)>>;

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

@@ -17,6 +17,7 @@ pub trait UuidStore {
     async fn get_uuid(&self, uid: String) -> Result<Option<Uuid>>;
     async fn delete(&self, uid: String) -> Result<Option<Uuid>>;
     async fn list(&self) -> Result<Vec<(String, Uuid)>>;
+    async fn insert(&self, name: String, uuid: Uuid) -> Result<()>;
     async fn snapshot(&self, path: PathBuf) -> Result<Vec<Uuid>>;
 }
 
@@ -63,6 +64,7 @@ impl UuidStore for HeedUuidStore {
         })
         .await?
     }
+
     async fn get_uuid(&self, name: String) -> Result<Option<Uuid>> {
         let env = self.env.clone();
         let db = self.db;
@@ -113,6 +115,18 @@ impl UuidStore for HeedUuidStore {
         .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?
+    }
+
     async fn snapshot(&self, mut path: PathBuf) -> Result<Vec<Uuid>> {
         let env = self.env.clone();
         let db = self.db;