feat(directory,bindingtester): implement move and move_to

PierreZ · PierreZ · commit 8efec0ce6308 · 2021-03-29T09:56:02.000+02:00
diff --git a/foundationdb-bindingtester/src/main.rs b/foundationdb-bindingtester/src/main.rs
@@ -1,8 +1,6 @@
 #[macro_use]
 extern crate log;
 
-// TODO: Fix 1330929912
-
 use foundationdb as fdb;
 use foundationdb_sys as fdb_sys;
 
@@ -1899,13 +1897,83 @@ impl StackMachine {
             //
             // Pop 2 tuples off the stack as [old_path, new_path]. Call move with the
             // specified old_path and new_path. Append the result onto the directory list.
-            DirectoryMove => unimplemented!(),
+            DirectoryMove => {
+                debug!("Move stack: {:?}", self.stack);
+
+                let paths = self.pop_tuple(2).await;
+
+                let directory = self
+                    .get_current_directory()
+                    .expect("could not find a directory");
+
+                let txn = match trx {
+                    TransactionState::Transaction(ref t) => t,
+                    _ => {
+                        panic!("could not find an active transaction");
+                    }
+                };
+
+                match directory
+                    .move_to(
+                        txn,
+                        (*paths.get(0).unwrap().to_vec()).to_owned(),
+                        (*paths.get(1).unwrap().to_vec()).to_owned(),
+                    )
+                    .await
+                {
+                    Ok(s) => {
+                        debug!(
+                            "pushing moved directory {:?} at index {}",
+                            &s,
+                            self.directory_stack.len()
+                        );
+                        self.directory_stack
+                            .push(DirectoryStackItem::DirectorySubspace(s));
+                    }
+                    Err(e) => {
+                        self.push_directory_err(&instr.code, number, e);
+                    }
+                };
+            }
 
             // Use the current directory for this operation.
             //
             // Pop 1 tuple off the stack as [new_absolute_path]. Call moveTo with the
             // specified new_absolute_path. Append the result onto the directory list.
-            DirectoryMoveTo => unimplemented!(),
+            DirectoryMoveTo => {
+                debug!("MoveTo stack: {:?}", self.stack);
+
+                let paths = self.pop_tuple(1).await;
+
+                let directory = self
+                    .get_current_directory()
+                    .expect("could not find a directory");
+
+                let txn = match trx {
+                    TransactionState::Transaction(ref t) => t,
+                    _ => {
+                        panic!("could not find an active transaction");
+                    }
+                };
+
+                match directory
+                    .move_directory(txn, (*paths.get(0).unwrap().to_vec()).to_owned())
+                    .await
+                {
+                    Ok(s) => {
+                        debug!(
+                            "pushing moved directory {:?} at index {}",
+                            &s,
+                            self.directory_stack.len()
+                        );
+                        self.directory_stack
+                            .push(DirectoryStackItem::DirectorySubspace(s));
+                    }
+                    Err(e) => {
+                        self.push_directory_err(&instr.code, number, e);
+                    }
+                };
+            }
 
             // Use the current directory for this operation.
             //
diff --git a/foundationdb/src/directory/directory_layer.rs b/foundationdb/src/directory/directory_layer.rs
@@ -5,10 +5,12 @@ use crate::tuple::hca::HighContentionAllocator;
 use crate::tuple::{Subspace, TuplePack, TupleUnpack};
 use crate::{FdbResult, Transaction};
 
-use crate::directory::Directory;
 use crate::directory::DirectorySubspace;
+use crate::directory::{compare_slice_string, Directory};
 use async_trait::async_trait;
 use byteorder::{LittleEndian, WriteBytesExt};
+use std::cmp::Ordering;
+
 
 // TODO: useful?
 const _LAYER_VERSION: (u8, u8, u8) = (1, 0, 0);
@@ -17,7 +19,7 @@ const MINOR_VERSION: u32 = 0;
 const PATCH_VERSION: u32 = 0;
 const DEFAULT_NODE_PREFIX: &[u8] = b"\xFE";
 const DEFAULT_HCA_PREFIX: &[u8] = b"hca";
-const DEFAULT_SUB_DIRS: i64 = 0;
+pub(crate) const DEFAULT_SUB_DIRS: i64 = 0;
 
 /// An implementation of FoundationDB's directory that is compatible with other bindings.
 ///
@@ -144,7 +146,7 @@ impl Directory for DirectoryLayer {
     /// `exists` returns true if the directory at path (relative to the default root directory) exists, and false otherwise.
     async fn exists(&self, trx: &Transaction, path: Vec<String>) -> Result<bool, DirectoryError> {
         match dbg!(
-            self.find_or_create_node(trx, path.to_owned(), false, None, None)
+            self.find_or_create_node(trx, path.to_owned(), false, None)
                 .await
         ) {
             Ok(_node) => Ok(true),
@@ -155,25 +157,81 @@ impl Directory for DirectoryLayer {
         }
     }
 
+    async fn move_directory(
+        &self,
+        _trx: &Transaction,
+        _new_path: Vec<String>,
+    ) -> Result<DirectorySubspace, DirectoryError> {
+        Err(DirectoryError::CannotMoveRootDirectory)
+    }
+
     /// `move_to` the directory from old_path to new_path(both relative to this
     /// Directory), and returns the directory (at its new location) and its
     /// contents as a Subspace. Move will return an error if a directory
     /// does not exist at oldPath, a directory already exists at newPath, or the
     /// parent directory of newPath does not exist.
     async fn move_to(
         &self,
-        _trx: &Transaction,
-        _old_path: Vec<String>,
-        _new_path: Vec<String>,
-    ) -> Result<Subspace, DirectoryError> {
-        unimplemented!()
+        trx: &Transaction,
+        old_path: Vec<String>,
+        new_path: Vec<String>,
+    ) -> Result<DirectorySubspace, DirectoryError> {
+        self.check_version(trx, false).await?;
+
+        let mut slice_end = old_path.len();
+        if slice_end > new_path.len() {
+            slice_end = new_path.len();
+        }
+
+        if compare_slice_string(&old_path[..], &new_path[..slice_end]) == Ordering::Equal
+            || old_path.is_empty()
+            || new_path.is_empty()
+        {
+            return Err(DirectoryError::CannotMoveBetweenSubdirectory);
+        }
+
+        let old_node = self
+            .find_or_create_node(&trx, old_path.to_owned(), false, None)
+            .await?;
+
+        if self.exists(&trx, new_path.to_owned()).await? {
+            return Err(DirectoryError::DirAlreadyExists);
+        }
+
+        let new_node_parent = self
+            .find_or_create_node(
+                &trx,
+                Vec::from(&new_path.to_owned()[..new_path.len() - 1]),
+                true,
+                None,
+            )
+            .await?;
+
+        let content_subspace = old_node.content_subspace.clone().unwrap();
+
+        let prefix = self.node_subspace.unpack(content_subspace.bytes())?;
+
+        if new_node_parent.is_new_node {
+            return Err(DirectoryError::CannotMoveMissingParent);
+        }
+
+        // create new node
+        self.find_or_create_node(&trx, new_path.to_owned(), true, Some(prefix))
+            .await?;
+
+        let child_name = old_path.last().unwrap().to_owned();
+        new_node_parent.remove_child(&trx, child_name).await;
+
+        return self
+            .contents_of_node(old_node.content_subspace, new_path, old_node.layer)
+            .await;
     }
 
     /// `remove` the subdirectory of this Directory located at `path` and all of its subdirectories,
     /// as well as all of their contents.
     async fn remove(&self, trx: &Transaction, path: Vec<String>) -> Result<bool, DirectoryError> {
         let node = self
-            .find_or_create_node(trx, path.to_owned(), false, None, None)
+            .find_or_create_node(trx, path.to_owned(), false, None)
             .await?;
         node.remove_all(trx).await?;
         Ok(true)
@@ -187,7 +245,7 @@ impl Directory for DirectoryLayer {
         path: Vec<String>,
     ) -> Result<Vec<String>, DirectoryError> {
         let node = self
-            .find_or_create_node(trx, path.to_owned(), false, None, None)
+            .find_or_create_node(trx, path.to_owned(), false, None)
             .await?;
         node.list(&trx).await
     }
@@ -220,13 +278,7 @@ impl DirectoryLayer {
         }
 
         match self
-            .find_or_create_node(
-                &trx,
-                path.to_owned(),
-                allow_create,
-                prefix.to_owned(),
-                layer.to_owned(),
-            )
+            .find_or_create_node(&trx, path.to_owned(), allow_create, prefix.to_owned())
             .await
         {
             Ok(node) => {
@@ -358,6 +410,7 @@ impl DirectoryLayer {
             node_subspace: self.get_root_node_subspace(),
             content_subspace: None,
             parent_node_reference: self.get_root_node_subspace(),
+            is_new_node: false,
         };
         let mut node_path = vec![];
 
@@ -407,6 +460,7 @@ impl DirectoryLayer {
                 node_subspace: self.node_subspace.subspace(&prefix.as_slice()),
                 content_subspace: Some(Subspace::from_bytes(&prefix.as_slice())),
                 parent_node_reference: key.to_owned(),
+                is_new_node: new_node,
             };
 
             node.retrieve_layer(&trx).await?;
diff --git a/foundationdb/src/directory/directory_subspace.rs b/foundationdb/src/directory/directory_subspace.rs
@@ -1,10 +1,12 @@
 use crate::directory::directory_layer::DirectoryLayer;
 use crate::directory::error::DirectoryError;
-use crate::directory::Directory;
+use crate::directory::{compare_slice_string, Directory};
 use crate::tuple::{PackResult, Subspace, TuplePack, TupleUnpack};
 use crate::Transaction;
 use async_trait::async_trait;
 
+use std::cmp::Ordering;
+
 /// `DirectorySubspace` is a directory that can act as a subspace
 #[derive(Clone, Debug)]
 pub struct DirectorySubspace {
@@ -95,12 +97,39 @@ impl Directory for DirectorySubspace {
             .await
     }
 
+    async fn move_directory(
+        &self,
+        trx: &Transaction,
+        new_path: Vec<String>,
+    ) -> Result<DirectorySubspace, DirectoryError> {
+        // equivalent of moveTo in Go
+        // return moveTo(t, d.dl, d.path, newAbsolutePath)
+        let partition_length = self.path.len();
+
+        if new_path.is_empty() {
+            return Err(DirectoryError::CannotMoveBetweenPartition);
+        }
+
+        dbg!(&new_path, &self.path);
+
+        if compare_slice_string(&new_path[..partition_length], &self.path) != Ordering::Equal {
+            Err(DirectoryError::CannotMoveBetweenPartition)
+        } else {
+            self.move_to(
+                trx,
+                Vec::from(&self.path[partition_length..]),
+                Vec::from(&new_path[partition_length..]),
+            )
+            .await
+        }
+    }
+
     async fn move_to(
         &self,
         trx: &Transaction,
         old_path: Vec<String>,
         new_path: Vec<String>,
-    ) -> Result<Subspace, DirectoryError> {
+    ) -> Result<DirectorySubspace, DirectoryError> {
         self.move_to(
             trx,
             self.directory
diff --git a/foundationdb/src/directory/error.rs b/foundationdb/src/directory/error.rs
@@ -36,6 +36,13 @@ pub enum DirectoryError {
     PrefixNotAllowed,
     /// cannot specify a prefix in a partition.
     CannotPrefixInPartition,
+    /// the root directory cannot be moved
+    CannotMoveRootDirectory,
+    CannotMoveBetweenPartition,
+    /// the destination directory cannot be a subdirectory of the source directory
+    CannotMoveBetweenSubdirectory,
+    /// the parent of the destination directory does not exist. Create it first
+    CannotMoveMissingParent,
     IoError(io::Error),
     FdbError(error::FdbError),
     HcaError(HcaError),
diff --git a/foundationdb/src/directory/mod.rs b/foundationdb/src/directory/mod.rs
@@ -19,13 +19,12 @@ mod node;
 use crate::directory::error::DirectoryError;
 
 
-
-use crate::tuple::{PackResult, Subspace, TuplePack, TupleUnpack};
-use crate::{Transaction};
+use crate::Transaction;
 
 use crate::directory::directory_subspace::DirectorySubspace;
 use async_trait::async_trait;
-
+use core::cmp;
+use std::cmp::Ordering;
 
 #[async_trait]
 pub trait Directory {
@@ -50,16 +49,33 @@ pub trait Directory {
         layer: Option<Vec<u8>>,
     ) -> Result<DirectorySubspace, DirectoryError>;
     async fn exists(&self, trx: &Transaction, path: Vec<String>) -> Result<bool, DirectoryError>;
+    async fn move_directory(
+        &self,
+        trx: &Transaction,
+        new_path: Vec<String>,
+    ) -> Result<DirectorySubspace, DirectoryError>;
     async fn move_to(
         &self,
         trx: &Transaction,
         old_path: Vec<String>,
         new_path: Vec<String>,
-    ) -> Result<Subspace, DirectoryError>;
+    ) -> Result<DirectorySubspace, DirectoryError>;
     async fn remove(&self, trx: &Transaction, path: Vec<String>) -> Result<bool, DirectoryError>;
     async fn list(
         &self,
         trx: &Transaction,
         path: Vec<String>,
     ) -> Result<Vec<String>, DirectoryError>;
 }
+
+pub fn compare_slice_string(a: &[String], b: &[String]) -> cmp::Ordering {
+    for (ai, bi) in a.iter().zip(b.iter()) {
+        match ai.cmp(&bi) {
+            Ordering::Equal => continue,
+            ord => return ord,
+        }
+    }
+
+    /* if every single element was equal, compare length */
+    a.len().cmp(&b.len())
+}
diff --git a/foundationdb/src/directory/node.rs b/foundationdb/src/directory/node.rs
diff --git a/scripts/run_bindingtester.sh b/scripts/run_bindingtester.sh
