arachne-runtime 0.1.0

Typed Rust client API for Arachne secure peer-to-peer workspaces.
Documentation
use arachne_runtime::{
    close, create, describe, enable_record_storage, execute, restore_record_storage, wait_for_work,
};
use serde_json::{Value, json};
use std::time::Instant;

mod common;

fn call(handle: i64, request: Value) -> Result<Value, String> {
    serde_json::from_slice(&execute(handle, &serde_json::to_vec(&request).unwrap())?)
        .map_err(|error| error.to_string())
}

fn bytes(value: &Value) -> Vec<u8> {
    value
        .as_array()
        .unwrap()
        .iter()
        .map(|byte| byte.as_u64().unwrap() as u8)
        .collect()
}

struct Owner {
    handle: i64,
    peer: Value,
    address: String,
    invitation: Value,
    _dir: tempfile::TempDir,
}

fn owner(seed: u8) -> Owner {
    let handle = create(Some(&[seed; 32])).unwrap();
    let _created = call(
        handle,
        json!({"op":"create_workspace","display_name":"Owner","workspace_name":"Compact join"}),
    )
    .unwrap();
    let invitation = call(handle, json!({"op":"issue_invitation"})).unwrap();
    let info: Value = serde_json::from_str(&describe(handle).unwrap()).unwrap();
    let dir = common::directory();
    let path = dir.path().join("owner.db");
    enable_record_storage(handle, &path, &[seed; 32]).unwrap();
    Owner {
        handle,
        peer: info["endpoint_key"].clone(),
        address: info["bound_address"].as_str().unwrap().to_owned(),
        invitation,
        _dir: dir,
    }
}

fn complete_join(handle: i64) -> Value {
    loop {
        let value = call(handle, json!({"op":"drive_join"})).unwrap();
        match value["state"].as_str() {
            Some("workspace_joined") => return value,
            Some("admission_pending") => assert!(wait_for_work(handle).unwrap()),
            Some("admission_waiting") => continue,
            state => panic!("unexpected join state: {state:?}"),
        }
    }
}

#[test]
fn async_driver_persists_selected_peer_and_exact_pending_request() {
    let owner = create(Some(&[231; 32])).unwrap();
    let joiner = create(Some(&[232; 32])).unwrap();
    let _created = call(
        owner,
        json!({"op":"create_workspace","display_name":"Owner","workspace_name":"Async join"}),
    )
    .unwrap();
    let invitation = call(owner, json!({"op":"issue_invitation"})).unwrap();
    let owner_info: Value = serde_json::from_str(&describe(owner).unwrap()).unwrap();
    let owner_peer = bytes(&owner_info["endpoint_key"]);
    let pending = call(
        joiner,
        json!({
            "op":"begin_join",
            "display_name":"Pending member",
            "invitation":invitation["invitation"],
            "checkpoint":invitation["checkpoint"],
            "peers":[owner_peer],
        }),
    )
    .unwrap();
    assert!(pending.get("invitation").is_none());
    let workspace: [u8; 32] = bytes(&pending["workspace"]).try_into().unwrap();
    let request = pending["admission_request"].clone();
    let dir = common::directory();
    let database = dir.path().join("joiner.db");
    enable_record_storage(joiner, &database, &[232; 32]).unwrap();

    let started = Instant::now();
    let first = call(joiner, json!({"op":"drive_join"})).unwrap();
    assert_eq!(first["state"], "admission_pending");
    assert_eq!(first["peer"], json!(owner_peer));
    assert!(started.elapsed().as_millis() < 500, "driver still blocks on the dial");

    close(joiner).unwrap();
    let restored_handle = create(Some(&[232; 32])).unwrap();
    let restored = restore_record_storage(restored_handle, &database, &[232; 32], workspace).unwrap();
    assert_eq!(restored["state"], "pending");
    assert_eq!(restored["admission_request"], request);

    let resumed = call(restored_handle, json!({"op":"drive_join"})).unwrap();
    assert_eq!(resumed["state"], "admission_pending");
    assert_eq!(resumed["peer"], json!(owner_peer));

    let reset = call(restored_handle, json!({"op":"reset_workspace"})).unwrap();
    assert_eq!(reset["state"], "reset");
    assert!(call(restored_handle, json!({"op":"drive_join"})).is_err());

    close(restored_handle).unwrap();
    close(owner).unwrap();
}

#[test]
fn compact_pending_invitation_restores_in_rust_and_joins_without_host_hydration() {
    let owner = owner(233);
    let dir = common::directory();
    let path = dir.path().join("compact-joiner.db");
    let joiner = create(Some(&[234; 32])).unwrap();
    let pending = call(
        joiner,
        json!({
            "op":"begin_join",
            "display_name":"Compact member",
            "invitation":owner.invitation["invitation"].clone(),
            "peers":[owner.peer.clone()],
        }),
    )
    .unwrap();
    assert!(pending.get("invitation").is_none());
    let workspace: [u8; 32] = bytes(&pending["workspace"]).try_into().unwrap();
    enable_record_storage(joiner, &path, &[234; 32]).unwrap();
    close(joiner).unwrap();

    let resumed = create(Some(&[234; 32])).unwrap();
    let restored = restore_record_storage(resumed, &path, &[234; 32], workspace).unwrap();
    assert_eq!(restored["state"], "pending");
    assert_eq!(restored["activity"]["state"], "joining");
    assert!(restored.get("invitation").is_none());
    call(
        resumed,
        json!({"op":"add_address_hint","peer":owner.peer.clone(),"address":owner.address}),
    )
    .unwrap();

    let requester = std::thread::spawn(move || complete_join(resumed));
    assert!(wait_for_work(owner.handle).unwrap());
    loop {
        let value = call(owner.handle, json!({"op":"drive_workspace"})).unwrap();
        if value["state"] == "workspace_committed" {
            break;
        }
        assert_eq!(value["state"], "admission_queued");
    }
    let joined = requester.join().unwrap();
    assert_eq!(joined["state"], "workspace_joined");
    close(owner.handle).unwrap();
}