feat(foundationdb): initial commit for Directory.Move

Author: PierreZ

foundationdb/src/directory/error.rs

@@ -22,6 +22,8 @@ pub enum DirectoryError {
     DirAlreadyExists,
     /// missing path.
     DirNotExists,
+    /// Parent does not exists
+    ParentDirDoesNotExists,
     /// the layer is incompatible.
     IncompatibleLayer,
     Message(String),

foundationdb/src/directory/mod.rs

@@ -167,11 +167,47 @@ impl DirectoryLayer {
     /// parent directory of newPath does not exist.
     pub async fn move_to(
         &self,
-        _trx: &Transaction,
-        _old_path: Vec<String>,
-        _new_path: Vec<String>,
+        trx: &Transaction,
+        old_path: Vec<String>,
+        new_path: Vec<String>,
     ) -> Result<bool, DirectoryError> {
-        unimplemented!("move is not supported yet")
+        self.check_version(trx, false).await?;
+
+        let mut old_nodes = self.find_nodes(&trx, old_path.to_owned()).await?;
+        let last_node_from_old_path = match old_nodes.last_mut() {
+            None => return Err(DirectoryError::Message(String::from("empty path"))),
+            Some(node) => node,
+        };
+        let content_subspace = last_node_from_old_path
+            .content_subspace
+            .as_ref()
+            .ok_or(DirectoryError::DirNotExists)?;
+
+        let mut new_nodes = self.find_nodes(&trx, new_path.to_owned()).await?;
+        // assert that parent of the new node exists
+        if new_nodes.get(new_nodes.len() - 2).is_none() {
+            return Err(DirectoryError::ParentDirDoesNotExists);
+        }
+
+        let last_node_from_new_path = match new_nodes.last_mut() {
+            None => return Err(DirectoryError::Message(String::from("empty path"))),
+            Some(node) => {
+                if node.content_subspace.is_some() {
+                    return Err(DirectoryError::DirNotExists);
+                }
+                node
+            }
+        };
+
+        last_node_from_new_path
+            .persist_content_subspace(&trx, content_subspace.to_owned())
+            .await?;
+
+        last_node_from_old_path
+            .delete_content_subspace(&trx)
+            .await?;
+
+        Ok(true)
     }
 
     /// Exists returns true if the directory at path (relative to this Directory)
@@ -258,7 +294,7 @@ impl DirectoryLayer {
                     // creating subspace
                     let allocator = self.allocator.allocate(trx).await?;
                     parent_subspace = node
-                        .create_subspace(&trx, allocator, &parent_subspace)
+                        .create_and_write_content_subspace(&trx, allocator, &parent_subspace)
                         .await?;
                 }
                 Some(subspace) => parent_subspace = subspace.clone(),

foundationdb/src/directory/node.rs

@@ -38,22 +38,38 @@ impl Node {
 
     /// This will use the generated id and:
     ///
-    /// * persist the node in the directory subspace dedicated to nodes
+    /// * persist the node in the directory subspace
     /// * create the content_subspace and returns it
-    pub(crate) async fn create_subspace(
+    pub(crate) async fn create_and_write_content_subspace(
         &mut self,
         trx: &Transaction,
         generated_id: i64,
         parent_subspace: &Subspace,
     ) -> Result<Subspace, DirectoryError> {
-        let new_subspace = parent_subspace.subspace(&generated_id);
+        let subspace = parent_subspace.subspace(&generated_id);
+        self.persist_content_subspace(&trx, subspace).await
+    }
 
+    /// `persist_content_subspace` will save the provided subspace as the `content_subspace`
+    pub(crate) async fn persist_content_subspace(
+        &mut self,
+        trx: &Transaction,
+        subspace: Subspace,
+    ) -> Result<Subspace, DirectoryError> {
         let key = self.node_subspace.to_owned();
-        trx.set(key.bytes(), new_subspace.bytes());
-
-        self.content_subspace = Some(new_subspace.to_owned());
+        trx.set(key.bytes(), subspace.bytes());
+        self.content_subspace = Some(subspace.to_owned());
+        Ok(subspace)
+    }
 
-        Ok(new_subspace)
+    /// delete subspace from the node_subspace
+    pub(crate) async fn delete_content_subspace(
+        &mut self,
+        trx: &Transaction,
+    ) -> Result<(), DirectoryError> {
+        let key = self.node_subspace.to_owned();
+        trx.clear(key.bytes());
+        Ok(())
     }
 
     /// retrieve the layer used for this node

foundationdb/tests/directory.rs

@@ -49,6 +49,46 @@ fn test_directory() {
     .expect("failed to run");
 
     futures::executor::block_on(test_bad_layer(&db)).expect("failed to run");
+
+    futures::executor::block_on(test_move_to(
+        &db,
+        &directory,
+        vec![String::from("d"), String::from("e")],
+        vec![String::from("a"), String::from("g")],
+    ))
+    .expect("failed to run");
+}
+
+async fn test_move_to(
+    db: &Database,
+    directory: &DirectoryLayer,
+    old_paths: Vec<String>,
+    new_paths: Vec<String>,
+) -> Result<(), DirectoryError> {
+    let trx = db.create_trx()?;
+    let create_output = directory.create_or_open(&trx, old_paths.to_owned()).await?;
+
+    trx.commit().await.expect("could not commit");
+    let trx = db.create_trx()?;
+
+    let move_output = directory
+        .move_to(&trx, old_paths.to_owned(), new_paths.to_owned())
+        .await?;
+    assert!(move_output);
+
+    trx.commit().await.expect("could not commit");
+    let trx = db.create_trx()?;
+
+    let open_output = directory.open(&trx, new_paths).await?;
+    assert_eq!(create_output.bytes(), open_output.bytes());
+
+    trx.commit().await.expect("could not commit");
+    let trx = db.create_trx()?;
+
+    let open_old_path = directory.open(&trx, old_paths).await;
+    assert!(open_old_path.is_err());
+
+    Ok(())
 }
 
 async fn test_create_then_open_async(