rostra-client 0.1.3

Integration runtime for Rostra peer-to-peer clients
Documentation
use std::time::Duration;

use iroh::endpoint::{RecvStream, SendStream, presets};
use rostra_client_db::Database;
use rostra_core::event::{Event, EventContentRaw, EventKind, VerifiedEvent, VerifiedEventContent};
use rostra_core::id::{RostraIdSecretKey, ToShort as _};
use rostra_p2p::Connection;
use rostra_p2p::connection::{FeedEventRequest, FeedEventResponse};
use rostra_p2p_api::ROSTRA_P2P_V0_ALPN;

use super::{
    InboundAdmission, MAX_CONCURRENT_INBOUND_RPCS, MAX_INBOUND_CONNECTIONS, ORDINARY_RPC_TIMEOUT,
    RESERVED_ORDINARY_INBOUND_RPCS,
};
use crate::Client;

#[test]
fn client_wide_admission_stays_bounded_and_recovers_after_release() {
    let admission = InboundAdmission::new();

    let connection_permits = (0..MAX_INBOUND_CONNECTIONS)
        .map(|_| {
            admission
                .try_admit_connection()
                .expect("connection within the global budget")
        })
        .collect::<Vec<_>>();
    assert!(
        admission.try_admit_connection().is_err(),
        "an excess connection must be rejected instead of creating a task"
    );

    let shared_rpc_count = MAX_CONCURRENT_INBOUND_RPCS - RESERVED_ORDINARY_INBOUND_RPCS;
    let mut rpc_permits = (0..shared_rpc_count)
        .map(|_| {
            admission
                .try_admit_rpc(true)
                .expect("long wait within the global budget")
        })
        .collect::<Vec<_>>();
    assert!(
        admission.try_admit_rpc(true).is_err(),
        "an excess persistent RPC must be rejected instead of creating a task"
    );

    let ordinary_rpc = admission
        .try_admit_rpc(false)
        .expect("reserved capacity admits ordinary traffic while long polls are saturated");
    drop(ordinary_rpc);

    rpc_permits.pop();
    let replacement_long_poll = admission
        .try_admit_rpc(true)
        .expect("persistent traffic resumes after a long wait releases its permit");
    assert_eq!(admission.shared_rpcs.available_permits(), 0);
    drop(replacement_long_poll);

    drop(connection_permits);
    assert_eq!(
        admission.connections.available_permits(),
        MAX_INBOUND_CONNECTIONS
    );
    assert_eq!(
        admission.shared_rpcs.available_permits(),
        shared_rpc_count - rpc_permits.len()
    );
    assert_eq!(
        admission.reserved_ordinary_rpcs.available_permits(),
        RESERVED_ORDINARY_INBOUND_RPCS
    );
}

async fn request_handler_fixture() -> (
    RostraIdSecretKey,
    std::sync::Arc<Client>,
    iroh::Endpoint,
    iroh::endpoint::Connection,
) {
    let secret = RostraIdSecretKey::from_bytes([73; 32]);
    let lookup = iroh::address_lookup::memory::MemoryLookup::new();
    let server_endpoint = iroh::Endpoint::builder(presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup.clone())
        .bind()
        .await
        .expect("server endpoint");
    let server_id = server_endpoint.id();
    lookup.add_endpoint_info(server_endpoint.addr());
    let server = Client::builder(secret.id())
        .db(Database::new_in_memory(secret.id())
            .await
            .expect("in-memory database"))
        .iroh_endpoint(server_endpoint)
        .start_background_tasks(false)
        .build()
        .await
        .expect("server client");
    let caller_endpoint = iroh::Endpoint::builder(presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup)
        .bind()
        .await
        .expect("caller endpoint");
    let connection = caller_endpoint
        .connect(server_id, ROSTRA_P2P_V0_ALPN)
        .await
        .expect("connect to server");
    (secret, server, caller_endpoint, connection)
}

async fn write_feed_event_header(send: &mut SendStream, request: &FeedEventRequest) {
    let payload = bincode::encode_to_vec(request, rostra_core::bincode::STD_BINCODE_CONFIG)
        .expect("encode request");
    let mut header = vec![0, 1];
    header.extend_from_slice(
        &u32::try_from(payload.len())
            .expect("request length fits u32")
            .to_be_bytes(),
    );
    header.extend_from_slice(&payload);
    send.write_all(&header).await.expect("write request header");
}

async fn read_return_code(recv: &mut RecvStream) -> u8 {
    let mut code = [0];
    recv.read_exact(&mut code).await.expect("read return code");
    code[0]
}

#[tokio::test(flavor = "multi_thread")]
async fn stalled_finite_rpc_times_out_and_connection_recovers() {
    let (secret, _server, caller_endpoint, raw_connection) = request_handler_fixture().await;
    let event = Event::builder_raw_content()
        .author(secret.id())
        .kind(EventKind::NULL)
        .content(&EventContentRaw::new(vec![1]))
        .build()
        .signed_by(secret);
    let (mut send, mut recv) = raw_connection.open_bi().await.expect("open RPC stream");
    write_feed_event_header(&mut send, &FeedEventRequest(event)).await;
    assert_eq!(read_return_code(&mut recv).await, 0);
    Connection::read_message::<1024, FeedEventResponse>(&mut recv)
        .await
        .expect("feed-event readiness response");

    tokio::time::sleep(ORDINARY_RPC_TIMEOUT + Duration::from_millis(50)).await;
    let mut response = [0];
    let closed = recv.read(&mut response).await;
    assert!(
        closed.is_err() || closed.ok() == Some(None),
        "the stalled request body must be canceled after the finite RPC deadline"
    );

    let connection = Connection::from(raw_connection);
    assert_eq!(
        tokio::time::timeout(Duration::from_secs(2), connection.ping(41))
            .await
            .expect("ordinary RPC after timeout")
            .expect("ping response"),
        41
    );
    caller_endpoint.close().await;
}

#[tokio::test(flavor = "multi_thread")]
async fn admitted_long_poll_survives_finite_deadline_and_allows_ordinary_rpc() {
    let (secret, server, caller_endpoint, raw_connection) = request_handler_fixture().await;
    let content = EventContentRaw::new(vec![2]);
    let signed = Event::builder_raw_content()
        .author(secret.id())
        .kind(EventKind::NULL)
        .content(&content)
        .build()
        .signed_by(secret);
    let verified =
        VerifiedEvent::verify_signed(secret.id(), signed).expect("self-signed test event");
    let first = VerifiedEventContent::verify(verified, content).expect("matching test content");
    let first_id = first.event.event_id.to_short();
    server.db().process_event_with_content(&first).await;
    let connection = Connection::from(raw_connection);
    let mut wait = Box::pin(connection.wait_head_update(first_id));

    assert!(
        tokio::time::timeout(ORDINARY_RPC_TIMEOUT + Duration::from_millis(50), &mut wait)
            .await
            .is_err(),
        "the explicit long-poll whitelist must not use the finite RPC deadline"
    );
    assert_eq!(
        connection.ping(42).await.expect("reserved ordinary RPC"),
        42
    );
    drop(wait);
    caller_endpoint.close().await;
}