add FCE examples

ipfs-node/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+.repl_history
+/target
+**/**.bak
+**/**.bk
+/artifacts
+keypair.json

ipfs-node/Config.toml

@@ -0,0 +1,17 @@
+modules_dir = "artifacts/"
+
+[[module]]
+    name = "ipfs_effector"
+    mem_pages_count = 100
+    logger_enabled = true
+
+    [module.mounted_binaries]
+    ipfs = "/usr/local/bin/ipfs"
+
+    [module.wasi]
+    envs = { "IPFS_ADDR" = "/dns4/relay02.fluence.dev/tcp/15001", "timeout" = "1s" }
+
+[[module]]
+    name = "ipfs_pure"
+    mem_pages_count = 100
+    logger_enabled = true

ipfs-node/build.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# This script builds all subprojects and puts all created Wasm modules in one dir
+cd effector
+cargo update
+fce build --release
+cd ../pure
+cargo update
+fce build --release
+
+cd ..
+rm artifacts/*
+cp ../../target/wasm32-wasi/release/ipfs_effector.wasm artifacts/
+cp ../../target/wasm32-wasi/release/ipfs_pure.wasm artifacts/

ipfs-node/effector/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "ipfs-effector"
+version = "0.1.0"
+authors = ["Fluence Labs"]
+edition = "2018"
+publish = false
+
+[[bin]]
+name = "ipfs_effector"
+path = "src/main.rs"
+
+[dependencies]
+fluence = { version = "=0.3.2", features = ["logger"] }
+log = "0.4.11"

ipfs-node/effector/src/main.rs

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2020 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.
+ */
+
+#![allow(improper_ctypes)]
+
+mod path;
+
+use crate::path::to_full_path;
+
+use fluence::fce;
+use fluence::WasmLoggerBuilder;
+use fluence::MountedBinaryResult;
+
+const RESULT_FILE_PATH: &str = "/tmp/ipfs_rpc_file";
+const IPFS_ADDR_ENV_NAME: &str = "IPFS_ADDR";
+const TIMEOUT_ENV_NAME: &str = "timeout";
+
+pub fn main() {
+    WasmLoggerBuilder::new()
+        .with_log_level(log::Level::Info)
+        .build()
+        .unwrap();
+}
+
+/// Put file from specified path to IPFS and return its hash.
+#[fce]
+pub fn put(file_path: String) -> String {
+    log::info!("put called with file path {}", file_path);
+
+    let file_path = to_full_path(file_path);
+
+    let timeout = std::env::var(TIMEOUT_ENV_NAME).unwrap_or_else(|_| "1s".to_string());
+    let cmd = vec![
+        String::from("add"),
+        String::from("--timeout"),
+        timeout,
+        String::from("-Q"),
+        file_path,
+    ];
+
+    let ipfs_result = unsafe { ipfs(cmd) };
+    ipfs_result
+        .into_std()
+        .unwrap()
+        .unwrap_or_else(std::convert::identity)
+}
+
+/// Get file by provided hash from IPFS, saves it to a temporary file and returns a path to it.
+#[fce]
+pub fn get(hash: String) -> String {
+    log::info!("get called with hash {}", hash);
+
+    let result_file_path = to_full_path(RESULT_FILE_PATH);
+
+    let timeout = std::env::var(TIMEOUT_ENV_NAME).unwrap_or_else(|_| "1s".to_string());
+    let cmd = vec![
+        String::from("get"),
+        String::from("--timeout"),
+        timeout,
+        String::from("-o"),
+        result_file_path,
+        hash,
+    ];
+
+    unsafe { ipfs(cmd) };
+    RESULT_FILE_PATH.to_string()
+}
+
+#[fce]
+pub fn get_address() -> String {
+    match std::env::var(IPFS_ADDR_ENV_NAME) {
+        Ok(addr) => addr,
+        Err(e) => format!(
+            "getting {} env variable failed with error {:?}",
+            IPFS_ADDR_ENV_NAME, e
+        ),
+    }
+}
+
+#[fce]
+#[link(wasm_import_module = "host")]
+extern "C" {
+    /// Execute provided cmd as a parameters of ipfs cli, return result.
+    pub fn ipfs(cmd: Vec<String>) -> MountedBinaryResult;
+}

ipfs-node/effector/src/path.rs

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020 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.
+ */
+
+pub(super) fn to_full_path<S>(cmd: S) -> String
+where
+    S: Into<String>,
+{
+    use std::path::Path;
+    use std::path::Component;
+
+    let cmd = cmd.into();
+    let path = Path::new(&cmd);
+
+    let mut components = path.components();
+    let is_absolute = components.next() == Some(Component::RootDir);
+
+    if !is_absolute {
+        return cmd;
+    }
+
+    let parent = match components.next() {
+        Some(Component::Normal(path)) => path.to_str().unwrap(),
+        _ => return cmd,
+    };
+
+    match std::env::var(parent) {
+        Ok(to_dir) => {
+            let mut full_path = std::path::PathBuf::from(to_dir);
+
+            // TODO: optimize this
+            #[allow(clippy::while_let_on_iterator)]
+            while let Some(component) = components.next() {
+                full_path.push(component);
+            }
+            full_path.to_string_lossy().into_owned()
+        }
+        Err(_) => cmd,
+    }
+}

ipfs-node/pure/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "ipfs-pure"
+version = "0.1.0"
+authors = ["Fluence Labs"]
+edition = "2018"
+publish = false
+
+[[bin]]
+name = "ipfs_pure"
+path = "src/main.rs"
+
+[dependencies]
+fluence = { version = "=0.3.2", features = ["logger"] }
+log = "0.4.11"

ipfs-node/pure/src/main.rs

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020 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.
+ */
+
+#![allow(improper_ctypes)]
+
+use fluence::fce;
+use fluence::WasmLoggerBuilder;
+
+use std::fs;
+use std::path::PathBuf;
+
+const RPC_TMP_FILEPATH: &str = "/tmp/ipfs_rpc_file";
+
+pub fn main() {
+    WasmLoggerBuilder::new()
+        .with_log_level(log::Level::Info)
+        .build()
+        .unwrap();
+}
+
+#[fce]
+pub fn invoke() -> String {
+    "IPFS_RPC wasm example, it allows to:\ninvoke\nput\nget".to_string()
+}
+
+#[fce]
+pub fn put(file_content: Vec<u8>) -> String {
+    log::info!("put called with {:?}", file_content);
+
+    let rpc_tmp_filepath = RPC_TMP_FILEPATH.to_string();
+
+    let r = fs::write(PathBuf::from(rpc_tmp_filepath.clone()), file_content);
+    if let Err(e) = r {
+        return format!("file can't be written: {}", e);
+    }
+
+    unsafe { ipfs_put(rpc_tmp_filepath) }
+}
+
+#[fce]
+pub fn get(hash: String) -> Vec<u8> {
+    log::info!("get called with hash: {}", hash);
+
+    let file_path = unsafe { ipfs_get(hash) };
+    fs::read(file_path).unwrap_or_else(|_| b"error while reading file".to_vec())
+}
+
+#[fce]
+#[link(wasm_import_module = "ipfs_effector")]
+extern "C" {
+    /// Put provided file to ipfs, return ipfs hash of the file.
+    #[link_name = "put"]
+    pub fn ipfs_put(file_path: String) -> String;
+
+    /// Get file from ipfs by hash.
+    #[link_name = "get"]
+    pub fn ipfs_get(hash: String) -> String;
+}