Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

9.8 KB
Raw Blame
use std::mem;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::sync::oneshot;
use wasmtime::component::{
    Component, Destination, Instance, Linker, Source, StreamConsumer, StreamProducer, StreamReader,
    StreamResult, VecBuffer,
};
use wasmtime::{Config, Engine, Result, Store, StoreContextMut};

const COMPONENT: &str = r#"
(component
  (type $s (stream u8))
  (core module $libc (memory (export "mem") 1))
  (core instance $libc (instantiate $libc))
  (core func $stream.new (canon stream.new $s))
  (core func $stream.read
    (canon stream.read $s async (memory (core memory $libc "mem"))))
  (core func $stream.write
    (canon stream.write $s async (memory (core memory $libc "mem"))))
  (core func $stream.cancel-read (canon stream.cancel-read $s))
  (core func $task.return (canon task.return (result u32)))
  (core module $m
    (import "" "mem" (memory 1))
    (import "" "stream.new" (func $stream.new (result i64)))
    (import "" "stream.read"
      (func $stream.read (param i32 i32 i32) (result i32)))
    (import "" "stream.write"
      (func $stream.write (param i32 i32 i32) (result i32)))
    (import "" "stream.cancel-read"
      (func $stream.cancel-read (param i32) (result i32)))
    (import "" "task.return" (func $task.return (param i32)))

    (global $w (mut i32) (i32.const 0))
    (data (i32.const 100) "\01\02\03\04")

    ;; Reads up to `n` items from `s`, returning the result of `stream.read`.
    (func (export "read") (param $s i32) (param $n i32) (result i32)
      (call $stream.read (local.get $s) (i32.const 200) (local.get $n)))

    ;; Starts reading up to `n` items from `s` and then cancels that,
    ;; returning the result of `stream.cancel-read`.
    (func (export "read-then-cancel") (param $s i32) (param $n i32) (result i32)
      (drop (call $stream.read (local.get $s) (i32.const 200) (local.get $n)))
      (call $task.return (call $stream.cancel-read (local.get $s)))
      (i32.const 0 (; EXIT ;)))
    (func (export "cb") (param i32 i32 i32) (result i32) unreachable)

    ;; Creates a stream, returning its readable end and keeping its writable
    ;; end for `write`.
    (func (export "new") (result i32)
      (local $rw i64)
      (local.set $rw (call $stream.new))
      (global.set $w (i32.wrap_i64 (i64.shr_u (local.get $rw) (i64.const 32))))
      (i32.wrap_i64 (local.get $rw)))

    ;; Writes `n` items at `ptr`, returning the result of `stream.write`.
    (func (export "write") (param $ptr i32) (param $n i32) (result i32)
      (call $stream.write (global.get $w) (local.get $ptr) (local.get $n))))
  (core instance $i (instantiate $m (with "" (instance
    (export "mem" (memory $libc "mem"))
    (export "stream.new" (func $stream.new))
    (export "stream.read" (func $stream.read))
    (export "stream.write" (func $stream.write))
    (export "stream.cancel-read" (func $stream.cancel-read))
    (export "task.return" (func $task.return))))))
  (func (export "read") (param "s" $s) (param "n" u32) (result u32)
    (canon lift (core func $i "read")))
  (func (export "read-then-cancel") async (param "s" $s) (param "n" u32)
    (result u32)
    (canon lift (core func $i "read-then-cancel") async
      (callback (core func $i "cb"))))
  (func (export "new") (result $s) (canon lift (core func $i "new")))
  (func (export "write") (param "ptr" u32) (param "n" u32) (result u32)
    (canon lift (core func $i "write")))
)
"#;

async fn instantiate() -> Result<(Store<()>, Instance)> {
    let mut config = Config::new();
    config.wasm_component_model_async(true);
    let engine = Engine::new(&config)?;
    let component = Component::new(&engine, COMPONENT)?;
    let mut store = Store::new(&engine, ());
    let instance = Linker::new(&engine)
        .instantiate_async(&mut store, &component)
        .await?;
    Ok((store, instance))
}

#[derive(Copy, Clone)]
enum Produce {
    /// Return `Completed` without producing anything (and eventually
    /// `Dropped`, so a host-to-host pipe can't spin forever).
    Nothing,
    /// Buffer `[1, 2, 3]` and return `Completed`, then `Dropped`.
    Items,
    /// Write `[1, 2, 3]` via `Destination::as_direct` and return `Completed`,
    /// then `Dropped`.
    DirectItems,
    /// Return `Pending` until `finish` is set, then `Cancelled`.
    Cancelled,
    /// Return `Pending` until `finish` is set, then buffer `[1, 2, 3]` and
    /// return `Cancelled`.
    CancelledWithItems,
}

struct TestProducer(Produce, usize);

impl StreamProducer<()> for TestProducer {
    type Item = u8;
    type Buffer = VecBuffer<u8>;

    fn poll_produce<'a>(
        mut self: Pin<&mut Self>,
        _cx: &mut Context<'_>,
        store: StoreContextMut<'a, ()>,
        mut dst: Destination<'a, Self::Item, Self::Buffer>,
        finish: bool,
    ) -> Poll<Result<StreamResult>> {
        self.1 += 1;
        Poll::Ready(Ok(match self.0 {
            Produce::Nothing if self.1 < 100 => StreamResult::Completed,
            Produce::Items | Produce::DirectItems if self.1 == 1 => {
                if let Produce::Items = self.0 {
                    dst.set_buffer(vec![1, 2, 3].into());
                } else {
                    let mut dst = dst.as_direct(store, 3);
                    dst.remaining()?.copy_from_slice(&[1, 2, 3]);
                    dst.mark_written(3);
                }
                StreamResult::Completed
            }
            Produce::Nothing | Produce::Items | Produce::DirectItems => StreamResult::Dropped,
            Produce::Cancelled | Produce::CancelledWithItems if !finish => return Poll::Pending,
            Produce::Cancelled => StreamResult::Cancelled,
            Produce::CancelledWithItems => {
                dst.set_buffer(vec![1, 2, 3].into());
                StreamResult::Cancelled
            }
        }))
    }
}

/// A consumer which takes everything it's given if `take` is set, or
/// otherwise nothing, and which sends what it took over `done` when dropped.
struct TestConsumer {
    take: bool,
    taken: Vec<u8>,
    done: Option<oneshot::Sender<Vec<u8>>>,
}

impl TestConsumer {
    fn new(take: bool) -> (Self, oneshot::Receiver<Vec<u8>>) {
        let (tx, rx) = oneshot::channel();
        let consumer = TestConsumer {
            take,
            taken: Vec::new(),
            done: Some(tx),
        };
        (consumer, rx)
    }
}

impl Drop for TestConsumer {
    fn drop(&mut self) {
        let _ = self.done.take().unwrap().send(mem::take(&mut self.taken));
    }
}

impl StreamConsumer<()> for TestConsumer {
    type Item = u8;

    fn poll_consume(
        mut self: Pin<&mut Self>,
        _cx: &mut Context<'_>,
        mut store: StoreContextMut<()>,
        mut src: Source<'_, Self::Item>,
        _finish: bool,
    ) -> Poll<Result<StreamResult>> {
        if self.take {
            let mut buf = Vec::with_capacity(src.remaining(&mut store)?);
            src.read(&mut store, &mut buf)?;
            self.taken.extend(buf);
        }
        Poll::Ready(Ok(StreamResult::Completed))
    }
}

/// Calls the guest's `export`, either `read` or `read-then-cancel`, with a
/// stream produced by `producer`.
async fn guest_read(export: &str, producer: Produce, n: u32) -> Result<u32> {
    let (mut store, instance) = instantiate().await?;
    let func = instance.get_typed_func::<(StreamReader<u8>, u32), (u32,)>(&mut store, export)?;
    let reader = StreamReader::new(&mut store, TestProducer(producer, 0))?;
    Ok(func.call_async(&mut store, (reader, n)).await?.0)
}

/// Has the guest write `n` items at `ptr` to a stream consumed by a
/// `TestConsumer`.
async fn guest_write(take: bool, ptr: u32, n: u32) -> Result<u32> {
    let (mut store, instance) = instantiate().await?;
    let new = instance.get_typed_func::<(), (StreamReader<u8>,)>(&mut store, "new")?;
    let write = instance.get_typed_func::<(u32, u32), (u32,)>(&mut store, "write")?;
    let (reader,) = new.call_async(&mut store, ()).await?;
    reader.pipe(&mut store, TestConsumer::new(take).0)?;
    Ok(write.call_async(&mut store, (ptr, n)).await?.0)
}

/// Pipes `producer` to a `TestConsumer` on the host, returning what the
/// consumer took once it's dropped.
async fn host_pipe(producer: Produce, take: bool) -> Result<Vec<u8>> {
    let (mut store, _instance) = instantiate().await?;
    let reader = StreamReader::new(&mut store, TestProducer(producer, 0))?;
    let (consumer, done) = TestConsumer::new(take);
    reader.pipe(&mut store, consumer)?;
    Ok(store.run_concurrent(async |_| done.await).await??)
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn consumer_completed_without_consuming() -> Result<()> {
    assert!(guest_write(false, 100, 1).await.is_err());
    assert!(host_pipe(Produce::Items, false).await.is_err());

    // A zero-length write may complete without anything being consumed.
    assert_eq!(guest_write(false, 100, 0).await?, 0);
    assert_eq!(guest_write(true, 100, 4).await?, 4 << 4); // COMPLETED(4)

    // A zero-length write is still bounds-checked.
    assert!(guest_write(true, u32::MAX, 0).await.is_err());
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn producer_completed_without_producing() -> Result<()> {
    assert!(guest_read("read", Produce::Nothing, 1).await.is_err());
    assert!(host_pipe(Produce::Nothing, true).await.is_err());

    // A zero-length read may complete without anything being produced.
    assert_eq!(guest_read("read", Produce::Nothing, 0).await?, 0);
    assert_eq!(guest_read("read", Produce::Items, 1).await?, 1 << 4); // COMPLETED(1)
    assert_eq!(host_pipe(Produce::DirectItems, true).await?, [1, 2, 3]);
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn producer_cancelled_after_producing() -> Result<()> {
    let read = "read-then-cancel";
    assert!(
        guest_read(read, Produce::CancelledWithItems, 4)
            .await
            .is_err()
    );

    let result = guest_read(read, Produce::Cancelled, 4).await?;
    assert_eq!(result, 2);
    Ok(())
}