@anysphere/file-service 0.0.0-930d43f → 0.0.0-a0aa43e6

package/index.d.ts

@@ -6,10 +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-930d43f",
+  "version": "0.0.0-a0aa43e6",
   "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-930d43f",
-    "@anysphere/file-service-darwin-x64": "0.0.0-930d43f",
-    "@anysphere/file-service-linux-x64-gnu": "0.0.0-930d43f",
-    "@anysphere/file-service-darwin-arm64": "0.0.0-930d43f",
-    "@anysphere/file-service-win32-arm64-msvc": "0.0.0-930d43f",
-    "@anysphere/file-service-darwin-universal": "0.0.0-930d43f"
+    "@anysphere/file-service-win32-x64-msvc": "0.0.0-a0aa43e6",
+    "@anysphere/file-service-darwin-x64": "0.0.0-a0aa43e6",
+    "@anysphere/file-service-linux-x64-gnu": "0.0.0-a0aa43e6",
+    "@anysphere/file-service-darwin-arm64": "0.0.0-a0aa43e6",
+    "@anysphere/file-service-win32-arm64-msvc": "0.0.0-a0aa43e6",
+    "@anysphere/file-service-darwin-universal": "0.0.0-a0aa43e6"
   }
 }

package/src/lib.rs

@@ -3,6 +3,8 @@ pub mod file_utils;
 pub mod git_utils;
 pub mod merkle_tree;
 
+use std::vec;
+
 use merkle_tree::{LocalConstruction, MerkleTree};
 
 #[macro_use]
@@ -31,14 +33,14 @@ impl MerkleClient {
     // 3. sync with the remote
     self.compute_merkle_tree().await?;
 
-		Ok(())
+    Ok(())
   }
 
   pub async unsafe fn interrupt(&mut self) -> Result<(), napi::Error> {
     unimplemented!("Interrupt is not implemented yet");
   }
 
-  // #[napi]
+  #[napi]
   pub async unsafe fn compute_merkle_tree(
     &mut self,
   ) -> Result<(), napi::Error> {
@@ -67,59 +69,150 @@ impl MerkleClient {
     let _r = self.tree.delete_file(file_path);
   }
 
-	#[napi]
-	pub async fn get_subtree_hash(&self, path: String) -> Result<String, napi::Error> {
-		let hash = self.tree.get_subtree_hash(path).await;
-
-		match hash {
-			Ok(hash) => Ok(hash),
-			Err(e) => Err(napi::Error::new(
-				napi::Status::Unknown,
-				format!("Error in get_subtree_hash: {:?}", e),
-			)),
-		}
-	}
-
-	#[napi]
-	pub async fn get_num_embeddable_files(&self) -> Result<i32, napi::Error> {
-		let num = self.tree.get_num_embeddable_files().await;
-
-		match num {
-			Ok(num) => Ok(num),
-			Err(e) => Err(napi::Error::new(
-				napi::Status::Unknown,
-				format!("Error in get_num_embeddable_files: {:?}", e),
-			)),
-		}
-	}
-
-	#[napi]
-	pub async fn get_all_files(&self) -> Result<Vec<String>, napi::Error> {
-		let files = self.tree.get_all_files().await;
-
-		match files {
-			Ok(files) => Ok(files),
-			Err(e) => Err(napi::Error::new(
-				napi::Status::Unknown,
-				format!("Error in get_all_files: {:?}", e),
-			)),
-		}
-	}
-
-	#[napi]
-	pub async fn get_hashes_for_files(&self, files: Vec<String>) -> Result<Vec<String>, napi::Error> {
-		let hashes = self.tree.get_hashes_for_files(files).await;
-
-		match hashes {
-			Ok(hashes) => Ok(hashes),
-			Err(e) => Err(napi::Error::new(
-				napi::Status::Unknown,
-				format!("Error in get_hashes_for_files: {:?}", e),
-			)),
-		}
-	}
-
-  // #[napi]
+  #[napi]
+  pub async fn get_subtree_hash(
+    &self,
+    relative_path: String,
+  ) -> Result<String, napi::Error> {
+    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),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_subtree_hash: {:?}", e),
+      )),
+    }
+  }
+
+  #[napi]
+  pub async fn get_num_embeddable_files(&self) -> Result<i32, napi::Error> {
+    let num = self.tree.get_num_embeddable_files().await;
+
+    match num {
+      Ok(num) => Ok(num),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_num_embeddable_files: {:?}", e),
+      )),
+    }
+  }
+
+  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;
+
+    match files {
+      Ok(files) => Ok(files),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_all_files: {:?}", e),
+      )),
+    }
+  }
+
+  #[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,
+  ) -> Result<Vec<String>, napi::Error> {
+    let n = self.tree.get_next_file_to_embed().await;
+
+    match n {
+      Ok((file, path)) => {
+        // now our job is to put the filename as the first element of the path.
+
+        // TODO(sualeh): we should assert that the path is ascending up to the path.
+
+        let ret = vec![file];
+        let ret = ret.into_iter().chain(path.into_iter()).collect::<Vec<_>>();
+
+        Ok(ret)
+      }
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_next_file_to_embed: {:?}", e),
+      )),
+    }
+  }
+
+  // FIXME(sualeh): get_spline
+  #[napi]
+  pub async fn get_spline(
+    &self,
+    absolute_file_path: String,
+  ) -> Result<Vec<String>, napi::Error> {
+    // let spline = self.tree.get_spline(absolute_file_path).await;
+
+    return Ok(vec![]);
+
+    // 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,
+    files: Vec<String>,
+  ) -> Result<Vec<String>, napi::Error> {
+    let hashes = self.tree.get_hashes_for_files(files).await;
+
+    match hashes {
+      Ok(hashes) => Ok(hashes),
+      Err(e) => Err(napi::Error::new(
+        napi::Status::Unknown,
+        format!("Error in get_hashes_for_files: {:?}", e),
+      )),
+    }
+  }
+
+  #[napi]
   pub fn update_root_directory(&mut self, root_directory: String) {
     self.root_directory = root_directory;
   }

package/src/merkle_tree/local_construction.rs

@@ -3,13 +3,16 @@ 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;
 
 #[async_trait]
 impl LocalConstruction for MerkleTree {
-  async fn new(root_directory: Option<String>) -> Result<MerkleTree, anyhow::Error> {
+  async fn new(
+    root_directory: Option<String>,
+  ) -> Result<MerkleTree, anyhow::Error> {
     if let Some(root_directory) = root_directory {
       let n = MerkleTree::construct_merkle_tree(root_directory).await;
       return n;
@@ -25,7 +28,9 @@ impl LocalConstruction for MerkleTree {
   /// 2. compute hash for each file
   /// 3. construct merkle tree
   /// 4. return merkle tree
-  async fn construct_merkle_tree(root_directory: String) -> Result<MerkleTree, anyhow::Error> {
+  async fn construct_merkle_tree(
+    root_directory: String,
+  ) -> Result<MerkleTree, anyhow::Error> {
     let path = PathBuf::from(root_directory.clone());
     if !path.exists() {
       // FIXME: we should report this via a good logger.
@@ -35,22 +40,23 @@ 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,
     };
 
     // we now iterate over all the nodes and add them to the hashmap
     // 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;
         match &node_reader.node_type {
           NodeType::Branch(n) => {
-						let children = &n.1;
-						files.insert(n.0.clone(), File { node: node.clone() });
+            let children = &n.1;
+            files.insert(n.0.clone(), File { node: node.clone() });
             for child in children {
               add_nodes_to_hashmap(child, files).await;
             }
@@ -102,9 +108,9 @@ impl LocalConstruction for MerkleTree {
       // File does not exist in the tree, let's add it.
       let e = self.attach_new_node_to_tree(file_path.clone()).await;
 
-			if e.is_err() {
-				return Err(anyhow::anyhow!("Could not attach new node to tree!"));
-			}
+      if e.is_err() {
+        return Err(anyhow::anyhow!("Could not attach new node to tree!"));
+      }
     }
 
     Ok(())
@@ -139,18 +145,17 @@ impl LocalConstruction for MerkleTree {
     let parent_node = parent_node.unwrap();
     let mut mut_parent = parent_node.write().await;
 
+    // BUG(sualeh): need to actually drop everything that is a child here.
+    // idea: enumerate all nodes that are children of this through a starts with query on the hashtable.
+    // then drop all of them.
+    // in opposite order of length.
 
-		// BUG(sualeh): need to actually drop everything that is a child here.
-		// idea: enumerate all nodes that are children of this through a starts with query on the hashtable.
-		// then drop all of them.
-		// in opposite order of length.
-
-		// then remove the node from the parent and you are done
+    // then remove the node from the parent and you are done
 
     // Remove the child from the parent node
     match mut_parent.node_type {
       NodeType::Branch(ref mut node) => {
-				let children = &mut node.1;
+        let children = &mut node.1;
         let mut found = false;
         let mut index = 0;