Merge pull request #55 from CoLearn-Dev/rename-set-send

Rename variable transfer functions (set/get -> send/receive)

Author: stneng

examples/protocol_variable_transfer.rs

@@ -11,7 +11,7 @@ impl ProtocolEntry for Initiator {
         participants: Vec<Participant>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
         println!("initiator");
-        cl.set_variable("output", &param, &[participants[1].clone()])
+        cl.send_variable("output", &param, &[participants[1].clone()])
             .await?;
         Ok(())
     }
@@ -26,7 +26,7 @@ impl ProtocolEntry for Receiver {
         param: Vec<u8>,
         participants: Vec<Participant>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-        let msg = cl.get_variable("output", &participants[0]).await?;
+        let msg = cl.recv_variable("output", &participants[0]).await?;
         println!("{}", String::from_utf8_lossy(&msg));
         cl.create_entry(&format!("tasks:{}:output", cl.get_task_id()?), &msg)
             .await?;

src/extensions/variable_transfer.rs

@@ -7,11 +7,21 @@ mod tls_utils;
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 
 impl crate::application::CoLink {
+    #[deprecated(note = "please use `send_variable` instead")]
     pub async fn set_variable(
         &self,
         key: &str,
         payload: &[u8],
         receivers: &[Participant],
+    ) -> Result<(), Error> {
+        self.send_variable(key, payload, receivers).await
+    }
+
+    pub async fn send_variable(
+        &self,
+        key: &str,
+        payload: &[u8],
+        receivers: &[Participant],
     ) -> Result<(), Error> {
         if self.task_id.is_empty() {
             Err("task_id not found".to_string())?;
@@ -24,11 +34,11 @@ impl crate::application::CoLink {
             let receiver = receiver.clone();
             tokio::spawn(async move {
                 if cl
-                    ._set_variable_p2p(&key, &payload, &receiver)
+                    ._send_variable_p2p(&key, &payload, &receiver)
                     .await
                     .is_err()
                 {
-                    cl.set_variable_with_remote_storage(&key, &payload, &[receiver.clone()])
+                    cl.send_variable_with_remote_storage(&key, &payload, &[receiver.clone()])
                         .await?;
                 }
                 Ok::<(), Box<dyn std::error::Error + Send + Sync + 'static>>(())
@@ -37,14 +47,19 @@ impl crate::application::CoLink {
         Ok(())
     }
 
+    #[deprecated(note = "please use `recv_variable` instead")]
     pub async fn get_variable(&self, key: &str, sender: &Participant) -> Result<Vec<u8>, Error> {
+        self.recv_variable(key, sender).await
+    }
+
+    pub async fn recv_variable(&self, key: &str, sender: &Participant) -> Result<Vec<u8>, Error> {
         if self.task_id.is_empty() {
             Err("task_id not found".to_string())?;
         }
-        if let Ok(res) = self._get_variable_p2p(key, sender).await {
+        if let Ok(res) = self._recv_variable_p2p(key, sender).await {
             return Ok(res);
         }
-        let res = self.get_variable_with_remote_storage(key, sender).await?;
+        let res = self.recv_variable_with_remote_storage(key, sender).await?;
         Ok(res)
     }
 }

src/extensions/variable_transfer/p2p_inbox.rs

@@ -151,7 +151,7 @@ pub(crate) struct VtP2pCtx {
 }
 
 impl crate::application::CoLink {
-    pub(crate) async fn _set_variable_p2p(
+    pub(crate) async fn _send_variable_p2p(
         &self,
         key: &str,
         payload: &[u8],
@@ -165,7 +165,7 @@ impl crate::application::CoLink {
             .contains_key(&receiver.user_id)
         {
             let inbox = self
-                .get_variable_with_remote_storage("inbox", receiver)
+                .recv_variable_with_remote_storage("inbox", receiver)
                 .await?;
             let inbox: VTInbox = serde_json::from_slice(&inbox)?;
             let inbox = if inbox.addr.is_empty() {
@@ -218,7 +218,7 @@ impl crate::application::CoLink {
         Ok(())
     }
 
-    pub(crate) async fn _get_variable_p2p(
+    pub(crate) async fn _recv_variable_p2p(
         &self,
         key: &str,
         sender: &Participant,
@@ -287,7 +287,7 @@ impl crate::application::CoLink {
                         .clone(),
                 }
             };
-            self.set_variable_with_remote_storage(
+            self.send_variable_with_remote_storage(
                 "inbox",
                 &serde_json::to_vec(&vt_inbox)?,
                 &[sender.clone()],

src/extensions/variable_transfer/remote_storage.rs

@@ -8,11 +8,22 @@ mod colink_remote_storage {
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 
 impl crate::application::CoLink {
+    #[deprecated(note = "please use `send_variable_with_remote_storage` instead")]
     pub async fn set_variable_with_remote_storage(
         &self,
         key: &str,
         payload: &[u8],
         receivers: &[Participant],
+    ) -> Result<(), Error> {
+        self.send_variable_with_remote_storage(key, payload, receivers)
+            .await
+    }
+
+    pub async fn send_variable_with_remote_storage(
+        &self,
+        key: &str,
+        payload: &[u8],
+        receivers: &[Participant],
     ) -> Result<(), Error> {
         let mut new_participants = vec![Participant {
             user_id: self.get_user_id()?,
@@ -49,10 +60,19 @@ impl crate::application::CoLink {
         Ok(())
     }
 
+    #[deprecated(note = "please use `recv_variable_with_remote_storage` instead")]
     pub async fn get_variable_with_remote_storage(
         &self,
         key: &str,
         sender: &Participant,
+    ) -> Result<Vec<u8>, Error> {
+        self.recv_variable_with_remote_storage(key, sender).await
+    }
+
+    pub async fn recv_variable_with_remote_storage(
+        &self,
+        key: &str,
+        sender: &Participant,
     ) -> Result<Vec<u8>, Error> {
         let key = format!(
             "_remote_storage:private:{}:_variable_transfer:{}:{}",

tests/test_protocol_variable_transfer.rs

@@ -15,10 +15,14 @@ impl ProtocolEntry for Initiator {
         for i in 0..8 {
             let key = &format!("output{}", i);
             let key2 = &format!("output_remote_storage{}", i);
-            cl.set_variable(key, &param, &participants[1..participants.len()])
-                .await?;
-            cl.set_variable_with_remote_storage(key2, &param, &participants[1..participants.len()])
+            cl.send_variable(key, &param, &participants[1..participants.len()])
                 .await?;
+            cl.send_variable_with_remote_storage(
+                key2,
+                &param,
+                &participants[1..participants.len()],
+            )
+            .await?;
         }
         Ok(())
     }
@@ -36,11 +40,11 @@ impl ProtocolEntry for Receiver {
         for i in 0..8 {
             let key = &format!("output{}", i);
             let key2 = &format!("output_remote_storage{}", i);
-            let msg = cl.get_variable(key, &participants[0]).await?;
+            let msg = cl.recv_variable(key, &participants[0]).await?;
             cl.create_entry(&format!("tasks:{}:output{}", cl.get_task_id()?, i), &msg)
                 .await?;
             let msg = cl
-                .get_variable_with_remote_storage(key2, &participants[0])
+                .recv_variable_with_remote_storage(key2, &participants[0])
                 .await?;
             cl.create_entry(
                 &format!("tasks:{}:output_remote_storage{}", cl.get_task_id()?, i),