update to marine, marine-test, bump versions

multi-service/block_getter/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-fluence = { version = "=0.6.2", features = ["logger"] }
+fluence = { version = "=0.6.9", features = ["logger"] }
 log = "0.4.14"
 serde_json = "1.0.64"
 fstrings = "0.2.3"

multi-service/block_getter/src/eth_block_getters.rs

@@ -15,7 +15,7 @@
  */
 
 use crate::curl_request;
-use fluence::fce;
+use fluence::marine;
 use fluence::MountedBinaryResult;
 
 fn result_to_string(result: MountedBinaryResult) -> String {
@@ -25,7 +25,7 @@ fn result_to_string(result: MountedBinaryResult) -> String {
     String::from_utf8(result.stderr).expect("Found invalid UTF-8")
 }
 
-#[fce]
+#[marine]
 pub fn get_latest_block(api_key: String) -> String {
     let url =
         f!("https://api.etherscan.io/api?module=proxy&action=eth_blockNumber&apikey={api_key}");
@@ -38,7 +38,7 @@ pub fn get_latest_block(api_key: String) -> String {
     serde_json::from_value(obj["result"].clone()).unwrap()
 }
 
-#[fce]
+#[marine]
 pub fn get_block(api_key: String, block_number: u32) -> String {
     let url = f!("https://api.etherscan.io/api?module=block&action=getblockreward&blockno={block_number}&apikey={api_key}");
     let header = "-d \"\"";

multi-service/block_getter/src/main.rs

@@ -18,7 +18,7 @@ extern crate fstrings;
 
 use fluence::module_manifest;
 use fluence::MountedBinaryResult;
-use fluence::{fce, WasmLoggerBuilder};
+use fluence::{marine, WasmLoggerBuilder};
 
 mod eth_block_getters;
 
@@ -28,7 +28,7 @@ fn main() {
     WasmLoggerBuilder::new().build().ok();
 }
 
-#[fce]
+#[marine]
 #[link(wasm_import_module = "curl_adapter")]
 extern "C" {
     pub fn curl_request(curl_cmd: Vec<String>) -> MountedBinaryResult;

multi-service/curl_adapter/Cargo.toml

@@ -10,6 +10,6 @@ path = "src/main.rs"
 name = "curl_adapter"
 
 [dependencies]
-fluence = { version = "=0.6.2", features = ["logger"] }
+fluence = { version = "=0.6.9", features = ["logger"] }
 log = "0.4.14"
 serde_json = "1.0.64"

multi-service/curl_adapter/src/main.rs

@@ -15,7 +15,7 @@
  */
 #![allow(improper_ctypes)]
 
-use fluence::fce;
+use fluence::marine;
 use fluence::module_manifest;
 use fluence::MountedBinaryResult;
 use fluence::WasmLoggerBuilder;
@@ -26,14 +26,14 @@ fn main() {
     WasmLoggerBuilder::new().build().unwrap();
 }
 
-#[fce]
+#[marine]
 pub fn curl_request(curl_cmd: Vec<String>) -> MountedBinaryResult {
     let response = curl(curl_cmd);
     response
 }
 
 // mounted_binaries are available to import like this:
-#[fce]
+#[marine]
 #[link(wasm_import_module = "host")]
 extern "C" {
     pub fn curl(cmd: Vec<String>) -> MountedBinaryResult;

multi-service/ethqlite/Cargo.toml

@@ -9,7 +9,7 @@ name = "ethqlite"
 path = "src/main.rs"
 
 [dependencies]
-fluence = { version="0.6.2", features = ["logger"]}
+fluence = { version="0.6.9", features = ["logger"]}
 log = "0.4.8"
 fce-sqlite-connector = "=0.4.0"
 serde = {version = "1.0.118",  features=["derive"]}

multi-service/ethqlite/build.sh

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
 set -o errexit -o nounset -o pipefail
 
-# This script builds all subprojects and puts all created Wasm modules in one dir
-# cargo update
-fce build --release
+
+cargo update --aggressive
+marine build --release
 
 rm -f artifacts/*.wasm
 cp target/wasm32-wasi/release/ethqlite.wasm artifacts/

multi-service/ethqlite/src/auth.rs

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-use fluence::{fce, CallParameters};
-use::fluence;
 use crate::get_connection;
+use ::fluence;
+use fluence::{marine, CallParameters};
 
 pub fn is_owner() -> bool {
     let meta = fluence::get_call_parameters();
@@ -26,7 +26,7 @@ pub fn is_owner() -> bool {
     caller == owner
 }
 
-#[fce]
+#[marine]
 pub fn am_i_owner() -> bool {
     is_owner()
-}
+}

multi-service/ethqlite/src/crud.rs

@@ -13,13 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-use fluence::fce;
 use fce_sqlite_connector;
 use fce_sqlite_connector::{Connection, Value};
+use fluence::marine;
 
-use crate::get_connection;
 use crate::auth::is_owner;
-
+use crate::get_connection;
 
 pub fn create_table(conn: &Connection) -> std::result::Result<(), fce_sqlite_connector::Error> {
     let res = conn.execute(
@@ -36,55 +35,73 @@ pub fn create_table(conn: &Connection) -> std::result::Result<(), fce_sqlite_con
     res
 }
 
-
-#[fce]
+#[marine]
 #[derive(Debug)]
 pub struct UpdateResult {
     pub success: bool,
     pub err_str: String,
 }
 
-#[fce]
-pub fn update_reward_blocks(data_string: String) -> UpdateResult {   
+#[marine]
+pub fn update_reward_blocks(data_string: String) -> UpdateResult {
     if !is_owner() {
-        return UpdateResult { success:false, err_str: "You are not the owner".into()};
+        return UpdateResult {
+            success: false,
+            err_str: "You are not the owner".into(),
+        };
     }
-    
-    let obj:serde_json::Value = serde_json::from_str(&data_string).unwrap();
+
+    let obj: serde_json::Value = serde_json::from_str(&data_string).unwrap();
     let obj = obj["result"].clone();
 
     if obj["blockNumber"] == serde_json::Value::Null {
-        return UpdateResult { success:false, err_str: "Empty reward block string".into()};
+        return UpdateResult {
+            success: false,
+            err_str: "Empty reward block string".into(),
+        };
     }
 
     let conn = get_connection();
 
     let insert = "insert or ignore into reward_blocks values(?, ?, ?, ?)";
     let mut ins_cur = conn.prepare(insert).unwrap().cursor();
-    
 
-    let insert = ins_cur.bind(
- &[Value::Integer(i64::from_str_radix(obj["blockNumber"].as_str().unwrap(), 10).unwrap()),
-          Value::Integer(i64::from_str_radix(obj["timeStamp"].as_str().unwrap(), 10).unwrap()),
-          Value::String(obj["blockMiner"].to_string()), 
-          Value::Integer(i64::from_str_radix(obj["blockReward"].clone().as_str().unwrap(), 10).unwrap()),
-        ]
-    );
+    let insert = ins_cur.bind(&[
+        Value::Integer(i64::from_str_radix(obj["blockNumber"].as_str().unwrap(), 10).unwrap()),
+        Value::Integer(i64::from_str_radix(obj["timeStamp"].as_str().unwrap(), 10).unwrap()),
+        Value::String(obj["blockMiner"].to_string()),
+        Value::Integer(
+            i64::from_str_radix(obj["blockReward"].clone().as_str().unwrap(), 10).unwrap(),
+        ),
+    ]);
 
     if insert.is_ok() {
         ins_cur.next().unwrap();
-        let mut select = conn.prepare("select * from reward_blocks").unwrap().cursor();
+        let mut select = conn
+            .prepare("select * from reward_blocks")
+            .unwrap()
+            .cursor();
         while let Some(row) = select.next().unwrap() {
             println!("select row {:?}", row);
-            println!("{}, {}", row[0].as_integer().unwrap(), row[2].as_string().unwrap());
+            println!(
+                "{}, {}",
+                row[0].as_integer().unwrap(),
+                row[2].as_string().unwrap()
+            );
         }
-        return UpdateResult { success:true, err_str: "".into()};
+        return UpdateResult {
+            success: true,
+            err_str: "".into(),
+        };
     }
 
-    UpdateResult { success:false, err_str: "Insert failed".into()}
-} 
+    UpdateResult {
+        success: false,
+        err_str: "Insert failed".into(),
+    }
+}
 
-#[fce]
+#[marine]
 #[derive(Debug)]
 pub struct RewardBlock {
     pub block_number: i64,
@@ -95,26 +112,25 @@ pub struct RewardBlock {
 
 impl RewardBlock {
     fn from_row(row: &[Value]) -> Self {
-        RewardBlock { 
-            block_number: row[0].as_integer().unwrap(), 
-            timestamp: row[1].as_integer().unwrap(), 
-            block_miner: row[2].as_string().unwrap().into(), 
-            block_reward: row[3].as_integer().unwrap().to_string(), 
+        RewardBlock {
+            block_number: row[0].as_integer().unwrap(),
+            timestamp: row[1].as_integer().unwrap(),
+            block_miner: row[2].as_string().unwrap().into(),
+            block_reward: row[3].as_integer().unwrap().to_string(),
         }
     }
 
     fn from_err() -> Self {
-        RewardBlock { 
+        RewardBlock {
             block_number: -1,
             timestamp: -1,
-            block_miner: String::from(""), 
+            block_miner: String::from(""),
             block_reward: String::from(""),
         }
     }
-
 }
 
-#[fce]
+#[marine]
 pub fn get_latest_reward_block() -> RewardBlock {
     // let db_path = "/tmp/db.sqlite";
     let conn = get_connection();
@@ -123,11 +139,11 @@ pub fn get_latest_reward_block() -> RewardBlock {
     let select = conn.prepare("select * from reward_blocks order by block_number desc limit 1");
     let result = match select {
         Ok(s) => {
-            let mut select = s.cursor(); 
+            let mut select = s.cursor();
             while let Some(row) = select.next().unwrap() {
                 println!("get_latest_reward_block: {:?}", row);
                 reward_block = RewardBlock::from_row(row);
-            };
+            }
             return reward_block;
         }
         Err(e) => reward_block,
@@ -135,7 +151,7 @@ pub fn get_latest_reward_block() -> RewardBlock {
     result
 }
 
-#[fce]
+#[marine]
 pub fn get_reward_block(block_number: u32) -> RewardBlock {
     let conn = get_connection();
 
@@ -145,35 +161,35 @@ pub fn get_reward_block(block_number: u32) -> RewardBlock {
     match select {
         Ok(s) => {
             let mut select = s.cursor();
-            select.bind(&[Value::Integer(block_number as i64)]).unwrap(); 
+            select.bind(&[Value::Integer(block_number as i64)]).unwrap();
             while let Some(row) = select.next().unwrap() {
                 println!("get_reward_block: {:?}", row);
                 reward_block = RewardBlock::from_row(row);
-            };
+            }
             return reward_block;
         }
-        Err(e) => reward_block
+        Err(e) => reward_block,
     }
 }
 
-#[fce]
+#[marine]
 #[derive(Debug)]
 pub struct MinerRewards {
     pub miner_address: String,
-    pub rewards: Vec<String>
+    pub rewards: Vec<String>,
 }
 impl MinerRewards {
     fn new(miner_address: String) -> Self {
-        let rewards:Vec<String> = Vec::new();
+        let rewards: Vec<String> = Vec::new();
 
         MinerRewards {
             miner_address,
-            rewards
-        } 
+            rewards,
+        }
     }
 }
 
-#[fce]
+#[marine]
 pub fn get_miner_rewards(miner_address: String) -> MinerRewards {
     let conn = get_connection();
 
@@ -187,8 +203,10 @@ pub fn get_miner_rewards(miner_address: String) -> MinerRewards {
             select.bind(&[Value::String(miner_address)]).unwrap();
             while let Some(row) = select.next().unwrap() {
                 println!("reward row {:?}", row);
-                miner_rewards.rewards.push(row[0].as_integer().unwrap().to_string());
-            };
+                miner_rewards
+                    .rewards
+                    .push(row[0].as_integer().unwrap().to_string());
+            }
         }
         Err(e) => log::error!("suck it"), //(format!("{:?}",e))
     };

multi-service/ethqlite/src/main.rs

@@ -14,70 +14,76 @@
  * limitations under the License.
  */
 
-use fluence::fce; ///, WasmLoggerBuilder};
-use fluence;
-use fluence::WasmLoggerBuilder;
 use fce_sqlite_connector;
 use fce_sqlite_connector::{Connection, State, Value};
+///, WasmLoggerBuilder};
+use fluence;
+use fluence::marine;
+use fluence::WasmLoggerBuilder;
 
-
-use std::path::{Path, PathBuf};
 use serde::Deserialize;
 use serde_json;
+use std::path::{Path, PathBuf};
 
 use std::sync::atomic::{AtomicBool, Ordering};
 
-use crate::crud::create_table;
 use crate::auth::is_owner;
+use crate::crud::create_table;
 
-const DB_PATH: &str  = "/tmp/fluence_service_db.sqlite";
+const DB_PATH: &str = "/tmp/fluence_service_db.sqlite";
 
-
-mod crud;
 mod auth;
+mod crud;
 
 pub static INIT: AtomicBool = AtomicBool::new(false);
 
 fn main() {}
 
-
 fn get_connection() -> Connection {
     Connection::open(DB_PATH).unwrap()
 }
 
-
-#[fce]
+#[marine]
 #[derive(Debug)]
 pub struct InitResult {
     pub success: bool,
     pub err_msg: String,
 }
 
-#[fce]
+#[fmarinece]
 pub fn init_service() -> InitResult {
-
     if !is_owner() {
-        return InitResult {success: false, err_msg: "Not authorized to use this service".into()};
+        return InitResult {
+            success: false,
+            err_msg: "Not authorized to use this service".into(),
+        };
     }
 
     if INIT.load(Ordering::Relaxed) {
-        return InitResult {success: false, err_msg: "Service already initiated".into()};
+        return InitResult {
+            success: false,
+            err_msg: "Service already initiated".into(),
+        };
     }
 
     let conn = get_connection();
     let res = create_table(&conn);
     if res.is_err() {
-        return InitResult {success: false, err_msg: "Failure to create tables".into()};
+        return InitResult {
+            success: false,
+            err_msg: "Failure to create tables".into(),
+        };
     }
-    
     // TODO: implement rollbacks
 
     INIT.store(true, Ordering::Relaxed);
-    InitResult {success: true, err_msg: "".into()}
+    InitResult {
+        success: true,
+        err_msg: "".into(),
+    }
 }
 
-
-#[fce]
+#[marine]
 pub fn owner_nuclear_reset() -> bool {
     if !is_owner() {
         return false;

multi-service/extract_miner_address/Cargo.toml

@@ -7,6 +7,6 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-fluence = { version = "=0.6.2", features = ["logger"] }
+fluence = { version = "=0.6.9", features = ["logger"] }
 log = "0.4.8"
 serde_json = "1.0.64"

multi-service/extract_miner_address/src/main.rs

@@ -1,5 +1,5 @@
 use fluence::module_manifest;
-use fluence::{fce, WasmLoggerBuilder};
+use fluence::{marine, WasmLoggerBuilder};
 use serde_json;
 
 module_manifest!();
@@ -8,7 +8,7 @@ fn main() {
     WasmLoggerBuilder::new().build().ok();
 }
 
-#[fce]
+#[marine]
 pub fn extract_miner_address(json_string: String) -> String {
     let obj = serde_json::from_str::<serde_json::Value>(&json_string);
     match obj {

multi-service/hex_converter/Cargo.toml

@@ -4,9 +4,7 @@ version = "0.1.0"
 authors = ["boneyard93501 <4523011+boneyard93501@users.noreply.github.com>"]
 edition = "2018"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-fluence = { version = "=0.6.2", features = ["logger"] }
+fluence = { version = "=0.6.9", features = ["logger"] }
 log = "0.4.8"
 serde_json = "1.0.64"

multi-service/hex_converter/src/main.rs

@@ -15,7 +15,7 @@
  */
 
 use fluence::module_manifest;
-use fluence::{fce, WasmLoggerBuilder};
+use fluence::{marine, WasmLoggerBuilder};
 use serde_json;
 
 module_manifest!();
@@ -24,7 +24,7 @@ fn main() {
     WasmLoggerBuilder::new().build().ok();
 }
 
-#[fce]
+#[marine]
 pub fn hex_to_int(data: String) -> u64 {
     if data.starts_with("0x") {
         let res = u64::from_str_radix(&data[2..], 16);

multi-service/scripts/build.sh

@@ -1,24 +1,20 @@
 #!/usr/bin/env bash
 set -o errexit -o nounset -o pipefail
 
-mkdir -p artifacts
-
 cd curl_adapter
-fce build --release
-cd ..
-
-cd hex_converter
-fce build --release
-cd ..
-
-cd block_getter
-fce build --release
-cd ..
-
-cd extract_miner_address
-fce build --release
+marine build --release
+
+cd ../hex_converter
+marine build --release
+
+cd ../block_getter
+marine build --release
+
+cd ../extract_miner_address
+marine build --release
 cd ..
 
+mkdir -p artifacts
 rm -f artifacts/*.wasm
 
 cp curl_adapter/target/wasm32-wasi/release/curl_adapter.wasm artifacts/

multi-service/simple_range_func/src/main.rs

@@ -1,11 +1,11 @@
-use fluence::fce;
+use fluence::marine;
 use fluence::module_manifest;
 
 module_manifest!();
 
 fn main() {}
 
-#[fce]
+#[marine]
 fn simple_range_list(start: i64, step: u32, n: u32) -> Vec<i64> {
     let mut result: Vec<i64> = Vec::new();
     let stop = start - n as i64;