Serving

Requests from every event loop share its queue, so one thread drains what all of them received. Dropping it leaves its queued requests unanswered until the server is freed, and the queue, once full, refuses new ones with 503.

use std::time::Duration;
use ucall::*;

let mut server = Server::new(&[Interface::new("127.0.0.1:0")])?;
let batching = Batching { min_size: 2, max_size: 2, max_latency: Duration::from_secs(1) };
let scores = server.batch("/score", Verb::Post, batching, |batch: Batch| {
    for request in batch {
        let score = request.body().len().to_string();
        let _ = request.reply(HTTPStatus::OK, &[], score.as_bytes());
    }
})?;
let address = server.address(0).unwrap().to_owned();

let mut client = Client::new(ClientOptions { connections: 2, ..Default::default() })?;
client.submit(ClientCall::post(format!("http://{address}/score"), b"four".as_slice()), 0)?;
client.submit(ClientCall::post(format!("http://{address}/score"), b"seven..".as_slice()), 1)?;
std::thread::scope(|scope| {
    scope.spawn(|| server.take_calls(0));
    scope.spawn(|| scores.take_batches());
    let mut completed: [Completed; 2] = Default::default();
    let mut answered = 0;
    while answered < 2 {
        match client.take_completed(&mut completed, Duration::from_secs(1)) {
            Ok(done) => answered += done.len(),
            Err(_) => break,
        }
    }
    server.stop();
});
let statistics = scores.statistics()?;
assert_eq!((statistics.batches, statistics.requests, statistics.filled_batches), (1, 2, 1));

Each counter is read on its own, so a snapshot of an endpoint being polled is not one instant. Requests released by Server::stop count nowhere.

Each counter is read on its own, so a snapshot of a running loop is not one instant. Byte counters cover the bytes UCall itself moves, never the kernel's own copies.

One server may answer plaintext on loopback and Noise on the wire at once, through two interfaces:

use ucall::*;

let (private_key, _) = generate_noise_keypair()?;
let plain = Interface::new("127.0.0.1:0");
let sealed = Interface::new("127.0.0.1:0")
    .security(Security::NoiseXX, private_key)
    .peer_authorizer(|noise_private_key: &NoiseKey| noise_private_key != &[0; 32]);
let server = Server::new(&[plain, sealed])?;
assert!(server.address(1).is_some());

Register every endpoint first, through &mut self, then share &Server with the threads that poll its event loops. Dropping it stops the server; the library frees it once the last BatchEndpoint and retained Request are dropped too.

use ucall::*;

let mut server = Server::new(&[Interface::new("127.0.0.1:0")])?;
server.get("/hello", |request: Request| {
    let _ = request.reply(HTTPStatus::OK, &["content-type: text/plain".into()], b"Hello!");
})?;
let address = server.address(0).unwrap().to_owned();

let mut client = Client::new(ClientOptions { connections: 1, ..Default::default() })?;
std::thread::scope(|scope| {
    for event_loop in 0..server.event_loops() {
        let server = &server;
        scope.spawn(move || server.take_calls(event_loop));
    }
    let response = client.get(format!("http://{address}/hello"));
    server.stop();
    assert_eq!(response?.body(), b"Hello!");
    Ok::<(), Error>(())
})?;
assert_eq!(server.event_loop_statistics(0)?.requests, 1);

Prints and parses its stable name, like "linux-uring618".