rostra-client 0.1.3

Integration runtime for Rostra peer-to-peer clients
Documentation
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};

use rostra_core::ShortEventId;
use rostra_core::event::{Event, EventContentRaw, EventKind, VerifiedEvent, VerifiedEventContent};
use rostra_core::id::{RostraIdSecretKey, ToShort as _};
use rostra_p2p::connection::{
    Connection, GetEventRequest, GetEventResponse, MAX_REQUEST_SIZE, RpcId, RpcMessage as _,
    WaitHeadUpdateRequest, WaitHeadUpdateResponse,
};
use rostra_p2p_api::ROSTRA_P2P_V0_ALPN;
use tokio::sync::{RwLock, mpsc, oneshot};

use super::{ActiveFolloweePoll, FolloweePollState, PollFolloweeHeadUpdates, RemoteProgress};

fn build_event(
    id_secret: RostraIdSecretKey,
    content_byte: u8,
    parent_prev: Option<ShortEventId>,
) -> VerifiedEventContent {
    let content = EventContentRaw::new(vec![content_byte]);
    let signed = Event::builder_raw_content()
        .author(id_secret.id())
        .kind(EventKind::NULL)
        .maybe_parent_prev(parent_prev)
        .content(&content)
        .build()
        .signed_by(id_secret);
    let event =
        VerifiedEvent::verify_signed(id_secret.id(), signed).expect("self-signed test event");
    VerifiedEventContent::verify(event, content).expect("matching test content")
}

#[test_log::test(tokio::test(start_paused = true))]
async fn poll_slots_retain_cursor_and_retry_pending_event_after_cancellation() {
    let remote_secret = RostraIdSecretKey::generate();
    let remote_id = remote_secret.id();
    let remote_head = build_event(remote_secret, 1, None).event;
    let remote_head_id = remote_head.event_id.to_short();
    let local_descendant = build_event(remote_secret, 2, Some(remote_head_id));
    let local_descendant_id = local_descendant.event.event_id.to_short();

    let lookup = iroh::address_lookup::memory::MemoryLookup::new();
    let server_endpoint = iroh::Endpoint::builder(iroh::endpoint::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 client_endpoint = iroh::Endpoint::builder(iroh::endpoint::presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup)
        .bind()
        .await
        .expect("client endpoint");
    let (requests_tx, mut requests_rx) = mpsc::channel(4);
    let server = tokio::spawn(async move {
        let incoming = server_endpoint.accept().await.expect("incoming connection");
        let connection = incoming
            .accept()
            .expect("accept incoming")
            .await
            .expect("connection");

        let (mut send, mut recv) = connection.accept_bi().await.expect("first wait stream");
        let (rpc_id, request) = Connection::read_request_raw(&mut recv)
            .await
            .expect("first wait request");
        assert_eq!(rpc_id, RpcId::WAIT_HEAD_UPDATE);
        let requested_head = WaitHeadUpdateRequest::decode_whole::<MAX_REQUEST_SIZE>(&request)
            .expect("decode first wait")
            .0;
        requests_tx
            .send((rpc_id, requested_head))
            .await
            .expect("request receiver");
        Connection::write_success_return_code(&mut send)
            .await
            .expect("first wait success");
        Connection::write_message(&mut send, &WaitHeadUpdateResponse(remote_head_id))
            .await
            .expect("first wait response");

        for _ in 0..2 {
            let (mut send, mut recv) = connection.accept_bi().await.expect("event stream");
            let (rpc_id, request) = Connection::read_request_raw(&mut recv)
                .await
                .expect("event request");
            assert_eq!(rpc_id, RpcId::GET_EVENT);
            let event_id = GetEventRequest::decode_whole::<MAX_REQUEST_SIZE>(&request)
                .expect("decode event request")
                .0;
            requests_tx
                .send((rpc_id, event_id))
                .await
                .expect("request receiver");
            Connection::write_success_return_code(&mut send)
                .await
                .expect("event success");
            Connection::write_message(&mut send, &GetEventResponse(Some(remote_head.into())))
                .await
                .expect("event response");
        }

        let (_send, mut recv) = connection.accept_bi().await.expect("second wait stream");
        let (rpc_id, request) = Connection::read_request_raw(&mut recv)
            .await
            .expect("second wait request");
        assert_eq!(rpc_id, RpcId::WAIT_HEAD_UPDATE);
        let requested_head = WaitHeadUpdateRequest::decode_whole::<MAX_REQUEST_SIZE>(&request)
            .expect("decode second wait")
            .0;
        requests_tx
            .send((rpc_id, requested_head))
            .await
            .expect("request receiver");
        std::future::pending::<()>().await;
    });
    let connection = Connection::from(
        client_endpoint
            .connect(server_id, ROSTRA_P2P_V0_ALPN)
            .await
            .expect("connect to server"),
    );
    let followee_state = Arc::new(RwLock::new(FolloweePollState::default()));
    let persist_attempts = Arc::new(AtomicUsize::new(0));

    let slot_connection = connection.clone();
    let slot_state = followee_state.clone();
    let slot_attempts = persist_attempts.clone();
    let first_slot = tokio::spawn(async move {
        tokio::time::timeout(
            super::POLL_SLOT_TIMEOUT,
            PollFolloweeHeadUpdates::poll_connection_slot(
                &slot_connection,
                remote_id,
                local_descendant_id,
                &slot_state,
                move |_| {
                    slot_attempts.fetch_add(1, Ordering::SeqCst);
                    std::future::pending()
                },
            ),
        )
        .await
    });

    assert_eq!(
        requests_rx.recv().await,
        Some((RpcId::WAIT_HEAD_UPDATE, local_descendant_id))
    );
    assert_eq!(
        requests_rx.recv().await,
        Some((RpcId::GET_EVENT, remote_head_id))
    );
    while persist_attempts.load(Ordering::SeqCst) == 0 {
        tokio::task::yield_now().await;
    }
    tokio::time::advance(super::POLL_SLOT_TIMEOUT).await;
    assert!(first_slot.await.expect("first slot task").is_err());
    {
        let state = followee_state.read().await;
        assert!(matches!(
            state.remote_progress,
            RemoteProgress::Pending(id) if id == remote_head_id
        ));
    }

    let slot_connection = connection.clone();
    let slot_state = followee_state.clone();
    let second_slot = tokio::spawn(async move {
        tokio::time::timeout(
            super::POLL_SLOT_TIMEOUT,
            PollFolloweeHeadUpdates::poll_connection_slot(
                &slot_connection,
                remote_id,
                local_descendant_id,
                &slot_state,
                |_| async { Ok(()) },
            ),
        )
        .await
    });
    for _ in 0..8 {
        tokio::task::yield_now().await;
    }
    tokio::time::advance(super::MISSING_EVENT_RETRY_DELAY).await;
    assert_eq!(
        requests_rx.recv().await,
        Some((RpcId::GET_EVENT, remote_head_id))
    );
    assert_eq!(
        requests_rx.recv().await,
        Some((RpcId::WAIT_HEAD_UPDATE, remote_head_id))
    );
    {
        let state = followee_state.read().await;
        assert!(matches!(
            state.remote_progress,
            RemoteProgress::Persisted(id) if id == remote_head_id
        ));
    }

    second_slot.abort();
    second_slot.await.expect_err("second slot cancelled");
    server.abort();
    server.await.expect_err("server cancelled");
    drop(connection);
    drop(client_endpoint);
}

#[test]
fn coalesced_unfollow_readd_cancels_active_epoch_and_prunes_stale_state() {
    let followee_id = RostraIdSecretKey::generate().id();
    let stale_head = build_event(RostraIdSecretKey::generate(), 9, None)
        .event
        .event_id
        .to_short();
    let old_epoch = build_event(RostraIdSecretKey::generate(), 10, None)
        .event
        .event_id
        .to_short();
    let new_epoch = build_event(RostraIdSecretKey::generate(), 11, None)
        .event
        .event_id
        .to_short();
    let mut desired = HashMap::from([(followee_id, old_epoch)]);
    let mut pending = BTreeMap::new();
    let (cancel, mut cancelled) = oneshot::channel();
    let mut active = HashMap::from([(
        followee_id,
        ActiveFolloweePoll {
            epoch: old_epoch,
            cancel,
        },
    )]);
    let mut states = HashMap::from([(
        followee_id,
        Arc::new(RwLock::new(FolloweePollState {
            remote_progress: RemoteProgress::Pending(stale_head),
            ..FolloweePollState::default()
        })),
    )]);

    PollFolloweeHeadUpdates::reconcile_followee_epochs(
        HashMap::from([(followee_id, new_epoch)]),
        &mut desired,
        &mut pending,
        &mut active,
        &mut states,
    );
    assert_eq!(cancelled.try_recv(), Ok(()));
    assert!(active.is_empty());
    assert_eq!(pending.get(&followee_id), Some(&new_epoch));
    assert!(states.is_empty());

    let readded = states.entry(followee_id).or_default().clone();
    assert_eq!(
        readded.blocking_read().wait_cursor(ShortEventId::ZERO),
        ShortEventId::ZERO
    );
    assert_eq!(states.len(), 1);

    PollFolloweeHeadUpdates::reconcile_followee_epochs(
        HashMap::new(),
        &mut desired,
        &mut pending,
        &mut active,
        &mut states,
    );
    assert!(states.is_empty());
    assert!(pending.is_empty());
}