Struct MemoryStore 

pub struct MemoryStore { /* private fields */ }

A store that keeps everything in memory.

For tests and for bringing a board up before its flash driver works. It is not a leaf node’s storage: it satisfies the durability contract only in the sense that there is nothing to lose power.

Implementations

impl MemoryStore

pub fn new() -> Self

Creates an empty store.

Examples found in repository

examples/wasi_host_shim.rs (line 123)

fn run() -> Result<(), String> {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let [app_id, peer, now] = args.as_slice() else {
        return Err(USAGE.to_string());
    };
    let now_unix_secs: u64 = now
        .parse()
        .map_err(|_| format!("now_unix_secs must be a whole number of seconds, got {now:?}"))?;

    // `shared_store` rather than `Arc::new`: it is the one constructor that
    // builds on every target the crate supports, so it is the route to copy.
    let store = shared_store(MemoryStore::new());

    // Provisioning draws from the getrandom backend the target selects. On
    // WASI that is the runtime's `random_get`; see the header.
    let mut device =
        LeafDevice::open(store, app_id).map_err(|error| format!("opening the device: {error}"))?;
    eprintln!("address {}", device.address());

    let stdout = io::stdout();
    let mut out = stdout.lock();

    // Pairing starts with the device's key package. The time is supplied, not
    // read: with `now_unix_secs` the package's validity window is real, and
    // without it the library would stamp 1970.
    let advertisement = device
        .key_package_frame(peer, now_unix_secs)
        .map_err(|error| format!("minting the key package: {error}"))?;
    emit(&mut out, &advertisement)?;

    // Steady state: frames arrive, the device verifies each, opens it if it is
    // sealed, persists, and only then hands back what it owes in reply.
    for (index, line) in io::stdin().lock().lines().enumerate() {
        let line = line.map_err(|error| format!("reading standard input: {error}"))?;
        if line.trim().is_empty() {
            continue;
        }
        let inbound = Message::from_json(&line)
            .map_err(|error| format!("line {}: not a frame: {error}", index + 1))?;
        match device.handle(&inbound, now_unix_secs) {
            Ok(handled) => {
                for event in &handled.events {
                    eprintln!("event {event:?}");
                }
                for frame in &handled.outbound {
                    emit(&mut out, frame)?;
                }
            }
            Err(error) => eprintln!("line {}: refused: {error}", index + 1),
        }
    }

    // Answering. The persist is inside `seal`, before it returns anything, so
    // there is no ordering here to get wrong. Without the phone's Welcome
    // there is no session, and the crate says so rather than sealing into a
    // group that does not exist.
    match device.seal(peer, GREETING, now_unix_secs) {
        Ok(frame) => emit(&mut out, &frame),
        Err(LeafError::NoSession(_)) => {
            eprintln!(
                "no session with {peer}: nothing sealed. A session exists only after the \
                 phone's Welcome, and no frame on standard input carried one."
            );
            Ok(())
        }
        Err(error) => Err(format!("sealing to {peer}: {error}")),
    }
}

pub fn len(&self) -> usize

Number of entries held, for tests that assert what was written.

pub fn is_empty(&self) -> bool

Whether the store holds nothing.

Trait Implementations

impl Debug for MemoryStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MemoryStore

fn default() -> Self

Returns the “default value” for a type.

impl LeafStore for MemoryStore

fn store( &self, key_type: &str, key_id: &str, data: &[u8], ) -> Result<(), StoreError>

Writes data, replacing any previous value for this key.

fn load( &self, key_type: &str, key_id: &str, ) -> Result<Option<Vec<u8>>, StoreError>

Reads a value, or None if this key was never written.

fn delete(&self, key_type: &str, key_id: &str) -> Result<(), StoreError>

Removes a value. Removing a key that is not there is not an error.