Requests

It reads like the Request it came from, moves to any thread, and answers 500 when dropped unreplied. Its replies hand back a Deferred while a file or path part still sends, and waiting on one belongs off the polling thread, as that thread is the one sending it.

use std::sync::mpsc;
use ucall::*;

let (handed, received) = mpsc::channel::<DetachedRequest>();
let mut server = Server::new(&[Interface::new("127.0.0.1:0")])?;
server.get("/clip", move |request: Request| handed.send(request.detach()).unwrap())?;
let address = server.address(0).unwrap().to_owned();

// The worker outlives the scope, as the sender it waits on lives in the server's handler.
std::thread::spawn(move || {
    for detached in received {
        let parts = [ReplyPart::Bytes(b"frame".into())];
        if let Ok(Some(deferred)) = detached.reply_parts(HTTPStatus::OK, &[], &parts) {
            let _ = deferred.wait(); // or: deferred.await
        }
    }
});
let mut client = Client::new(ClientOptions { connections: 1, ..Default::default() })?;
std::thread::scope(|scope| {
    let polling = scope.spawn(|| server.take_calls(0));
    let response = client.get(format!("http://{address}/clip"));
    server.stop();
    polling.join().unwrap()?;
    assert_eq!(response?.body(), b"frame");
    Ok::<(), Error>(())
})?;

It owns its received bytes, so it may move to any thread and be replied to there after its handler returned. Dropping it unreplied answers 500. Reads the library refuses, which happens only on a thread whose CPU cannot run the server's class, read as empty.

use std::sync::mpsc;
use ucall::*;

let (handed, received) = mpsc::channel::<Request>();
let mut server = Server::new(&[Interface::new("127.0.0.1:0")])?;
server.get("/users/{name}", move |request: Request| handed.send(request).unwrap())?;
let address = server.address(0).unwrap().to_owned();

// The worker outlives the scope, as the sender it waits on lives in the server's handler.
std::thread::spawn(move || {
    for request in received {
        let name = request.path_parameter("name").unwrap_or_default();
        let greeting = [b"Hello, ", name].concat();
        let _ = request.reply(HTTPStatus::OK, &[], &greeting);
    }
});
let mut client = Client::new(ClientOptions { connections: 1, ..Default::default() })?;
std::thread::scope(|scope| {
    let polling = scope.spawn(|| server.take_calls(0));
    let response = client.get(format!("http://{address}/users/ada?verbose=1"));
    server.stop();
    polling.join().unwrap()?;
    assert_eq!(response?.body(), b"Hello, ada");
    Ok::<(), Error>(())
})?;

Deferred::status polls without blocking, Deferred::wait blocks until the reply is final, and .await polls it from async code. Dropping one that is not final waits for it, so it belongs off the polling thread, which is the one finishing it.

The library has no wake-up, so an executor re-polls it while other tasks run, spinning only when nothing else is ready; Deferred::wait blocks on the CPU class's waiter.