use super::*;
use std::sync::RwLock;
pub(super) struct CommittedView {
workspace: Arc<arachne_security::Workspace>,
endpoint: [u8; 32],
}
#[derive(Clone, Default)]
pub(super) struct Published {
view: Arc<RwLock<Option<Arc<CommittedView>>>>,
profiles: membership::Profiles,
signal: Option<Arc<work_signal::WorkSignal>>,
}
impl Published {
pub(super) fn new(signal: Option<Arc<work_signal::WorkSignal>>) -> Self {
Self {
signal,
..Self::default()
}
}
pub(super) fn profiles(&self) -> membership::Profiles {
Arc::clone(&self.profiles)
}
pub(super) fn publish(&self, workspace: Arc<arachne_security::Workspace>, endpoint: [u8; 32]) {
*self.view.write().unwrap_or_else(|error| error.into_inner()) =
Some(Arc::new(CommittedView {
workspace,
endpoint,
}));
}
pub(super) fn clear(&self) {
*self.view.write().unwrap_or_else(|error| error.into_inner()) = None;
*self.profiles.lock().unwrap_or_else(|error| error.into_inner()) = Default::default();
}
fn current(&self) -> Option<Arc<CommittedView>> {
self.view
.read()
.unwrap_or_else(|error| error.into_inner())
.clone()
}
pub(super) fn responder(&self) -> arachne_node::InquiryResponder {
let published = self.clone();
Arc::new(move |peer, payload| {
let view = published.current()?;
if payload.starts_with(b"DFMQ") {
return published.answer_membership_query(&view, peer, payload);
}
if payload.starts_with(membership::PROFILE_QUERY_PREFIX) {
let set = membership::lock_profiles(&published.profiles);
return Some(membership::profile_page_reply(
Some(&view.workspace),
&set,
peer,
payload,
));
}
view.answer(peer, payload)
})
}
fn answer_membership_query(
&self,
view: &CommittedView,
peer: [u8; 32],
payload: &[u8],
) -> Option<Vec<u8>> {
let mut set = membership::lock_profiles(&self.profiles);
let reply = membership::answer_query(
Some(&view.workspace),
&mut set,
peer,
payload,
membership::MAX_PROFILE_SET_BYTES,
);
let bytes = membership::encode_reply(&reply).ok()?;
let current = reply["state"] != "membership_denied"
&& view.workspace.member_id_for_endpoint(peer).is_ok();
set.note_answered(current.then_some(peer));
drop(set);
if let Some(signal) = &self.signal {
signal.raise();
}
Some(bytes)
}
}
const UNAVAILABLE: &[u8] = b"{\"state\":\"admission_unavailable\",\"reason\":\"unavailable\"}";
impl CommittedView {
fn answer(&self, peer: [u8; 32], payload: &[u8]) -> Option<Vec<u8>> {
if payload.starts_with(INVITATION_CHECKPOINT_REQUEST) {
let proof = &payload[INVITATION_CHECKPOINT_REQUEST.len()..];
return Some(
self.workspace
.checkpoint_for_invitation(peer, self.endpoint, proof)
.unwrap_or_default(),
);
}
if payload.starts_with(ADMISSION_HISTORY_PAGE_REQUEST) {
let page = parse_admission_history_page_packet(payload).ok().and_then(
|(request, checkpoint, offset)| {
admission_reply_page(&self.workspace, peer, request, Some(checkpoint), offset)
.ok()
},
);
return Some(page.unwrap_or_else(|| UNAVAILABLE.to_vec()));
}
if payload.starts_with(b"DFMS") {
return Some(membership::range_reply(
Some(&self.workspace),
peer,
payload,
));
}
if payload.starts_with(b"DFJA") {
let (request, checkpoint, _) = admission_packet(payload).ok()?;
self.workspace.retained_admission(peer, request).ok()??;
return admission_reply_page(&self.workspace, peer, request, checkpoint, 0).ok();
}
None
}
}
#[test]
fn a_membership_query_answer_is_the_host_answer() {
let (owner, members, endpoints) = membership::admit_members(21, "Equal member", 3);
let owner = Arc::new(owner);
let mut host = membership::bare_test_session(owner.clone());
let mut view = membership::bare_test_session(owner.clone());
view.committed.publish(owner.clone(), view.node.id());
let responder = view.committed.responder();
let profiles: Vec<Vec<u8>> = members
.iter()
.map(|member| member.sign_member_profile().unwrap())
.collect();
let basis = membership::StateBasis::new(owner.epoch(), owner.epoch_fingerprint(), [0; 32]);
let query = |digest: [u8; 32], carried: [&[u8]; 2]| {
membership::wire::encode_query(&membership::wire::Query {
workspace: owner.id(),
basis,
profiles_digest: digest,
profiles: carried,
})
.unwrap()
};
let mut asks = vec![
(endpoints[0], query([0; 32], [&profiles[0], &[]])),
(endpoints[1], query([0; 32], [&profiles[1], &profiles[0]])),
(endpoints[2], query([0; 32], [&profiles[2], &[]])),
(endpoints[0], query([0; 32], [&[], &[]])),
([250; 32], query([0; 32], [&[], &[]])),
];
let mut probe = membership::bare_test_session(owner.clone());
for (peer, bytes) in &asks[..3] {
membership::reply_with_profiles(&mut probe, *peer, bytes);
}
let settled = membership::reply_with_profiles(&mut probe, endpoints[1], &asks[3].1);
let digest: [u8; 32] = serde_json::from_value(settled["profiles_digest"].clone()).unwrap();
asks.push((endpoints[1], query(digest, [&[], &[]])));
for (peer, bytes) in asks {
let expected =
membership::encode_reply(&membership::reply_with_profiles(&mut host, peer, &bytes))
.unwrap();
let answered = responder(peer, &bytes).expect("a membership query is an inquiry");
assert_eq!(
answered,
expected,
"reply differs for peer {:?}",
&peer[..2]
);
}
assert_eq!(
membership::roster(&mut view, &[]).unwrap(),
membership::roster(&mut host, &[]).unwrap(),
"the view retained different names than the host"
);
let page = membership::wire::encode_profile_query(&membership::wire::ProfileQuery {
workspace: owner.id(),
after: None,
})
.unwrap();
let host_page = membership::profile_page_reply(
host.workspace.as_deref(),
&membership::lock_profiles(&host.profiles),
endpoints[0],
&page,
);
assert_eq!(responder(endpoints[0], &page), Some(host_page));
}