#![cfg(test)]
use std::sync::Arc as StdArc;
use std::time::Duration;
use identity::{Ed25519Keypair, IdentityProvider, InMemoryProvider};
use muniment::MemoryBackend;
use murm_replication::{MunimentStore, SyncedSpace};
use p2panda_core::{Operation, Topic};
use p2panda_net::sync::SyncHandle;
use p2panda_net::{Endpoint, Gossip, LogSync};
use p2panda_sync::protocols::TopicLogSyncEvent;
use transport::P2pandaTransport;
use super::roster::MootRoster;
use super::store::MootStore;
use super::wire::{MootEvent, MootExt, MootLogId, verify};
const MOOT: [u8; 32] = [0x6e; 32];
type MootHandle = SyncHandle<Operation<MootExt>, TopicLogSyncEvent<MootExt>>;
struct MootSession {
store: MootStore,
handle: MootHandle,
space: SyncedSpace,
_log_sync: LogSync<MunimentStore<MemoryBackend, MootExt>, MootLogId, MootExt>,
}
impl MootSession {
async fn join(endpoint: Endpoint, gossip: Gossip, store: MootStore) -> Self {
let log_sync = LogSync::builder(store.sync_store(), endpoint, gossip)
.spawn()
.await
.expect("logsync spawn");
let handle = log_sync
.stream(Topic::from(MOOT), true)
.await
.expect("logsync stream");
let sub = handle.subscribe().await.expect("logsync subscribe");
let accept_store = store.clone();
let space = SyncedSpace::drive(sub, move |op: Operation<MootExt>| {
let store = accept_store.clone();
async move {
verify(&op)
&& op.header.extensions.moot_id == MOOT
&& matches!(store.insert(&op).await, Ok(true))
}
});
Self {
store,
handle,
space,
_log_sync: log_sync,
}
}
async fn author(&self, keypair: &Ed25519Keypair, event: &MootEvent) {
let op = self
.store
.author(keypair, MOOT, event)
.await
.expect("author");
self.handle.publish(op).await.expect("publish");
}
async fn roster(&self) -> MootRoster {
self.store.roster(MOOT).await.expect("roster")
}
fn ops_received(&self) -> u64 {
self.space.sync_status().ops_received
}
}
async fn two_peers() -> (P2pandaTransport, P2pandaTransport) {
let founder_provider = StdArc::new(InMemoryProvider::from_seed([70; 32]));
let friend_provider = StdArc::new(InMemoryProvider::from_seed([71; 32]));
let founder_id = transport::PeerID::from_public_key(founder_provider.master_public_key());
let friend_id = transport::PeerID::from_public_key(friend_provider.master_public_key());
let founder_t = P2pandaTransport::builder(founder_provider.master_keypair())
.gossip()
.bind()
.await
.expect("bind founder");
let friend_t = P2pandaTransport::builder(friend_provider.master_keypair())
.gossip()
.bind()
.await
.expect("bind friend");
let overlay = transport::sync_overlay_topic(MOOT);
founder_t
.add_peer(friend_t.endpoint_addr().await.unwrap())
.await
.unwrap();
founder_t.set_topics(friend_id, &[overlay]).await.unwrap();
friend_t
.add_peer(founder_t.endpoint_addr().await.unwrap())
.await
.unwrap();
friend_t.set_topics(founder_id, &[overlay]).await.unwrap();
(founder_t, friend_t)
}
async fn join(t: &P2pandaTransport) -> MootSession {
let (ep, gossip) = t.sync_parts().expect("sync parts");
let store = MootStore::in_memory();
MootSession::join(ep, gossip, store).await
}
async fn wait_for_roster(space: &MootSession, pred: impl Fn(&MootRoster) -> bool, what: &str) {
let outcome = tokio::time::timeout(Duration::from_secs(30), async {
loop {
if pred(&space.roster().await) {
break;
}
tokio::time::sleep(Duration::from_millis(200)).await;
}
})
.await;
assert!(outcome.is_ok(), "timed out waiting for: {what}");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn declare_join_share_converges_on_both_peers() {
let (founder_t, friend_t) = two_peers().await;
let founder_space = join(&founder_t).await;
let friend_space = join(&friend_t).await;
let founder_kp = InMemoryProvider::from_seed([70; 32])
.derive_keypair(b"moot-author")
.unwrap();
let friend_kp = InMemoryProvider::from_seed([71; 32])
.derive_keypair(b"moot-author")
.unwrap();
founder_space
.author(
&founder_kp,
&MootEvent::Declared {
name: "printing circle".into(),
charter: "we share what we set in type".into(),
at_ms: 10,
},
)
.await;
founder_space
.author(
&founder_kp,
&MootEvent::Joined {
name: "mark".into(),
at_ms: 11,
},
)
.await;
wait_for_roster(
&friend_space,
|r| r.declaration.is_some(),
"friend sees the declaration",
)
.await;
friend_space
.author(
&friend_kp,
&MootEvent::Joined {
name: "alex".into(),
at_ms: 20,
},
)
.await;
friend_space
.author(
&friend_kp,
&MootEvent::Shared {
manifest_id: [0xaa; 32],
schema_id: "eidetic.SearchIndexSpec/v1".into(),
title: "my trail index".into(),
at_ms: 21,
},
)
.await;
for (space, who) in [(&founder_space, "founder"), (&friend_space, "friend")] {
wait_for_roster(
space,
|r| {
r.declaration.as_ref().map(|d| d.name.as_str()) == Some("printing circle")
&& r.members.len() == 2
&& r.fauna.len() == 1
&& r.fauna[0].title == "my trail index"
},
&format!("{who} converges on the full roster"),
)
.await;
}
assert!(founder_space.ops_received() >= 2);
assert!(friend_space.ops_received() >= 2);
assert!(founder_space.space.sync_status().last_activity_ms.is_some());
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn a_late_joiner_catches_up_on_an_existing_moot() {
let (founder_t, friend_t) = two_peers().await;
let founder_kp = InMemoryProvider::from_seed([70; 32])
.derive_keypair(b"moot-author")
.unwrap();
let store = MootStore::in_memory();
store
.author(
&founder_kp,
MOOT,
&MootEvent::Declared {
name: "early circle".into(),
charter: "founded before you arrived".into(),
at_ms: 5,
},
)
.await
.unwrap();
let (ep, gossip) = founder_t.sync_parts().expect("founder sync parts");
let _founder_space = MootSession::join(ep, gossip, store).await;
let friend_space = join(&friend_t).await;
wait_for_roster(
&friend_space,
|r| r.declaration.as_ref().map(|d| d.name.as_str()) == Some("early circle"),
"friend catches up on the founding",
)
.await;
assert!(friend_space.ops_received() >= 1);
}