Fluence Compute Engine

FCE is intended to run various Wasm binaries. At now, it is in the heavily developing phase. Docs and tutorials are also in the work-in-progress state.

Installation

• cargo install fcli

this will add fce binary to your system.

Usage

• fce build in Rust project

HOW TO: Create App with FCE Modules

Recommendations:

• Modules architecture should be upwards from effectors (modules that persist data and WASI modules) that will work with local binaries, local storage and syscalls to pure modules that perform business logic.
• Splitting app to small FCE modules are easier to support, reuse and distribute
• Each module for its own task (npm like)

Module project structure

• Init simple rust project cargo init --bin

• Config.toml:

[[bin]]
name = "wasm_application"
path = "src/main.rs"

[dependencies]
# logger - if you'll use logging
fluence = { git = "https://github.com/fluencelabs/rust-sdk", features = ["logger"] }

• Methods that will be exported from this module marked with #[fce]

use fluence::fce;

#[fce]
pub fn get(url: String) -> String {
...
}

• Multiple arguments with primitive Rust types (bool, u8, u16, u32, u64, i8, i16, i32, i64, f32, f64, String, Vec<u8>) and only one return argument could be used

• Build project with fce build (supports --release and all other cargo flags now)

• Copy wasm file from target/wasm32-wasi/debug or target/wasm32-wasi/release to directory with other modules

• To import other wasm modules to your project use similar code:

#[fce]
#[link(wasm_import_module = "curl")]
extern "C" {
    #[link_name = "get"]
    pub fn curl_get(url: String) -> String;
}

#[fce]
#[link(wasm_import_module = "local_storage")]
extern "C" {
    #[link_name = "get"]
    pub fn curl_get(url: String) -> String;
}

Combine modules to Application

• Create simple Rust project
• Create Config.toml to describe existed wasm modules and give accesses to host binaries and local storage if needed:

modules_dir = "wasm/artifacts/modules/"

[[module]]
    name = "local_storage"
    logger_enabled = true

    [module.wasi]
    preopened_files = ["./wasm/artifacts"]
    mapped_dirs = { "sites" = "./sites" }

[[module]]
    name = "curl"
    logger_enabled = true

    [module.imports]
    curl = "/usr/bin/curl"

[[module]]
    name = "site-storage"
    mem_pages_count = 10000
    logger_enabled = true
    [module.wasi]
    envs = ["ENV_ONE=parameter-one"]

modules_dir - path to directory with all modules. All subsequent paths will be relative to this path

[[module]] - modules list

name - wasm file name in modules_dir

mem_pages_count - a maximum number of Wasm memory pages that loaded module can use. Each Wasm pages is 65536 bytes long

[module.imports] - list of available imports

curl = "/usr/bin/curl" - gives possibility to call binary file /usr/bin/curl as method curl in Rust code

Import example:

#[fce]
#[link(wasm_import_module = "host")]
extern "C" {
    fn curl(args: String) -> String;
}

Call binary with arguments: curl("-vvv ya.ru")

[module.wasi] - this block manages communication with the "outside" world env - environment variables. Usage: std::env::var("IPFS_ADDR") preopened_files - list of available directories for loaded modules mapped_dirs - mapping between paths

Working with files as usual:

fs::write(PathBuf::from("/tmp/somefile"), vec!(1,2,3));
fs::read(...);