@anysphere/file-service 0.0.0-f12ef7ad → 0.0.0

package/build.rs

@@ -6,38 +6,38 @@ fn main() -> Result<(), anyhow::Error> {
   napi_build::setup();
 
   // print the relative path.
-  // let workspace_root = "../../../../../";
-  // let path = std::path::Path::new(workspace_root).canonicalize()?;
-  // let include_path = Path::join(&path, "schema");
-
-  // // let relevant_protos = &[
-	// // 	"aiserver/v1/repository.proto",
-	// // 	"aiserver/v1/symbolic_context.proto",
-	// // 	"aiserver/v1/utils.proto"
-	// // ];
-  // // let proto_paths = relevant_protos
-  // //   .iter()
-  // //   .map(|proto| Path::join(&include_path, proto))
-	// // 	.collect::<Vec<_>>();
-	// let proto_glob = Path::join(&include_path, "aiserver/v1/*.proto");
-  // let relevant_protos: Vec<_> = glob::glob(proto_glob.to_str().expect("Failed to convert path to str"))?
-  //   .filter_map(Result::ok)
-  //   .collect();
-
+  let workspace_root = "../../../../../";
+  let path = std::path::Path::new(workspace_root).canonicalize()?;
+  let include_path = Path::join(&path, "schema");
+
+  // let relevant_protos = &[
+	// 	"aiserver/v1/repository.proto",
+	// 	"aiserver/v1/symbolic_context.proto",
+	// 	"aiserver/v1/utils.proto"
+	// ];
   // let proto_paths = relevant_protos
   //   .iter()
-  //   .map(|proto_path| proto_path.to_str().expect("Failed to convert path to str"))
-  //   .collect::<Vec<_>>();
-  // let includes = &[include_path.to_str().unwrap()];
-
-  // // print the path
-  // println!("cargo:rustc-env=INCLUDE_PATH={}", include_path.display());
-
-  // tonic_build::configure()
-  //   .build_server(false)
-	// 	.build_transport(true)
-	// 	.out_dir("src/proto")
-  //   .compile(&proto_paths, includes)?;
+  //   .map(|proto| Path::join(&include_path, proto))
+	// 	.collect::<Vec<_>>();
+	let proto_glob = Path::join(&include_path, "aiserver/v1/*.proto");
+  let relevant_protos: Vec<_> = glob::glob(proto_glob.to_str().expect("Failed to convert path to str"))?
+    .filter_map(Result::ok)
+    .collect();
+
+  let proto_paths = relevant_protos
+    .iter()
+    .map(|proto_path| proto_path.to_str().expect("Failed to convert path to str"))
+    .collect::<Vec<_>>();
+  let includes = &[include_path.to_str().unwrap()];
+
+  // print the path
+  println!("cargo:rustc-env=INCLUDE_PATH={}", include_path.display());
+
+  tonic_build::configure()
+    .build_server(false)
+		.build_transport(true)
+		.out_dir("src/proto")
+    .compile(&proto_paths, includes)?;
 
 
 	Ok(())

package/index.d.ts

@@ -4,13 +4,10 @@
 /* auto-generated by NAPI-RS */
 
 export class MerkleClient {
-  constructor(rootDirectory: string)
   init(): Promise<void>
+  syncWithRemote(): Promise<void>
+  computeMerkleTree(): Promise<void>
   updateFile(filePath: string): Promise<void>
   deleteFile(filePath: string): Promise<void>
-  getSubtreeHash(path: string): Promise<string>
-  getNumEmbeddableFiles(): Promise<number>
-  getAllFiles(): Promise<Array<string>>
-  getNextFileToEmbed(): Promise<Array<string>>
-  getHashesForFiles(files: Array<string>): Promise<Array<string>>
+  updateRootDirectory(rootDirectory: string): void
 }

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "@anysphere/file-service",
-  "version": "0.0.0-f12ef7ad",
+  "version": "0.0.0",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
     "name": "file_service",
     "triples": {
       "additional": [
-        "aarch64-apple-darwin",
-        "aarch64-pc-windows-msvc",
-        "universal-apple-darwin"
+        "aarch64-apple-darwin"
       ]
     }
   },
@@ -31,15 +29,12 @@
     "prepublishOnly": "napi prepublish -t npm",
     "test": "ava",
     "universal": "napi universal",
-    "preversion": "git config --global user.name || git config --global user.name 'Your Name'; git config --global user.email || git config --global user.email 'youremail@example.com'",
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@anysphere/file-service-win32-x64-msvc": "0.0.0-f12ef7ad",
-    "@anysphere/file-service-darwin-x64": "0.0.0-f12ef7ad",
-    "@anysphere/file-service-linux-x64-gnu": "0.0.0-f12ef7ad",
-    "@anysphere/file-service-darwin-arm64": "0.0.0-f12ef7ad",
-    "@anysphere/file-service-win32-arm64-msvc": "0.0.0-f12ef7ad",
-    "@anysphere/file-service-darwin-universal": "0.0.0-f12ef7ad"
+    "@anysphere/file-service-win32-x64-msvc": "0.0.0",
+    "@anysphere/file-service-darwin-x64": "0.0.0",
+    "@anysphere/file-service-linux-x64-gnu": "0.0.0",
+    "@anysphere/file-service-darwin-arm64": "0.0.0"
   }
 }

package/src/file_utils.rs

@@ -12,16 +12,15 @@ pub fn is_in_bad_dir(file_path: &Path) -> Result<bool, Error> {
   let item_path = file_path
     .to_str()
     .ok_or(anyhow::anyhow!("Failed to convert path to string"))?;
-  let is_bad_dir = (item_path.contains("node_modules")
-    || item_path.contains(".git"))
+  let is_bad_dir = (item_path.contains("node_modules") || item_path.contains(".git"))
     && !(item_path.ends_with(".git") || item_path.ends_with("node_modules"));
   Ok(is_bad_dir)
 }
 
 pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
-  let item_path = file_path
-    .to_str()
-    .ok_or(anyhow::anyhow!("Failed to convert path to string"))?;
+  let item_path = file_path.to_str().ok_or(anyhow::anyhow!(
+		"Failed to convert path to string"
+	))?;
 
   let path = Path::new(item_path);
   let file_name = path
@@ -37,8 +36,7 @@ pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
     .ok_or(anyhow::anyhow!("Failed to convert extension to string"))?;
 
   match file_name {
-    "package-lock.json" | "pnpm-lock.yaml" | "yarn.lock" | "composer.lock"
-    | "Gemfile.lock" => {
+    "package-lock.json" | "pnpm-lock.yaml" | "yarn.lock" | "composer.lock" | "Gemfile.lock" => {
       return Err(anyhow::anyhow!("File is just a lock file"));
     }
     _ => {}
@@ -51,10 +49,7 @@ pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
     _ => {}
   }
 
-  if item_path.contains(".git")
-    || item_path.contains(".svn")
-    || item_path.contains(".hg")
-  {
+  if item_path.contains(".git") || item_path.contains(".svn") || item_path.contains(".hg") {
     return Err(anyhow::anyhow!("File is just a lock file"));
   }
 
@@ -65,39 +60,29 @@ pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
         if bad_extensions.contains(&ext_str) {
           return Err(anyhow::anyhow!("File is not a valid UTF-8 string"));
         }
-      }
-      None => {
-        return Err(anyhow::anyhow!("Failed to convert extension to string"))
-      }
+      },
+      None => return Err(anyhow::anyhow!("Failed to convert extension to string")),
     },
     None => return Err(anyhow::anyhow!("Failed to get extension")),
   }
 
-  // #[cfg(not(test))]
-  // {
   let path = Path::new(item_path);
   for part in path.iter() {
     match part.to_str() {
-      Some(s) if s.starts_with(".") => {
-        return Err(anyhow::anyhow!("File is hidden"))
-      }
+      Some(s) if s.starts_with(".") => return Err(anyhow::anyhow!("File is hidden")),
       _ => {}
     }
   }
-  // }
 
   Ok(())
 }
 
 // implement the buffer above:
-pub async fn is_good_file_runtime_check(
-  file_path: &Path,
-  buffer: &[u8],
-) -> Result<(), Error> {
+pub async fn is_good_file_runtime_check(file_path: &Path, buffer: &[u8]) -> Result<(), Error> {
   match get_file_size(file_path).await {
     Ok(size) if size > 2 * 1024 * 1024 => {
       return Err(anyhow::anyhow!("Buffer is too large"));
-    }
+    },
     Err(e) => return Err(e),
     _ => {}
   }
@@ -112,10 +97,7 @@ pub async fn is_good_file_runtime_check(
   Ok(())
 }
 
-pub fn as_relative_path(
-  base_path: &Path,
-  file_path: &Path,
-) -> Result<String, Error> {
+pub fn as_relative_path(base_path: &Path, file_path: &Path) -> Result<String, Error> {
   let relative_path = file_path.strip_prefix(base_path)?;
   Ok(
     relative_path
@@ -135,7 +117,7 @@ pub async fn get_file_size(file_path: &Path) -> Result<u64, Error> {
 mod tests {
   use super::*;
   use std::path::Path;
-  use tokio::io::AsyncWriteExt;
+	use tokio::io::AsyncWriteExt;
 
   #[test]
   fn test_is_in_bad_dir() {
@@ -168,12 +150,7 @@ mod tests {
     let mut temp_file = fs::File::create(&temp_file_path).await.unwrap();
     temp_file.write_all(b"Hello, world!").await.unwrap();
     let buffer = fs::read(&temp_file_path).await.unwrap();
-    assert_eq!(
-      is_good_file_runtime_check(&temp_file_path, &buffer)
-        .await
-        .is_ok(),
-      true
-    );
+    assert_eq!(is_good_file_runtime_check(&temp_file_path, &buffer).await.is_ok(), true);
     temp_dir.close().unwrap();
 
     let temp_dir = tempfile::tempdir().unwrap();
@@ -181,12 +158,7 @@ mod tests {
     let mut temp_file = fs::File::create(&temp_file_path).await.unwrap();
     temp_file.write_all(&[0, 159, 146, 150]).await.unwrap(); // Invalid UTF-8 sequence
     let buffer = fs::read(&temp_file_path).await.unwrap();
-    assert_eq!(
-      is_good_file_runtime_check(&temp_file_path, &buffer)
-        .await
-        .is_err(),
-      true
-    );
+    assert_eq!(is_good_file_runtime_check(&temp_file_path, &buffer).await.is_err(), true);
     temp_dir.close().unwrap();
   }
 
@@ -210,5 +182,6 @@ mod tests {
     let size = get_file_size(&temp_file_path).await.unwrap();
     assert_eq!(size, 13);
     temp_dir.close().unwrap();
+
   }
 }

package/src/lib.rs

@@ -3,26 +3,52 @@ pub mod file_utils;
 pub mod git_utils;
 pub mod merkle_tree;
 
-use std::vec;
-
-use merkle_tree::{LocalConstruction, MerkleTree};
+#[path = "proto/aiserver.v1.rs"]
+pub mod aiserver;
+
+use aiserver::repository_service_client::RepositoryServiceClient;
+use aiserver::{FastRepoInitHandshakeRequest, GetNumFilesToSendRequest, GetNumFilesToSendResponse};
+use merkle_tree::{MerkleTree, LocalConstruction};
+
+use tonic::metadata::MetadataValue;
+use tonic::transport::Channel;
+use tonic::Request;
+// use aiserver::v1::repository_client::RepositoryClient;
+
+trait APISualehNeeds {
+  fn compute_merkle_tree() -> MerkleTree;
+  fn update_file(file_path: String, file_content: String, file_hash: String);
+  fn sync_with_remote();
+}
 
 #[macro_use]
 extern crate napi_derive;
 
+pub type RepositoryClient = RepositoryServiceClient<
+  tonic::service::interceptor::InterceptedService<Channel, AsphrAuthInterceptor>,
+>;
+
 #[napi]
 pub struct MerkleClient {
   tree: MerkleTree,
   root_directory: String,
+  intercepter: AsphrAuthInterceptor,
+  backend_url: String,
+  // repository_info
+  // repo_client: Option<RepositoryClient>,
 }
 
+use std::convert::TryFrom;
+
 #[napi]
 impl MerkleClient {
-  #[napi(constructor)]
-  pub fn new(root_directory: String) -> MerkleClient {
+  // #[napi(constructor)]
+  pub fn new(root_directory: String, bearer_token: String, backend_url: String) -> MerkleClient {
     MerkleClient {
       tree: MerkleTree::empty_tree(),
       root_directory,
+      intercepter: AsphrAuthInterceptor::new(bearer_token),
+      backend_url,
     }
   }
 
@@ -31,32 +57,83 @@ impl MerkleClient {
     // 1. compute the merkle tree
     // 2. update the backend
     // 3. sync with the remote
-    self.compute_merkle_tree().await?;
+    self.compute_merkle_tree().await;
+    let res = self.sync_with_remote().await;
+
+    if let Err(e) = res {
+      println!("Error: {:?}", e);
+      return Err(napi::Error::new(
+        napi::Status::Unknown,
+        "Error in sync_with_remote",
+      ));
+    }
 
     Ok(())
   }
 
-  pub async unsafe fn interrupt(&mut self) -> Result<(), napi::Error> {
-    unimplemented!("Interrupt is not implemented yet");
+  pub async fn update_backend(&self) -> Result<RepositoryClient, napi::Error> {
+    let channel = match Channel::from_shared(self.backend_url.clone()) {
+      Ok(channel) => {
+        let connection = match channel.connect().await {
+          Ok(connection) => connection,
+          Err(_) => {
+            return Err(napi::Error::new(
+              napi::Status::Unknown,
+              "Invalid backend URL",
+            ))
+          }
+        };
+
+        connection
+      }
+      Err(_) => {
+        return Err(napi::Error::new(
+          napi::Status::Unknown,
+          "Invalid backend URL",
+        ))
+      }
+    };
+
+    let repo_client = RepositoryServiceClient::with_interceptor(channel, self.intercepter.clone());
+
+    Ok(repo_client)
   }
 
-  // #[napi]
-  pub async unsafe fn compute_merkle_tree(
-    &mut self,
-  ) -> Result<(), napi::Error> {
-    let t =
-      MerkleTree::construct_merkle_tree(self.root_directory.clone()).await;
-
-    match t {
-      Ok(tree) => {
-        self.tree = tree;
-        Ok(())
-      }
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in compute_merkle_tree: {:?}", e),
-      )),
+  #[napi]
+  pub async fn sync_with_remote(&self) -> Result<(), napi::Error> {
+    // BLOCKER:
+    // 1. need to get the repository info nicely from javascript.
+    // 2. need to handle the napi conversions.
+    let client: Result<RepositoryClient, napi::Error> = self.update_backend().await;
+
+    if let Err(e) = client {
+      return Err(e);
     }
+    let mut client = client.unwrap();
+
+    // 1. make sure your tree is upto date.
+    // just make sure that you did an update recently and that you havent left too many updates to be buffered up.
+
+    // 2. sync it carefully.
+    // let repo_init_handshake_req = tonic::Request::new(FastRepoInitHandshakeRequest {
+    // 	repository:
+    // 	merkle_tree: self.tree.clone(),
+    // });
+    // client.fast_repo_init_handshake()
+
+    // 2.5 if the hash is the same, you are happy and you just leave.
+
+    // 3. start the diffing process if everything is ok.
+    // let different_files = self.tree.sync_with_remote(client).await;
+    // let num_files_to_send = different_files.len();
+
+    // 4. send those files to the server!
+    Ok(())
+  }
+
+	#[napi]
+  pub async unsafe fn compute_merkle_tree(&mut self) {
+    self.tree = MerkleTree::construct_merkle_tree(self.root_directory.clone()).await;
   }
 
   #[napi]
@@ -70,89 +147,47 @@ impl MerkleClient {
   }
 
   #[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),
-      )),
-    }
+  pub fn update_root_directory(&mut self, root_directory: String) {
+    self.root_directory = root_directory;
   }
 
-  #[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),
-      )),
-    }
+  // TODO
+  pub fn update_repository_info(&mut self, repository_info: String) {
+    // self.repository_info = repository_info;
   }
+}
 
-  #[napi]
-  pub async fn get_all_files(&self) -> Result<Vec<String>, napi::Error> {
-    let files = self.tree.get_all_files().await;
+/// A simple implementation of an interceptor that adds a bearer token to the request
+#[derive(Clone)]
+pub struct AsphrAuthInterceptor {
+  auth_token: String,
+  full_auth_string: String,
+}
 
-    match files {
-      Ok(files) => Ok(files),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_all_files: {:?}", e),
-      )),
-    }
+impl tonic::service::Interceptor for AsphrAuthInterceptor {
+  fn call(&mut self, mut request: tonic::Request<()>) -> Result<tonic::Request<()>, tonic::Status> {
+    request.metadata_mut().insert(
+      "authorization",
+      MetadataValue::try_from(&self.full_auth_string).unwrap(),
+    );
+    Ok(request)
   }
+}
 
-  #[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),
-      )),
+impl AsphrAuthInterceptor {
+  pub fn new(auth_token: String) -> AsphrAuthInterceptor {
+    AsphrAuthInterceptor {
+      auth_token: auth_token.clone(),
+      full_auth_string: format!("Bearer {}", auth_token),
     }
   }
 
-  #[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),
-      )),
-    }
+  pub fn get_auth_token(&self) -> String {
+    self.auth_token.clone()
   }
 
-  // #[napi]
-  pub fn update_root_directory(&mut self, root_directory: String) {
-    self.root_directory = root_directory;
+  pub fn update_auth_token(&mut self, new_token: String) {
+    self.auth_token = new_token;
+    self.full_auth_string = format!("Bearer {}", self.auth_token);
   }
 }