feat(foundationdb): implement Directory.list

Author: PierreZ

foundationdb/src/directory/error.rs

@@ -10,6 +10,7 @@
 
 use crate::error;
 use crate::tuple::hca::HcaError;
+use crate::tuple::PackError;
 use std::io;
 
 /// The enumeration holding all possible errors from a Directory.
@@ -29,6 +30,7 @@ pub enum DirectoryError {
     IoError(io::Error),
     FdbError(error::FdbError),
     HcaError(HcaError),
+    PackError(PackError),
 }
 
 impl From<error::FdbError> for DirectoryError {
@@ -42,3 +44,9 @@ impl From<HcaError> for DirectoryError {
         DirectoryError::HcaError(err)
     }
 }
+
+impl From<PackError> for DirectoryError {
+    fn from(err: PackError) -> Self {
+        DirectoryError::PackError(err)
+    }
+}

foundationdb/src/directory/mod.rs

@@ -138,6 +138,20 @@ impl DirectoryLayer {
             .await
     }
 
+    /// list all sub-directory contained in the path
+    pub async fn list(
+        &self,
+        trx: &Transaction,
+        paths: Vec<String>,
+    ) -> Result<Vec<String>, DirectoryError> {
+        let nodes = self.find_nodes(trx, paths.to_owned()).await?;
+
+        match nodes.last() {
+            None => Err(DirectoryError::DirNotExists),
+            Some(node) => node.list(&trx).await,
+        }
+    }
+
     async fn create_or_open_internal(
         &self,
         trx: &Transaction,

foundationdb/src/directory/node.rs

@@ -8,7 +8,7 @@
 
 use crate::directory::DirectoryError;
 use crate::tuple::Subspace;
-use crate::{FdbError, Transaction};
+use crate::{FdbError, RangeOption, Transaction};
 
 /// Node are used to represent the paths generated by a Directory.
 /// They are stored in the `Directory.`
@@ -64,4 +64,37 @@ impl Node {
         }
         Ok(())
     }
+
+    /// list sub-folders for a node
+    pub(crate) async fn list(&self, trx: &Transaction) -> Result<Vec<String>, DirectoryError> {
+        let mut results = vec![];
+
+        let range_option = RangeOption::from(&self.node_subspace.to_owned());
+
+        let fdb_values = trx.get_range(&range_option, 1_024, false).await?;
+
+        for fdb_value in fdb_values {
+            let subspace = Subspace::from_bytes(fdb_value.key());
+            // stripping from subspace
+            let sub_directory: Vec<u8> = self.node_subspace.unpack(subspace.bytes())?;
+            match String::from_utf8(sub_directory.to_owned()) {
+                Ok(mut s) => {
+                    // s is like "\u{0}\u{2}node-0\u{0}"
+                    // we need to remove DEFAULT_SUB_DIRS at the beginning and the padding at the end.
+                    // maybe there is a better way to clean it? Unpack?
+                    s.remove(0);
+                    s.remove(0);
+                    s.remove(s.len() - 1);
+                    results.push(s);
+                }
+                Err(err) => {
+                    return Err(DirectoryError::Message(format!(
+                        "could not decode '{:?}' in utf-8: {}",
+                        sub_directory, err
+                    )))
+                }
+            }
+        }
+        Ok(results)
+    }
 }

foundationdb/tests/directory.rs

@@ -38,6 +38,9 @@ fn test_directory() {
     ))
     .expect("failed to run");
 
+    futures::executor::block_on(test_list(&db, &directory, vec![String::from("a")], 10))
+        .expect("failed to run");
+
     futures::executor::block_on(test_bad_layer(&db)).expect("failed to run");
 }
 
@@ -99,3 +102,38 @@ async fn test_bad_layer(db: &Database) -> Result<(), DirectoryError> {
 
     Ok(())
 }
+
+async fn test_list(
+    db: &Database,
+    directory: &DirectoryLayer,
+    paths: Vec<String>,
+    sub_path_to_create: usize,
+) -> Result<(), DirectoryError> {
+    // creating directory
+    let trx = db.create_trx()?;
+    directory.create(&trx, paths.to_owned()).await;
+    trx.commit().await.expect("could not commit");
+
+    for i in 0..sub_path_to_create {
+        let trx = db.create_trx()?;
+
+        let mut sub_path = paths.clone();
+        sub_path.push(format!("node-{}", i));
+        eprintln!("creating {:?}", sub_path.to_owned());
+        directory.create(&trx, sub_path.to_owned()).await;
+
+        trx.commit().await.expect("could not commit");
+    }
+
+    let trx = db.create_trx()?;
+
+    let sub_folders = directory.list(&trx, paths.to_owned()).await?;
+    eprintln!("found {:?}", sub_folders);
+    assert_eq!(sub_folders.len(), sub_path_to_create);
+
+    for i in 0..sub_path_to_create {
+        assert!(sub_folders.contains(&format!("node-{}", i)));
+    }
+
+    Ok(())
+}