node: ApiClient vfs methods take references

Author: MaxFangX

node/src/api/client.rs

@@ -119,19 +119,19 @@ impl ApiClient for LexeApiClient {
             .await
     }
 
-    async fn get_file(&self, data: FileId) -> Result<Option<File>, ApiError> {
+    async fn get_file(&self, data: &FileId) -> Result<Option<File>, ApiError> {
         let endpoint = "/file";
         self.request(&Method::GET, Backend, V1, endpoint, &data)
             .await
     }
 
-    async fn create_file(&self, data: File) -> Result<File, ApiError> {
+    async fn create_file(&self, data: &File) -> Result<File, ApiError> {
         let endpoint = "/file";
         self.request(&Method::POST, Backend, V1, endpoint, &data)
             .await
     }
 
-    async fn upsert_file(&self, data: File) -> Result<File, ApiError> {
+    async fn upsert_file(&self, data: &File) -> Result<File, ApiError> {
         let endpoint = "/file";
         self.request(&Method::PUT, Backend, V1, endpoint, &data)
             .await
@@ -140,15 +140,15 @@ impl ApiClient for LexeApiClient {
     // TODO We want to delete channel peers / monitors when channels close
     /// Returns "OK" if exactly one row was deleted.
     #[allow(dead_code)]
-    async fn delete_file(&self, data: FileId) -> Result<String, ApiError> {
+    async fn delete_file(&self, data: &FileId) -> Result<String, ApiError> {
         let endpoint = "/file";
         self.request(&Method::DELETE, Backend, V1, endpoint, &data)
             .await
     }
 
     async fn get_directory(
         &self,
-        data: Directory,
+        data: &Directory,
     ) -> Result<Vec<File>, ApiError> {
         let endpoint = "/directory";
         self.request(&Method::GET, Backend, V1, endpoint, &data)

node/src/api/mock.rs

@@ -153,35 +153,35 @@ impl ApiClient for MockApiClient {
 
     async fn get_file(
         &self,
-        file_id: FileId,
+        file_id: &FileId,
     ) -> Result<Option<File>, ApiError> {
-        let file_opt = self.vfs.lock().unwrap().get(file_id);
+        let file_opt = self.vfs.lock().unwrap().get(file_id.clone());
         Ok(file_opt)
     }
 
-    async fn create_file(&self, file: File) -> Result<File, ApiError> {
+    async fn create_file(&self, file: &File) -> Result<File, ApiError> {
         let file_opt = self.vfs.lock().unwrap().insert(file.clone());
         assert!(file_opt.is_none());
-        Ok(file)
+        Ok(file.clone())
     }
 
-    async fn upsert_file(&self, file: File) -> Result<File, ApiError> {
+    async fn upsert_file(&self, file: &File) -> Result<File, ApiError> {
         self.vfs.lock().unwrap().insert(file.clone());
-        Ok(file)
+        Ok(file.clone())
     }
 
     /// Returns "OK" if exactly one row was deleted.
-    async fn delete_file(&self, file_id: FileId) -> Result<String, ApiError> {
-        let file_opt = self.vfs.lock().unwrap().remove(file_id);
+    async fn delete_file(&self, file_id: &FileId) -> Result<String, ApiError> {
+        let file_opt = self.vfs.lock().unwrap().remove(file_id.clone());
         assert!(file_opt.is_none());
         Ok(String::from("OK"))
     }
 
     async fn get_directory(
         &self,
-        dir: Directory,
+        dir: &Directory,
     ) -> Result<Vec<File>, ApiError> {
-        let files_vec = self.vfs.lock().unwrap().get_dir(dir);
+        let files_vec = self.vfs.lock().unwrap().get_dir(dir.clone());
         Ok(files_vec)
     }
 

node/src/api/mod.rs

@@ -54,20 +54,22 @@ pub trait ApiClient {
         data: NodeInstanceSeed,
     ) -> Result<NodeInstanceSeed, ApiError>;
 
-    async fn get_file(&self, file_id: FileId)
-        -> Result<Option<File>, ApiError>;
+    async fn get_file(
+        &self,
+        file_id: &FileId,
+    ) -> Result<Option<File>, ApiError>;
 
-    async fn create_file(&self, file: File) -> Result<File, ApiError>;
+    async fn create_file(&self, file: &File) -> Result<File, ApiError>;
 
-    async fn upsert_file(&self, file: File) -> Result<File, ApiError>;
+    async fn upsert_file(&self, file: &File) -> Result<File, ApiError>;
 
     // TODO We want to delete channel peers / monitors when channels close
     /// Returns "OK" if exactly one row was deleted.
-    async fn delete_file(&self, file_id: FileId) -> Result<String, ApiError>;
+    async fn delete_file(&self, file_id: &FileId) -> Result<String, ApiError>;
 
     async fn get_directory(
         &self,
-        dir: Directory,
+        dir: &Directory,
     ) -> Result<Vec<File>, ApiError>;
 
     async fn notify_runner(

node/src/lexe/persister.rs

@@ -107,7 +107,7 @@ impl InnerPersister {
         );
         let cm_file_opt = self
             .api
-            .get_file(cm_file_id)
+            .get_file(&cm_file_id)
             .await
             .context("Could not fetch channel manager from DB")?;
 
@@ -162,7 +162,7 @@ impl InnerPersister {
 
         let cm_file_vec = self
             .api
-            .get_directory(cm_dir)
+            .get_directory(&cm_dir)
             .await
             .context("Could not fetch channel monitors from DB")?;
 
@@ -209,7 +209,7 @@ impl InnerPersister {
         );
         let scorer_file_opt = self
             .api
-            .get_file(scorer_file_id)
+            .get_file(&scorer_file_id)
             .await
             .context("Could not fetch probabilistic scorer from DB")?;
 
@@ -244,7 +244,7 @@ impl InnerPersister {
         );
         let ng_file_opt = self
             .api
-            .get_file(ng_file_id)
+            .get_file(&ng_file_id)
             .await
             .context("Could not fetch network graph from DB")?;
 
@@ -273,7 +273,7 @@ impl InnerPersister {
 
         let cp_file_vec = self
             .api
-            .get_directory(cp_dir)
+            .get_directory(&cp_dir)
             .await
             .context("Could not fetch channel peers from DB")?;
 
@@ -309,7 +309,7 @@ impl InnerPersister {
         );
 
         self.api
-            .create_file(cp_file)
+            .create_file(&cp_file)
             .await
             .map(|_| ())
             .map_err(|e| e.into())
@@ -333,7 +333,7 @@ impl InnerPersister {
         );
 
         self.api
-            .upsert_file(cm_file)
+            .upsert_file(&cm_file)
             .await
             .map(|_| ())
             .context("Could not persist channel manager")
@@ -356,7 +356,7 @@ impl InnerPersister {
         );
 
         self.api
-            .upsert_file(file)
+            .upsert_file(&file)
             .await
             .map(|_| ())
             .context("Could not persist network graph")
@@ -384,7 +384,7 @@ impl InnerPersister {
         };
 
         self.api
-            .upsert_file(scorer_file)
+            .upsert_file(&scorer_file)
             .await
             .map(|_| ())
             .context("Could not persist scorer")
@@ -415,7 +415,7 @@ impl Persist<SignerType> for InnerPersister {
 
         // Run an async fn inside a sync fn inside a Tokio runtime
         Handle::current()
-            .block_on(async move { self.api.create_file(cm_file).await })
+            .block_on(async move { self.api.create_file(&cm_file).await })
             .map(|_| ())
             .map_err(|e| {
                 // TODO(max): Implement durability then make this err permanent
@@ -448,7 +448,7 @@ impl Persist<SignerType> for InnerPersister {
 
         // Run an async fn inside a sync fn inside a Tokio runtime
         Handle::current()
-            .block_on(async move { self.api.upsert_file(cm_file).await })
+            .block_on(async move { self.api.upsert_file(&cm_file).await })
             .map(|_| ())
             .map_err(|e| {
                 // TODO(max): Implement durability then make this err permanent