openNGVFS/testing/standalone-test-0001/openngvfs_init_wasm_test/src/main.rs

use openngvfs_init_wasm_lib::{api_ver_get, set_auto_mount_handler, exkv_has_key, exkv_get, get_app_name, get_nagae_rov_root, vfs_mkdir};
use openngvfs_init_wasm_lib::afs::AfsInstance;
use openngvfs_init_wasm_lib::bep_ovfs::AfsBepOvFsInstance;
use openngvfs_init_wasm_lib::error::{GetKeyError};

fn main() {
    println!("Hello, world!");
    set_auto_mount_handler(auto_mount_handler);
    let (api_maj, api_min, api_pat) = api_ver_get();
    println!("API Version: {}.{}.{}", api_maj, api_min, api_pat);
    println!("App Name: {}", get_app_name())
}

fn auto_mount_handler() -> i32 {
    println!("auto mount test");
    println!("auto mount test done.");
    println!("==== Test for exkv_has_key ====");
    has_key_test("test");
    has_key_test("foo");
    has_key_test("bar");
    has_key_test("foobar");
    println!("========");
    println!("==== Test for exkv_get ====");
    get_test("test");
    get_test("foo");
    get_test("bar");
    get_test("foobar");
    println!("========");
    let ng_root = get_nagae_rov_root();
    println!("nagae root: {}", &ng_root);
    println!("==== Mount Test ====");
    let root = AfsInstance::new_afero_memfs();
    root.mount("/").unwrap();
    vfs_mkdir("/local", 0666).unwrap();
    vfs_mkdir("/ro", 0666).unwrap();
    //vfs_mkdir("/wasm", 0666).unwrap();
    let osfs = AfsInstance::new_afero_osfs();
    let local = AfsInstance::new_afero_bpfs(&osfs, &ng_root);
    local.mount("/local").unwrap();
    let local_ro = AfsInstance::new_afero_rofs(&local);
    local_ro.mount("/ro").unwrap();
    // afero.RegexpFs has some bugs with Readdir.
    //let only_wasm = AfsInstance::new_afero_regfs(&local_ro, "\\.wasm$");
    //only_wasm.mount("/wasm").unwrap();
    let rwcache_path = format!("{}/{}", ng_root, "cache/rwtest");
    let rwcache = AfsInstance::new_afero_bpfs(&osfs, &rwcache_path);
    root.mkdir("/overlay", 0666).unwrap();
    let overlay_fslayer = vec![&rwcache, &local_ro];
    let overlay = AfsBepOvFsInstance::new(&overlay_fslayer, true).unwrap();
    overlay.mount("/overlay").unwrap();
    0
}

fn has_key_test(key: &str) {
    let ret = exkv_has_key(key);
    if ret {
        println!("key exists: {}", key);
    }else{
        println!("key not exists: {}", key);
    }
}

fn get_test(key: &str) {
    let ret = exkv_get(key);
    match ret {
        Ok(v) => {
            let s = String::from_utf8_lossy(v.as_slice());
            println!("value of key {}: {}", key, s);
        }
        Err(e) => {
            match e {
                GetKeyError::KeyNotExists => {
                    println!("failed get value of key {}: key not exists", key);
                }
                GetKeyError::InternalError(emsg) => {
                    println!("failed get value of key {}: internal error: {:?}", key, emsg);
                }
            }
        }
    };
}