@anysphere/file-service 0.0.0-eb1d04d9 → 0.0.0-ed88c2dc

package/index.d.ts

@@ -6,11 +6,15 @@
 export class MerkleClient {
   constructor(rootDirectory: string)
   init(): Promise<void>
+  computeMerkleTree(): Promise<void>
   updateFile(filePath: string): Promise<void>
   deleteFile(filePath: string): Promise<void>
-  getSubtreeHash(path: string): Promise<string>
+  getSubtreeHash(relativePath: string): Promise<string>
   getNumEmbeddableFiles(): Promise<number>
   getAllFiles(): Promise<Array<string>>
+  getAllDirFilesToEmbed(absoluteFilePath: string): Promise<Array<string>>
   getNextFileToEmbed(): Promise<Array<string>>
+  getSpline(absoluteFilePath: string): Promise<Array<string>>
   getHashesForFiles(files: Array<string>): Promise<Array<string>>
+  updateRootDirectory(rootDirectory: string): void
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anysphere/file-service",
-  "version": "0.0.0-eb1d04d9",
+  "version": "0.0.0-ed88c2dc",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
@@ -35,11 +35,11 @@
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@anysphere/file-service-win32-x64-msvc": "0.0.0-eb1d04d9",
-    "@anysphere/file-service-darwin-x64": "0.0.0-eb1d04d9",
-    "@anysphere/file-service-linux-x64-gnu": "0.0.0-eb1d04d9",
-    "@anysphere/file-service-darwin-arm64": "0.0.0-eb1d04d9",
-    "@anysphere/file-service-win32-arm64-msvc": "0.0.0-eb1d04d9",
-    "@anysphere/file-service-darwin-universal": "0.0.0-eb1d04d9"
+    "@anysphere/file-service-win32-x64-msvc": "0.0.0-ed88c2dc",
+    "@anysphere/file-service-darwin-x64": "0.0.0-ed88c2dc",
+    "@anysphere/file-service-linux-x64-gnu": "0.0.0-ed88c2dc",
+    "@anysphere/file-service-darwin-arm64": "0.0.0-ed88c2dc",
+    "@anysphere/file-service-win32-arm64-msvc": "0.0.0-ed88c2dc",
+    "@anysphere/file-service-darwin-universal": "0.0.0-ed88c2dc"
   }
 }

package/src/lib.rs

@@ -40,7 +40,7 @@ impl MerkleClient {
     unimplemented!("Interrupt is not implemented yet");
   }
 
-  // #[napi]
+  #[napi]
   pub async unsafe fn compute_merkle_tree(
     &mut self,
   ) -> Result<(), napi::Error> {
@@ -72,9 +72,11 @@ impl MerkleClient {
   #[napi]
   pub async fn get_subtree_hash(
     &self,
-    path: String,
+    relative_path: String,
   ) -> Result<String, napi::Error> {
-    let hash = self.tree.get_subtree_hash(path).await;
+    let absolute_path =
+      std::path::Path::new(&self.root_directory).join(relative_path);
+    let hash = self.tree.get_subtree_hash(absolute_path).await;
 
     match hash {
       Ok(hash) => Ok(hash),
@@ -98,6 +100,26 @@ impl MerkleClient {
     }
   }
 
+  pub async fn get_num_embeddable_files_in_subtree(
+    &self,
+    relative_path: String,
+  ) -> Result<i32, napi::Error> {
+    let absolute_path =
+      std::path::Path::new(&self.root_directory).join(relative_path);
+    let num = self
+      .tree
+      .get_num_embeddable_files_in_subtree(absolute_path)
+      .await;
+
+    match num {
+      Ok(num) => Ok(num),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_num_embeddable_files_in_subtree: {:?}", e),
+      )),
+    }
+  }
+
   #[napi]
   pub async fn get_all_files(&self) -> Result<Vec<String>, napi::Error> {
     let files = self.tree.get_all_files().await;
@@ -111,6 +133,26 @@ impl MerkleClient {
     }
   }
 
+  #[napi]
+  pub async fn get_all_dir_files_to_embed(
+    &self,
+    absolute_file_path: String,
+  ) -> Result<Vec<String>, napi::Error> {
+    let absolute_path_str = absolute_file_path.as_str();
+    let files = self
+      .tree
+      .get_all_dir_files_to_embed(absolute_path_str)
+      .await;
+
+    match files {
+      Ok(files) => Ok(files),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_all_dir_files_to_embed: {:?}", e),
+      )),
+    }
+  }
+
   #[napi]
   pub async unsafe fn get_next_file_to_embed(
     &mut self,
@@ -135,6 +177,24 @@ impl MerkleClient {
     }
   }
 
+  // FIXME(sualeh): get_spline
+  #[napi]
+  pub async fn get_spline(
+    &self,
+    absolute_file_path: String,
+  ) -> Result<Vec<String>, napi::Error> {
+    let absolute_path_str = absolute_file_path.as_str();
+    let spline = self.tree.get_spline(absolute_path_str).await;
+
+    match spline {
+      Ok(spline) => Ok(spline),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_spline: {:?}", e),
+      )),
+    }
+  }
+
   #[napi]
   pub async fn get_hashes_for_files(
     &self,
@@ -151,7 +211,7 @@ impl MerkleClient {
     }
   }
 
-  // #[napi]
+  #[napi]
   pub fn update_root_directory(&mut self, root_directory: String) {
     self.root_directory = root_directory;
   }

package/src/merkle_tree/local_construction.rs

@@ -3,6 +3,7 @@ use crate::merkle_tree::{
 };
 
 use super::{LocalConstruction, MerkleTree};
+use std::collections::BTreeMap;
 use std::path::PathBuf;
 use std::{collections::HashMap, path::Path, sync::Arc};
 use tonic::async_trait;
@@ -39,7 +40,7 @@ impl LocalConstruction for MerkleTree {
     let root_node = MerkleNode::new(path, None).await;
     let mut mt = MerkleTree {
       root: root_node,
-      files: HashMap::new(),
+      files: BTreeMap::new(),
       root_path: root_directory,
       cursor: None,
     };
@@ -48,7 +49,7 @@ impl LocalConstruction for MerkleTree {
     // TODO(later): i can make this parallel.
     fn add_nodes_to_hashmap<'a>(
       node: &'a MerkleNodePtr,
-      files: &'a mut HashMap<String, File>,
+      files: &'a mut BTreeMap<String, File>,
     ) -> PinnedFuture<'a, ()> {
       Box::pin(async move {
         let node_reader = node.read().await;

package/src/merkle_tree/mod.rs

@@ -1,7 +1,8 @@
 use super::file_utils;
 use sha2::Digest;
+use std::collections::BTreeMap;
 use std::path::PathBuf;
-use std::{collections::HashMap, fs, path::Path, sync::Arc};
+use std::{fs, path::Path, sync::Arc};
 use tokio::sync::RwLock;
 use tonic::async_trait;
 pub mod local_construction;
@@ -12,8 +13,8 @@ pub type MerkleNodePtr = Arc<RwLock<MerkleNode>>;
 pub struct MerkleTree {
   root_path: String,
   root: MerkleNodePtr,
-  files: HashMap<String, File>,
-  cursor: Option<MerkleNodePtr>,
+  files: BTreeMap<String, File>,
+  cursor: Option<usize>,
 }
 
 #[derive(Debug)]
@@ -87,7 +88,7 @@ impl MerkleTree {
   pub fn empty_tree() -> MerkleTree {
     MerkleTree {
       root: Arc::new(RwLock::new(MerkleNode::empty_node(None, None))),
-      files: HashMap::new(),
+      files: BTreeMap::new(),
       root_path: "".to_string(),
       cursor: None,
     }
@@ -95,10 +96,18 @@ impl MerkleTree {
 
   pub async fn get_subtree_hash(
     &self,
-    path: String,
+    absolute_path: PathBuf,
   ) -> Result<String, anyhow::Error> {
-    let path = PathBuf::from(path);
-    let node = match self.files.get(path.to_str().unwrap()) {
+    let abs_string = match absolute_path.to_str() {
+      Some(s) => s.to_string(),
+      None => {
+        return Err(anyhow::anyhow!(
+          "get_subtree_hash: Failed to convert path to string"
+        ))
+      }
+    };
+
+    let node = match self.files.get(&abs_string) {
       Some(file) => file.node.clone(),
       None => {
         return Err(anyhow::anyhow!("Could not find file in tree!"));
@@ -132,6 +141,43 @@ impl MerkleTree {
     Ok(count)
   }
 
+  pub async fn get_num_embeddable_files_in_subtree(
+    &self,
+    absolute_path: PathBuf,
+  ) -> Result<i32, anyhow::Error> {
+    let mut count = 0;
+
+    let absolute_path = match absolute_path.to_str() {
+      Some(s) => s.to_string(),
+      None => {
+        return Err(anyhow::anyhow!(
+        "get_num_embeddable_files_in_subtree: Failed to convert path to string"
+      ))
+      }
+    };
+
+    // TODO(sualeh): worth keeping this list sorted. its now a btree
+
+    for (_, file) in &self.files {
+      let file_reader = file.node.read().await;
+      match &file_reader.node_type {
+        NodeType::File(file_name) => {
+          if file_name.contains(&absolute_path) {
+            count += 1;
+          }
+        }
+        NodeType::Branch(_) => {
+          continue;
+        }
+        NodeType::ErrorNode(_) => {
+          continue;
+        }
+      }
+    }
+
+    Ok(count)
+  }
+
   pub async fn get_all_files(&self) -> Result<Vec<String>, anyhow::Error> {
     let mut files = Vec::new();
 
@@ -188,83 +234,94 @@ impl MerkleTree {
   pub async fn get_next_file_to_embed(
     &mut self,
   ) -> Result<(String, Vec<String>), anyhow::Error> {
-    // the plan is to do an in-order traversal of the tree.
-
-    // first the edge case to deal with:
-    // cursor == None
-    if self.cursor.is_none() {
-      // If the root is a file, return its name.
-      if let NodeType::File(file_path) = &self.root.read().await.node_type {
-        return Ok((file_path.clone(), vec![]));
-      }
-
-      // if the path is not empty, we can iterate till we find the first child.
-      let mut potential_first_child = self.root.clone();
-      let mut is_branch = true;
-      let mut path = Vec::new();
-
-      while is_branch {
-        let node = {
-          let potential_first_child_reader = potential_first_child.read().await;
-          match &potential_first_child_reader.node_type {
-            NodeType::Branch(branch) => branch.clone(),
-            NodeType::File(_) => {
-              return Err(anyhow::anyhow!(
-                "get_next_file_to_embed: This should not happen! the branch happened to be file."
-              ));
-            }
-            NodeType::ErrorNode(_) => {
-              return Err(anyhow::anyhow!("Cursor is an error node!"));
-            }
-          }
-        };
+    // if the cursor is none, set it to 0
+    let cursor = match self.cursor {
+      Some(cursor) => cursor,
+      None => {
+        self.cursor = Some(0);
+        0
+      }
+    };
 
-        let current_node_name = &node.0;
-        let child_list = &node.1;
+    // get the thing at the cursor. while we dont find a file, we keep incrementing the cursor.
+    let mut cursor = cursor;
+    loop {
+      // O(log n)
+      let file = match self.files.values().nth(cursor) {
+        Some(file) => file,
+        None => {
+          return Err(anyhow::anyhow!("Could not find file to embed!"));
+        }
+      };
 
-        if let Some(c) = child_list.first() {
-          let c_reader = c.read().await;
+      let file_reader = file.node.read().await;
+      match &file_reader.node_type {
+        NodeType::File(f) => {
+          // update the cursor.
+          self.cursor = Some(cursor + 1);
+          let spline = self.get_spline(f).await?;
+          return Ok((f.clone(), spline));
+        }
+        NodeType::Branch(_) => {
+          cursor += 1;
+          continue;
+        }
+        NodeType::ErrorNode(_) => {
+          cursor += 1;
+          continue;
+        }
+      }
+    }
+  }
 
-          match &c_reader.node_type {
-            NodeType::File(file_path) => {
-              // must set the cursor!
-              self.cursor = Some(c.clone());
+  pub async fn get_all_dir_files_to_embed(
+    &self,
+    absolute_path: &str,
+  ) -> Result<Vec<String>, anyhow::Error> {
+    let mut files = Vec::new();
 
-              return Ok((file_path.clone(), path));
-            }
-            NodeType::Branch(_) => {
-              potential_first_child = c.clone();
-              is_branch = true;
+    for (file_path, f) in &self.files {
+      if !file_path.contains(absolute_path) {
+        continue;
+      }
 
-              // add the path to the current node.
-              path.push(current_node_name.clone());
-            }
-            NodeType::ErrorNode(_) => {
-              return Err(anyhow::anyhow!("Cursor is an error node!"));
-            }
-          }
-        } else {
-          // If the root has no children, return an error.
-          return Err(anyhow::anyhow!("Root has no children!"));
+      match f.node.read().await.node_type {
+        NodeType::File(_) => {
+          files.push(file_path.clone());
+        }
+        NodeType::Branch(_) => {
+          continue;
+        }
+        NodeType::ErrorNode(_) => {
+          continue;
         }
       }
     }
 
-    // THE DEFAULT CASE:
-    // we already have a cursor at a file.
-
-    // UNWRAP checked and fine. see the none case above.
-    let cursor_name = self.cursor.as_ref().unwrap();
-    let cursor_reader = cursor_name.read().await;
-
-    // invariant: you must be a file!!
+    Ok(files)
+  }
 
-    // everytime we get to a child list, we will add all the children to a fifo, and then pull from it as long as we need it.
+  pub async fn get_spline(
+    &self,
+    absolute_path: &str,
+  ) -> Result<Vec<String>, anyhow::Error> {
+    let mut files = Vec::new();
 
-    // algorithm:
-    // 1.
+    let current_node = match self.files.get(absolute_path) {
+      Some(node) => node.node.clone(),
+      None => return Err(anyhow::anyhow!("File not found: {}", absolute_path)),
+    };
+    let mut stack = Vec::new();
+    stack.push(current_node);
 
-    Err(anyhow::anyhow!("Could not find file to embed!"))
+    while let Some(node) = stack.pop() {
+      let parent = node.read().await.parent.clone();
+      if let Some(parent) = parent {
+        files.push(parent.read().await.hash.clone());
+        stack.push(parent);
+      }
+    }
+    Ok(files)
   }
 
   /// creates a new node and attaches it to the current tree.