From d69e712dba6c7fa7c5b54a1b876e8b258edb772d Mon Sep 17 00:00:00 2001 From: Devin R Date: Tue, 21 Jul 2020 00:11:03 -0400 Subject: [PATCH] Working at get_auth_chain_diff --- src/lib.rs | 25 +++++++++++++-- src/state_store.rs | 2 +- tests/init.rs | 80 ++++++++++++++++++++++++++++++++++------------ 3 files changed, 82 insertions(+), 25 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 36053264..a029c2c1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -81,7 +81,13 @@ impl StateResolution { let mut auth_diff = self.get_auth_chain_diff(room_id, &state_sets, &mut event_map, store)?; - println!("{:?}", auth_diff); + println!( + "AUTH DIFF {:?}", + auth_diff + .iter() + .map(ToString::to_string) + .collect::>() + ); // add the auth_diff to conflicting now we have a full set of conflicting events auth_diff.extend(conflicting.values().cloned().flatten()); @@ -191,6 +197,8 @@ impl StateResolution { &mut self, state_sets: &[StateMap], ) -> (StateMap, StateMap>) { + use itertools::Itertools; + let mut unconflicted_state = StateMap::new(); let mut conflicted_state = StateMap::new(); @@ -198,6 +206,7 @@ impl StateResolution { let mut event_ids = state_sets .iter() .flat_map(|map| map.get(key).cloned()) + .dedup() .collect::>(); if event_ids.len() == 1 { @@ -221,12 +230,22 @@ impl StateResolution { ) -> Result, String> { use itertools::Itertools; + println!( + "{:?}", + state_sets + .iter() + .flat_map(|map| map.values()) + .map(ToString::to_string) + .dedup() + .collect::>() + ); + tracing::debug!("calculating auth chain difference"); store.auth_chain_diff( room_id, - &state_sets + state_sets .iter() - .flat_map(|map| map.values()) + .map(|map| map.values().cloned().collect()) .dedup() .collect::>(), ) diff --git a/src/state_store.rs b/src/state_store.rs index 757444ab..7881883a 100644 --- a/src/state_store.rs +++ b/src/state_store.rs @@ -20,6 +20,6 @@ pub trait StateStore { fn auth_chain_diff( &self, room_id: &RoomId, - event_id: &[&EventId], + event_id: Vec>, ) -> Result, String>; } diff --git a/tests/init.rs b/tests/init.rs index 7ab1d278..6fc0c57c 100644 --- a/tests/init.rs +++ b/tests/init.rs @@ -1,6 +1,7 @@ #![allow(unused)] use std::{ + cell::RefCell, collections::{BTreeMap, BTreeSet}, convert::TryFrom, time::{Duration, SystemTime, UNIX_EPOCH}, @@ -28,20 +29,20 @@ fn id(id: &str) -> EventId { } fn alice() -> UserId { - UserId::try_from("@alice:example.com").unwrap() + UserId::try_from("@alice:foo").unwrap() } fn bobo() -> UserId { - UserId::try_from("@bobo:example.com").unwrap() + UserId::try_from("@bobo:foo").unwrap() } fn devin() -> UserId { - UserId::try_from("@devin:example.com").unwrap() + UserId::try_from("@devin:foo").unwrap() } fn zera() -> UserId { - UserId::try_from("@zera:example.com").unwrap() + UserId::try_from("@zera:foo").unwrap() } fn room_id() -> RoomId { - RoomId::try_from("!test:example.com").unwrap() + RoomId::try_from("!test:foo").unwrap() } fn member_content_ban() -> JsonValue { @@ -297,26 +298,41 @@ impl StateStore for TestStore { fn auth_chain_diff( &self, room_id: &RoomId, - event_ids: &[&EventId], + event_ids: Vec>, ) -> Result, String> { - let mut chains = BTreeSet::new(); - let mut list = vec![]; - for id in event_ids { + use itertools::Itertools; + + println!( + "EVENTS FOR AUTH {:?}", + event_ids + .iter() + .map(|v| v.iter().map(ToString::to_string).collect::>()) + .collect::>() + ); + + let mut chains = vec![]; + for ids in event_ids { let chain = self - .auth_event_ids(room_id, &[(*id).clone()])? + .auth_event_ids(room_id, &ids)? .into_iter() .collect::>(); - list.push(chain.clone()); - chains.insert(chain); + chains.push(chain); } - if let Some(chain) = list.first() { - let set = maplit::btreeset!(chain.clone()); - let common = set.intersection(&chains).flatten().collect::>(); + + if let Some(chain) = chains.first() { + let rest = chains.iter().skip(1).flatten().cloned().collect(); + let common = chain.intersection(&rest).collect::>(); + println!( + "COMMON {:?}", + common.iter().map(ToString::to_string).collect::>() + ); Ok(chains .iter() .flatten() - .filter(|id| common.contains(&id)) + .filter(|id| !common.contains(&id)) .cloned() + .collect::>() + .into_iter() .collect()) } else { Ok(vec![]) @@ -325,6 +341,8 @@ impl StateStore for TestStore { } fn do_check(events: &[StateEvent], edges: Vec>, expected_state_ids: Vec) { + use itertools::Itertools; + let mut resolver = StateResolution::default(); // TODO what do we fill this with, everything ?? let store = TestStore( @@ -340,12 +358,19 @@ fn do_check(events: &[StateEvent], edges: Vec>, expected_state_ids: // this is the same as in `resolve` event_id -> StateEvent let mut fake_event_map = BTreeMap::new(); + // create the DB of events that led up to this point // TODO maybe clean up some of these clones it is just tests but... for ev in INITIAL_EVENTS().values().chain(events) { graph.insert(ev.event_id().unwrap().clone(), vec![]); fake_event_map.insert(ev.event_id().unwrap().clone(), ev.clone()); } + for pair in INITIAL_EDGES().windows(2) { + if let &[a, b] = &pair { + graph.entry(a.clone()).or_insert(vec![]).push(b.clone()); + } + } + for edge_list in edges { for pair in edge_list.windows(2) { if let &[a, b] = &pair { @@ -392,8 +417,12 @@ fn do_check(events: &[StateEvent], edges: Vec>, expected_state_ids: // .collect::>() // ); - let resolved = - resolver.resolve(&room_id(), &RoomVersionId::version_1(), &state_sets, &store); + let resolved = resolver.resolve( + &room_id(), + &RoomVersionId::version_1(), + &state_sets, + &TestStore(event_map.clone()), + ); match resolved { Ok(ResolutionResult::Resolved(state)) => state, _ => panic!("resolution for {} failed", node), @@ -428,6 +457,7 @@ fn do_check(events: &[StateEvent], edges: Vec>, expected_state_ids: // TODO The event is just remade, adding the auth_events and prev_events here // UPDATE: the `to_pdu_event` was split into `init` and the fn below, could be better let e = fake_event; + let ev_id = e.event_id().unwrap(); let event = to_pdu_event( &e.event_id().unwrap().to_string(), e.sender().clone(), @@ -437,6 +467,9 @@ fn do_check(events: &[StateEvent], edges: Vec>, expected_state_ids: &auth_events, prev_events, ); + // we have to update our store, an actual user of this lib would do this + // with the result of the resolution> + // *store.0.borrow_mut().get_mut(ev_id).unwrap() = event.clone(); state_at_event.insert(node, state_after); event_map.insert(event_id.clone(), event); @@ -462,13 +495,18 @@ fn do_check(events: &[StateEvent], edges: Vec>, expected_state_ids: .get(&EventId::try_from("$START:foo").unwrap()) .unwrap(); - println!("{:?}", start_state); - let end_state = state_at_event .get(&EventId::try_from("$END:foo").unwrap()) .unwrap() .iter() - .filter(|(k, v)| expected_state.contains_key(k) || start_state.get(k) != Some(*v)) + .filter(|(k, v)| { + println!( + "{:?} == {:?}", + start_state.get(k).map(ToString::to_string), + Some(v.to_string()) + ); + expected_state.contains_key(k) || start_state.get(k) != Some(*v) + }) .map(|(k, v)| (k.clone(), v.clone())) .collect::>();