Make interpreter async (#130)

Co-authored-by: folex <0xdxdy@gmail.com>
Co-authored-by: Pavel Murygin <pavel.murygin@gmail.com>

crates/interpreter-interface/Cargo.toml

@@ -19,3 +19,4 @@ marine-rs-sdk = "0.6.11"
 fluence-it-types = "0.3.0"
 
 serde = "1.0.118"
+serde_json = "1.0.56"

crates/interpreter-interface/src/call_request_parameters.rs

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2021 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use marine_rs_sdk::marine;
+use serde::Deserialize;
+use serde::Serialize;
+use std::collections::HashMap;
+
+pub type CallRequests = HashMap<u32, CallRequestParams>;
+
+/// Contains arguments of a call instruction and all other necessary information
+/// required for calling a service.
+#[marine]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CallRequestParams {
+    /// Id of a service that should be called.
+    pub service_id: String,
+
+    /// Name of a function from service identified by service_id that should be called.
+    pub function_name: String,
+
+    /// Serialized to JSON string Vec<JValue> of arguments that should be passed to a service.
+    pub arguments: String,
+
+    /// Serialized to JSON string Vec<Vec<SecurityTetraplet>> that should be passed to a service.
+    pub tetraplets: String,
+}
+
+impl CallRequestParams {
+    pub fn new(
+        service_id: String,
+        function_name: String,
+        arguments: String,
+        tetraplets: String,
+    ) -> Self {
+        Self {
+            service_id,
+            function_name,
+            arguments,
+            tetraplets,
+        }
+    }
+}

crates/interpreter-interface/src/call_service_result.rs

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2021 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use serde::Deserialize;
+use serde::Serialize;
+use serde_json::Value as JValue;
+use std::collections::HashMap;
+
+pub type CallResults = HashMap<u32, CallServiceResult>;
+pub const CALL_SERVICE_SUCCESS: i32 = 0;
+
+/// Represents an executed host function result.
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct CallServiceResult {
+    /// A error code service or builtin returned, where CALL_SERVICE_SUCCESS represents success.
+    pub ret_code: i32,
+
+    /// Resulted JValue serialized to a string. It's impossible to wrap it with the marine macro,
+    /// inasmuch as it's a enum uses HashMap inside.
+    pub result: String,
+}
+
+impl CallServiceResult {
+    pub fn ok(result: &JValue) -> Self {
+        Self {
+            ret_code: CALL_SERVICE_SUCCESS,
+            result: result.to_string(),
+        }
+    }
+
+    pub fn err(err_code: i32, result: &JValue) -> Self {
+        Self {
+            ret_code: err_code,
+            result: result.to_string(),
+        }
+    }
+}
+
+use std::fmt;
+
+impl fmt::Display for CallServiceResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "ret_code: {}, result: '{}'", self.ret_code, self.result)
+    }
+}

crates/interpreter-interface/src/interpreter_outcome.rs

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2021 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use marine_rs_sdk::marine;
+
+use fluence_it_types::IValue;
+use serde::Deserialize;
+use serde::Serialize;
+
+pub const INTERPRETER_SUCCESS: i32 = 0;
+
+/// Describes a result returned at the end of the interpreter execution_step.
+#[marine]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct InterpreterOutcome {
+    /// A return code, where INTERPRETER_SUCCESS means success.
+    pub ret_code: i32,
+
+    /// Contains error message if ret_code != INTERPRETER_SUCCESS.
+    pub error_message: String,
+
+    /// Contains script data that should be preserved in an executor of this interpreter
+    /// regardless of ret_code value.
+    pub data: Vec<u8>,
+
+    /// Public keys of peers that should receive data.
+    pub next_peer_pks: Vec<String>,
+
+    /// Collected parameters of all met call instructions that could be executed on a current peer.
+    pub call_requests: Vec<u8>,
+}
+
+impl InterpreterOutcome {
+    pub fn from_ivalue(ivalue: IValue) -> Result<Self, String> {
+        const OUTCOME_FIELDS_COUNT: usize = 5;
+
+        let mut record_values = try_as_record(ivalue)?.into_vec();
+        if record_values.len() != OUTCOME_FIELDS_COUNT {
+            return Err(format!(
+                "expected InterpreterOutcome struct with {} fields, got {:?}",
+                OUTCOME_FIELDS_COUNT, record_values
+            ));
+        }
+
+        let call_requests = try_as_byte_vec(record_values.pop().unwrap(), "call_requests")?;
+        let next_peer_pks = try_as_string_vec(record_values.pop().unwrap(), "next_peer_pks")?;
+        let data = try_as_byte_vec(record_values.pop().unwrap(), "data")?;
+        let error_message = try_as_string(record_values.pop().unwrap(), "error_message")?;
+        let ret_code = try_as_i32(record_values.pop().unwrap(), "ret_code")?;
+
+        let outcome = Self {
+            ret_code,
+            error_message,
+            data,
+            next_peer_pks,
+            call_requests,
+        };
+
+        Ok(outcome)
+    }
+}
+
+use fluence_it_types::ne_vec::NEVec;
+
+fn try_as_record(ivalue: IValue) -> Result<NEVec<IValue>, String> {
+    match ivalue {
+        IValue::Record(record_values) => Ok(record_values),
+        v => {
+            return Err(format!(
+                "expected record for InterpreterOutcome, got {:?}",
+                v
+            ))
+        }
+    }
+}
+
+fn try_as_i32(ivalue: IValue, field_name: &str) -> Result<i32, String> {
+    match ivalue {
+        IValue::S32(value) => Ok(value),
+        v => return Err(format!("expected an i32 for {}, got {:?}", field_name, v)),
+    }
+}
+
+fn try_as_string(ivalue: IValue, field_name: &str) -> Result<String, String> {
+    match ivalue {
+        IValue::String(value) => Ok(value),
+        v => return Err(format!("expected a string for {}, got {:?}", field_name, v)),
+    }
+}
+
+fn try_as_byte_vec(ivalue: IValue, field_name: &str) -> Result<Vec<u8>, String> {
+    let byte_vec = match ivalue {
+        IValue::Array(array) => {
+            let array: Result<Vec<_>, _> = array
+                .into_iter()
+                .map(|v| match v {
+                    IValue::U8(byte) => Ok(byte),
+                    v => Err(format!("expected a byte, got {:?}", v)),
+                })
+                .collect();
+            array?
+        }
+        IValue::ByteArray(array) => array,
+        v => {
+            return Err(format!(
+                "expected a Vec<u8> for {}, got {:?}",
+                field_name, v
+            ))
+        }
+    };
+
+    Ok(byte_vec)
+}
+
+fn try_as_string_vec(ivalue: IValue, field_name: &str) -> Result<Vec<String>, String> {
+    match ivalue {
+        IValue::Array(ar_values) => {
+            let array = ar_values
+                .into_iter()
+                .map(|v| match v {
+                    IValue::String(str) => Ok(str),
+                    v => Err(format!("expected string for next_peer_pks, got {:?}", v)),
+                })
+                .collect::<Result<Vec<String>, _>>()?;
+
+            Ok(array)
+        }
+        v => Err(format!("expected an array for {}, got {:?}", field_name, v)),
+    }
+}

crates/interpreter-interface/src/lib.rs

@@ -14,101 +14,12 @@
  * limitations under the License.
  */
 
-use marine_rs_sdk::marine;
+mod call_request_parameters;
+mod call_service_result;
+mod interpreter_outcome;
+mod run_parameters;
 
-use fluence_it_types::IValue;
-use serde::Deserialize;
-use serde::Serialize;
-
-pub const INTERPRETER_SUCCESS: i32 = 0;
-
-/// Describes a result returned at the end of the interpreter execution_step.
-#[marine]
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct InterpreterOutcome {
-    /// A return code, where INTERPRETER_SUCCESS means success.
-    pub ret_code: i32,
-
-    /// Contains error message if ret_code != INTERPRETER_SUCCESS.
-    pub error_message: String,
-
-    /// Contains script data that should be preserved in an executor of this interpreter
-    /// regardless of ret_code value.
-    pub data: Vec<u8>,
-
-    /// Public keys of peers that should receive data.
-    pub next_peer_pks: Vec<String>,
-}
-
-impl InterpreterOutcome {
-    pub fn from_ivalues(mut ivalues: Vec<IValue>) -> Result<Self, String> {
-        const OUTCOME_FIELDS_COUNT: usize = 4;
-
-        let record_values = match ivalues.remove(0) {
-            IValue::Record(record_values) => record_values,
-            v => {
-                return Err(format!(
-                    "expected record for InterpreterOutcome, got {:?}",
-                    v
-                ))
-            }
-        };
-
-        let mut record_values = record_values.into_vec();
-        if record_values.len() != OUTCOME_FIELDS_COUNT {
-            return Err(format!(
-                "expected InterpreterOutcome struct with {} fields, got {:?}",
-                OUTCOME_FIELDS_COUNT, record_values
-            ));
-        }
-
-        let ret_code = match record_values.remove(0) {
-            IValue::S32(ret_code) => ret_code,
-            v => return Err(format!("expected i32 for ret_code, got {:?}", v)),
-        };
-
-        let error_message = match record_values.remove(0) {
-            IValue::String(str) => str,
-            v => return Err(format!("expected string for data, got {:?}", v)),
-        };
-
-        let data = match record_values.remove(0) {
-            IValue::Array(array) => {
-                let array: Result<Vec<_>, _> = array
-                    .into_iter()
-                    .map(|v| match v {
-                        IValue::U8(byte) => Ok(byte),
-                        v => Err(format!("expected a byte, got {:?}", v)),
-                    })
-                    .collect();
-                array?
-            }
-            IValue::ByteArray(array) => array,
-            v => return Err(format!("expected Vec<u8> for data, got {:?}", v)),
-        };
-
-        let next_peer_pks = match record_values.remove(0) {
-            IValue::Array(ar_values) => {
-                let array = ar_values
-                    .into_iter()
-                    .map(|v| match v {
-                        IValue::String(str) => Ok(str),
-                        v => Err(format!("expected string for next_peer_pks, got {:?}", v)),
-                    })
-                    .collect::<Result<Vec<String>, _>>()?;
-
-                Ok(array)
-            }
-            v => Err(format!("expected array for next_peer_pks, got {:?}", v)),
-        }?;
-
-        let outcome = Self {
-            ret_code,
-            error_message,
-            data,
-            next_peer_pks,
-        };
-
-        Ok(outcome)
-    }
-}
+pub use call_request_parameters::*;
+pub use call_service_result::*;
+pub use interpreter_outcome::*;
+pub use run_parameters::*;

crates/interpreter-interface/src/run_parameters.rs

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2021 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use marine_rs_sdk::marine;
+use serde::Deserialize;
+use serde::Serialize;
+
+/// Parameters that a host side should pass to an interpreter and that necessary for execution.
+#[marine]
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+pub struct RunParameters {
+    /// Peer id of a peer that start this particle.
+    pub init_peer_id: String,
+
+    /// Peer id of a current peer.
+    pub current_peer_id: String,
+}