latzero 0.1.0

Async Rust client for latzero-server
Documentation
use std::{collections::HashMap, time::Duration};

use latzero::{CallOutcome, Client, ClientEvent, Error, Message, ProcessOptions, WorkerKind};
use serde_json::{Value, json};
use tokio::{
    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
    net::{TcpListener, tcp::OwnedReadHalf, tcp::OwnedWriteHalf},
    time,
};

async fn read_message(reader: &mut BufReader<OwnedReadHalf>) -> Message {
    let mut line = String::new();
    reader.read_line(&mut line).await.unwrap();
    assert!(!line.is_empty(), "client closed unexpectedly");
    serde_json::from_str(&line).unwrap()
}

async fn write_message(writer: &mut OwnedWriteHalf, message: &Message) {
    let mut bytes = serde_json::to_vec(message).unwrap();
    bytes.push(b'\n');
    writer.write_all(&bytes).await.unwrap();
}

fn response(request: &Message, kind: &str, payload: Value) -> Message {
    Message {
        kind: kind.to_owned(),
        request_id: request.request_id.clone(),
        client_id: request.client_id.clone(),
        pool: request.pool.clone(),
        payload,
    }
}

async fn accept_handshake(
    listener: TcpListener,
    join_payload: Value,
) -> (BufReader<OwnedReadHalf>, OwnedWriteHalf) {
    let (stream, _) = listener.accept().await.unwrap();
    let (reader, mut writer) = stream.into_split();
    let mut reader = BufReader::new(reader);

    let hello = read_message(&mut reader).await;
    assert_eq!(hello.kind, "hello");
    write_message(
        &mut writer,
        &response(&hello, "ack", json!({"server": "test"})),
    )
    .await;

    let join = read_message(&mut reader).await;
    assert_eq!(join.kind, "join_pool");
    write_message(&mut writer, &response(&join, "ack", join_payload)).await;
    (reader, writer)
}

#[tokio::test]
async fn buffers_namespaces_subscriptions_and_out_of_order_rpc() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let server = tokio::spawn(async move {
        let (mut reader, mut writer) = accept_handshake(
            listener,
            json!({"pool": "alpha", "auth_required": false, "clients": ["rust-1"]}),
        )
        .await;
        let mut values = HashMap::<String, Value>::new();
        loop {
            let request = read_message(&mut reader).await;
            match request.kind.as_str() {
                "set_buffer" => {
                    let key = request.payload["key"].as_str().unwrap().to_owned();
                    values.insert(key.clone(), request.payload["value"].clone());
                    write_message(
                        &mut writer,
                        &response(&request, "ack", json!({"key": key, "version": 1})),
                    )
                    .await;
                }
                "get_buffer" => {
                    let key = request.payload["key"].as_str().unwrap();
                    let payload = values.get(key).map_or_else(
                        || json!({"key": key, "exists": false, "entry": null}),
                        |value| {
                            json!({
                                "key": key,
                                "exists": true,
                                "entry": {
                                    "value": value,
                                    "updated_at": 1.0,
                                    "updated_by": "rust-1",
                                    "persistent": false,
                                    "ttl": null,
                                    "version": 1
                                }
                            })
                        },
                    );
                    write_message(&mut writer, &response(&request, "ack", payload)).await;
                }
                "list_buffers" => {
                    let prefix = request.payload["pattern"].as_str();
                    let mut keys: Vec<_> = values
                        .keys()
                        .filter(|key| prefix.is_none_or(|prefix| key.starts_with(prefix)))
                        .cloned()
                        .collect();
                    keys.sort();
                    write_message(
                        &mut writer,
                        &response(&request, "ack", json!({"keys": keys})),
                    )
                    .await;
                }
                "subscribe_buffer" => {
                    write_message(
                        &mut writer,
                        &response(&request, "ack", json!({"subscribed": true})),
                    )
                    .await;
                    write_message(
                        &mut writer,
                        &Message {
                            kind: "buffer_update".to_owned(),
                            request_id: None,
                            client_id: Some("other".to_owned()),
                            pool: Some("alpha".to_owned()),
                            payload: json!({
                                "key": "users:1",
                                "operation": "set",
                                "entry": {
                                    "value": {"name": "Ada"},
                                    "updated_at": 2.0,
                                    "updated_by": "other",
                                    "persistent": false,
                                    "ttl": null,
                                    "version": 2
                                }
                            }),
                        },
                    )
                    .await;
                }
                "call_app" if request.payload["response_to"] == Value::Null => {
                    // A fast target can reply before the origin receives its ack.
                    write_message(
                        &mut writer,
                        &response(&request, "app_result", json!({"value": 7, "error": null})),
                    )
                    .await;
                    write_message(
                        &mut writer,
                        &response(&request, "ack", json!({"queued": true})),
                    )
                    .await;
                }
                "call_app" => {
                    write_message(
                        &mut writer,
                        &response(&request, "ack", json!({"queued": true})),
                    )
                    .await;
                }
                "leave_pool" => {
                    write_message(
                        &mut writer,
                        &response(&request, "ack", json!({"left_pool": true})),
                    )
                    .await;
                    break;
                }
                other => panic!("unexpected request: {other}"),
            }
        }
    });

    let client = Client::builder("latzero://rust-1", "alpha")
        .port(port)
        .connect()
        .await
        .unwrap();
    let mut events = client.events();
    let users = client.namespace("users");
    users.set("1", &json!({"name": "Ada"})).await.unwrap();
    assert_eq!(
        users.get::<Value>("1").await.unwrap(),
        Some(json!({"name": "Ada"}))
    );
    assert_eq!(users.keys(None).await.unwrap(), vec!["1"]);
    assert_eq!(users.increment("counter", 2).await.unwrap(), 2);
    assert_eq!(users.decrement("counter", 1).await.unwrap(), 1);

    client.subscribe_buffer("users:1").await.unwrap();
    let event = time::timeout(Duration::from_secs(1), events.recv())
        .await
        .unwrap()
        .unwrap();
    assert!(matches!(event, ClientEvent::Buffer(update) if update.key == "users:1"));

    let result: i64 = client
        .call_app("worker", "sum", &json!({"x": 3, "y": 4}))
        .await
        .unwrap();
    assert_eq!(result, 7);

    let outcome: CallOutcome<Value> = client
        .call_app_with_options(
            "worker",
            "sum",
            &json!({"x": 1}),
            Duration::from_secs(1),
            Some("third"),
        )
        .await
        .unwrap();
    assert!(matches!(outcome, CallOutcome::Routed { request_id } if !request_id.is_empty()));

    client.disconnect().await.unwrap();
    server.await.unwrap();
}

#[tokio::test]
async fn authentication_errors_are_typed() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let server = tokio::spawn(async move {
        let (stream, _) = listener.accept().await.unwrap();
        let (reader, mut writer) = stream.into_split();
        let mut reader = BufReader::new(reader);
        let hello = read_message(&mut reader).await;
        write_message(&mut writer, &response(&hello, "ack", json!({}))).await;
        let join = read_message(&mut reader).await;
        write_message(
            &mut writer,
            &response(
                &join,
                "error",
                json!({"code": "auth_failed", "message": "bad token"}),
            ),
        )
        .await;
    });

    let result = Client::builder("latzero://rust-auth", "secure")
        .auth_token("wrong")
        .port(port)
        .connect()
        .await;
    let error = match result {
        Ok(_) => panic!("authentication unexpectedly succeeded"),
        Err(error) => error,
    };
    assert!(matches!(error, Error::Authentication(message) if message == "bad token"));
    server.await.unwrap();
}

#[tokio::test]
async fn incoming_event_and_process_calls_return_results() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let server = tokio::spawn(async move {
        let (mut reader, mut writer) = accept_handshake(
            listener,
            json!({"pool": "alpha", "auth_required": false, "clients": ["worker"]}),
        )
        .await;
        let register = read_message(&mut reader).await;
        assert_eq!(register.kind, "register_process");
        write_message(
            &mut writer,
            &response(
                &register,
                "ack",
                json!({
                    "process_id": "worker:add",
                    "group_id": "g1",
                    "worker_kind": "thread",
                    "min_workers": 1,
                    "max_workers": 4
                }),
            ),
        )
        .await;

        for (request_id, event, expected) in [
            ("event-call", "add", json!(99)),
            ("process-call", "worker:add", json!(7)),
        ] {
            write_message(
                &mut writer,
                &Message {
                    kind: "call_app".to_owned(),
                    request_id: Some(request_id.to_owned()),
                    client_id: Some("caller".to_owned()),
                    pool: Some("alpha".to_owned()),
                    payload: json!({"event": event, "data": {"x": 3, "y": 4}}),
                },
            )
            .await;
            loop {
                let result = read_message(&mut reader).await;
                if result.kind == "worker_metrics" {
                    write_message(
                        &mut writer,
                        &response(&result, "ack", json!({"received": 1})),
                    )
                    .await;
                    continue;
                }
                assert_eq!(result.kind, "app_result");
                assert_eq!(result.request_id.as_deref(), Some(request_id));
                assert_eq!(result.payload["value"], expected);
                break;
            }
        }

        let leave = read_message(&mut reader).await;
        assert_eq!(leave.kind, "leave_pool");
        write_message(
            &mut writer,
            &response(&leave, "ack", json!({"left_pool": true})),
        )
        .await;
    });

    let client = Client::builder("latzero://worker", "alpha")
        .port(port)
        .connect()
        .await
        .unwrap();
    client
        .on_event("add", |_| async { Ok::<_, String>(99) })
        .await;
    client
        .register_process(
            "add",
            ProcessOptions {
                max_workers: 4,
                worker_kind: WorkerKind::Thread,
                ..ProcessOptions::default()
            },
            |data| async move {
                let x = data["x"].as_i64().unwrap();
                let y = data["y"].as_i64().unwrap();
                Ok::<_, String>(x + y)
            },
        )
        .await
        .unwrap();
    time::sleep(Duration::from_millis(100)).await;
    client.disconnect().await.unwrap();
    server.await.unwrap();
}

#[tokio::test]
async fn dropping_last_client_handle_closes_the_socket() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let server = tokio::spawn(async move {
        let (mut reader, _writer) = accept_handshake(listener, json!({})).await;
        let mut line = String::new();
        let read = time::timeout(Duration::from_secs(1), reader.read_line(&mut line))
            .await
            .expect("socket remained open after Client was dropped")
            .unwrap();
        assert_eq!(read, 0);
    });

    let client = Client::builder("latzero://drop-test", "alpha")
        .port(port)
        .connect()
        .await
        .unwrap();
    drop(client);
    server.await.unwrap();
}