feat/parsec: add related_info to Observation::Genesis

- Add a new `genesis_info` parameter to `Parsec::from_genesis` for specifying the related_info on the genesis event.
- Some dot files had to be modified/regenerated because the hash of `Observation::Genesis` changed.
- A bogus clippy lint silenced by slightly reshuffling the code (clippy issue: rust-lang/rust-clippy#4133)

examples/basic.rs

@@ -107,7 +107,12 @@ impl Peer {
     fn from_genesis(our_id: PeerId, genesis_group: &BTreeSet<PeerId>) -> Self {
         Self {
             id: our_id.clone(),
-            parsec: Parsec::from_genesis(our_id, genesis_group, ConsensusMode::Supermajority),
+            parsec: Parsec::from_genesis(
+                our_id,
+                genesis_group,
+                vec![],
+                ConsensusMode::Supermajority,
+            ),
             observations: vec![],
             blocks: vec![],
         }

input_graphs/benches/minimal.dot

@@ -914,7 +914,7 @@ digraph GossipGraph {
 
 /// ===== meta-elections =====
 /// consensus_history:
-/// a137c1b54c5895b13a1e204869f650636920286bd5b903e0576a9a15a2f58c2c
+/// d98f8abc4ba966aadc391bb857a6879a122602074766f19fadf22ce59dd0410e
 /// c93ff2cda7e9dd6a49b12c4fccdbaa0fe1b25b1e92421f288b06bfe53122be0f
 
 /// interesting_events: {

input_graphs/dev_utils_record_tests_smoke_other_peer_names/annie.dot

@@ -5,6 +5,7 @@
 ///   Carol: PeerState(VOTE|SEND|RECV)
 ///   Claire: PeerState(VOTE|SEND|RECV)
 /// }
+/// consensus_mode: Supermajority
 digraph GossipGraph {
   splines=false
   rankdir=BT
@@ -1163,7 +1164,7 @@ digraph GossipGraph {
 
 /// ===== meta-elections =====
 /// consensus_history:
-/// ece3eaf86a7f7396aed2e4bdd0c67cf7b67df5aabbd5eced04924b154d0f3841
+/// 5d1bc22c2cce50873bffc1ba00ecbecce52085dc3bd15e8b43f5167bf72962cd
 
 /// interesting_events: {
 ///   Annie -> ["An_19"]
@@ -1174,10 +1175,6 @@ digraph GossipGraph {
 /// all_voters: {Annie, B, Carol, Claire}
 /// unconsensused_events: {"An_13", "B_9", "Ca_6", "Cl_10"}
 /// meta_events: {
-///   An_13 -> {
-///     observees: {}
-///     interesting_content: []
-///   }
 ///   An_14 -> {
 ///     observees: {}
 ///     interesting_content: []
@@ -1353,10 +1350,6 @@ digraph GossipGraph {
 ///     observees: {}
 ///     interesting_content: []
 ///   }
-///   B_9 -> {
-///     observees: {}
-///     interesting_content: []
-///   }
 ///   B_10 -> {
 ///     observees: {}
 ///     interesting_content: []
@@ -1467,10 +1460,6 @@ digraph GossipGraph {
 ///       Cl: 0/0   t   t   t   t
 ///     }
 ///   }
-///   Ca_6 -> {
-///     observees: {}
-///     interesting_content: []
-///   }
 ///   Ca_7 -> {
 ///     observees: {}
 ///     interesting_content: []
@@ -1620,10 +1609,6 @@ digraph GossipGraph {
 ///     observees: {}
 ///     interesting_content: []
 ///   }
-///   Cl_10 -> {
-///     observees: {}
-///     interesting_content: []
-///   }
 ///   Cl_11 -> {
 ///     observees: {}
 ///     interesting_content: []

input_graphs/functional_tests_unpolled_observations/alice.dot

@@ -827,7 +827,7 @@ digraph GossipGraph {
 
 /// ===== meta-elections =====
 /// consensus_history:
-/// a137c1b54c5895b13a1e204869f650636920286bd5b903e0576a9a15a2f58c2c
+/// d98f8abc4ba966aadc391bb857a6879a122602074766f19fadf22ce59dd0410e
 
 /// interesting_events: {
 ///   Alice -> ["A_14"]

src/dev_utils/dot_parser.rs

@@ -526,7 +526,10 @@ fn parse_invalid() -> Parser<u8, MaliceInput> {
 }
 
 fn parse_genesis() -> Parser<u8, Observation<Transaction, PeerId>> {
-    (seq(b"Genesis(") * parse_peers() - seq(b")")).map(Observation::Genesis)
+    (seq(b"Genesis(") * parse_peers() - seq(b")")).map(|group| Observation::Genesis {
+        group,
+        related_info: vec![],
+    })
 }
 
 fn parse_add() -> Parser<u8, Observation<Transaction, PeerId>> {

src/dev_utils/network.rs

@@ -425,16 +425,16 @@ impl Network {
 
         for block_group in block_groups {
             for block in block_group {
-                if let ParsecObservation::Genesis(ref g) = *block.payload() {
-                    valid_voters = g.clone();
+                if let ParsecObservation::Genesis { ref group, .. } = *block.payload() {
+                    valid_voters = group.clone();
                 }
 
                 self.check_block_signatories(block, &valid_voters)?;
             }
 
             for block in block_group {
                 match *block.payload() {
-                    ParsecObservation::Genesis(_) => (),
+                    ParsecObservation::Genesis { .. } => (),
                     ParsecObservation::Add { ref peer_id, .. } => {
                         let _ = valid_voters.insert(peer_id.clone());
                     }

src/dev_utils/peer.rs

@@ -248,6 +248,7 @@ impl Peer {
         Self::new(WrappedParsec::Good(Parsec::from_genesis(
             id,
             genesis_group,
+            vec![],
             consensus_mode,
         )))
     }

src/dev_utils/record.rs

@@ -41,8 +41,12 @@ impl Record {
     }
 
     pub fn play(self) -> Parsec<Transaction, PeerId> {
-        let mut parsec =
-            Parsec::from_genesis(self.our_id, &self.genesis_group, self.consensus_mode);
+        let mut parsec = Parsec::from_genesis(
+            self.our_id,
+            &self.genesis_group,
+            vec![],
+            self.consensus_mode,
+        );
 
         for action in self.actions {
             action.run(&mut parsec)
@@ -213,8 +217,8 @@ fn extract_genesis_group<'a>(
         .and_then(|key| observations.get(key))
         .map(|info| &info.observation)
         .and_then(|observation| {
-            if let Observation::Genesis(ref genesis_group) = *observation {
-                Some(genesis_group)
+            if let Observation::Genesis { ref group, .. } = *observation {
+                Some(group)
             } else {
                 None
             }

src/dump_graph.rs

@@ -979,7 +979,7 @@ mod detail {
             short_peer_ids: &PeerIndexMap<String>,
         ) -> Self {
             let value = match observation {
-                Observation::Genesis(group) => format!(
+                Observation::Genesis { group, .. } => format!(
                     "Genesis({:?})",
                     group.iter().map(sanitise_peer_id).collect::<BTreeSet<_>>()
                 ),

src/functional_tests.rs

@@ -161,7 +161,13 @@ fn from_genesis() {
     assert_eq!(*parsec.event_creator_id(&genesis_observation), our_id);
     match parsec.event_payload(&genesis_observation) {
         Some(payload) => {
-            assert_eq!(*payload, Observation::Genesis(peers));
+            assert_eq!(
+                *payload,
+                Observation::Genesis {
+                    group: peers,
+                    related_info: vec![]
+                }
+            );
         }
         None => panic!("Expected observation, but event carried no vote"),
     }
@@ -341,6 +347,7 @@ fn unpolled_observations() {
         peer_id: PeerId::new("Eric"),
         related_info: vec![],
     };
+
     assert_eq!(alice.our_unpolled_observations().count(), 1);
     assert_eq!(*unwrap!(alice.our_unpolled_observations().next()), add_eric);
 
@@ -389,7 +396,7 @@ fn our_unpolled_observations_with_consensus_mode_single() {
     let mut alice = Record::from(parse_test_dot_file("alice.dot")).play();
 
     let block = unwrap!(alice.poll());
-    if let Observation::Genesis(_) = block.payload() {
+    if let Observation::Genesis { .. } = block.payload() {
     } else {
         panic!();
     }
@@ -587,9 +594,13 @@ mod handle_malice {
         ));
         let d_1_index = dave_contents.add_event(d_1);
 
-        let d_2 = unwrap!(
-            dave_contents.new_event_from_observation(d_1_index, Observation::Genesis(genesis),)
-        );
+        let d_2 = unwrap!(dave_contents.new_event_from_observation(
+            d_1_index,
+            Observation::Genesis {
+                group: genesis,
+                related_info: vec![]
+            }
+        ));
         let d_2_hash = *d_2.hash();
         let _ = dave_contents.add_event(d_2);
 
@@ -642,9 +653,13 @@ mod handle_malice {
         let e_0 = Event::new_initial(eric_contents.event_context());
         let e_0_index = eric_contents.add_event(e_0);
 
-        let e_1 = unwrap!(
-            eric_contents.new_event_from_observation(e_0_index, Observation::Genesis(genesis),)
-        );
+        let e_1 = unwrap!(eric_contents.new_event_from_observation(
+            e_0_index,
+            Observation::Genesis {
+                group: genesis,
+                related_info: vec![]
+            },
+        ));
         let e_1_hash = *e_1.hash();
         let _ = eric_contents.add_event(e_1);
 
@@ -703,7 +718,7 @@ mod handle_malice {
         // Pop Alice's last event, which is her genesis vote.
         let (_, genesis_event) = unwrap!(alice.remove_last_event());
         match unwrap!(alice.event_payload(&genesis_event)) {
-            Observation::Genesis(_) => (),
+            Observation::Genesis { .. } => (),
             _ => panic!("This should be Alice's genesis vote."),
         }
 
@@ -735,7 +750,10 @@ mod handle_malice {
             bob.our_pub_id().clone(),
             PeerId::new("Derp")
         ];
-        unwrap!(alice.vote_for(Observation::Genesis(invalid_genesis)));
+        unwrap!(alice.vote_for(Observation::Genesis {
+            group: invalid_genesis,
+            related_info: vec![]
+        }));
 
         // Create request from Alice to Carol.
         let request = unwrap!(alice.create_gossip(carol.our_pub_id()));

src/observation.rs

@@ -27,7 +27,12 @@ use std::{
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub enum Observation<T: NetworkEvent, P: PublicId> {
     /// Genesis group
-    Genesis(BTreeSet<P>),
+    Genesis {
+        /// Members of the genesis group.
+        group: BTreeSet<P>,
+        /// Extra arbitrary information for use by the client.
+        related_info: Vec<u8>,
+    },
     /// Vote to add the indicated peer to the network.
     Add {
         /// Public id of the peer to be added
@@ -67,7 +72,7 @@ impl<T: NetworkEvent, P: PublicId> Observation<T, P> {
 impl<T: NetworkEvent, P: PublicId> Debug for Observation<T, P> {
     fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
         match self {
-            Observation::Genesis(group) => write!(formatter, "Genesis({:?})", group),
+            Observation::Genesis { group, .. } => write!(formatter, "Genesis({:?})", group),
             Observation::Add { peer_id, .. } => write!(formatter, "Add({:?})", peer_id),
             Observation::Remove { peer_id, .. } => write!(formatter, "Remove({:?})", peer_id),
             Observation::Accusation { offender, malice } => {

src/parsec.rs

@@ -116,11 +116,13 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
     /// * `our_id` is the value that will identify the owning peer in the network.
     /// * `genesis_group` is the set of public IDs of the peers that are present at the network
     /// startup.
+    /// * `genesis_info` extra arbitrary opaque data attached to the genesis event.
     /// * `consensus_mode` determines how many votes are needed for an observation to become a
     /// candidate for consensus. For more details, see [ConsensusMode](enum.ConsensusMode.html)
     pub fn from_genesis(
         our_id: S,
         genesis_group: &BTreeSet<S::PublicId>,
+        genesis_info: Vec<u8>,
         consensus_mode: ConsensusMode,
     ) -> Self {
         if !genesis_group.contains(our_id.public_id()) {
@@ -147,7 +149,10 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
         parsec.add_initial_event();
 
         // Add event carrying genesis observation.
-        let genesis_observation = Observation::Genesis(genesis_group.clone());
+        let genesis_observation = Observation::Genesis {
+            group: genesis_group.clone(),
+            related_info: genesis_info,
+        };
         let event = parsec.our_last_event_index().and_then(|self_parent| {
             parsec.new_event_from_observation(self_parent, genesis_observation)
         });
@@ -821,7 +826,7 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
 
                 self.handle_remove_peer(event_index, offender)
             }
-            Some(Observation::Genesis(_)) | Some(Observation::OpaquePayload(_)) => None,
+            Some(Observation::Genesis { .. }) | Some(Observation::OpaquePayload(_)) => None,
             None => {
                 log_or_panic!("Failed to get observation from hash.");
                 None
@@ -1589,7 +1594,7 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
 
     // Detect if the event carries an `Observation::Genesis` that doesn't match what we'd expect.
     fn detect_incorrect_genesis(&mut self, event: &Event<S::PublicId>) -> Result<()> {
-        if let Some(Observation::Genesis(ref group)) = self.event_payload(event) {
+        if let Some(Observation::Genesis { ref group, .. }) = self.event_payload(event) {
             if self.genesis_group() == group.iter().collect() {
                 return Ok(());
             }
@@ -1667,7 +1672,7 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
                 return;
             };
 
-            let genesis_group = if let Observation::Genesis(ref group) = *payload {
+            let genesis_group = if let Observation::Genesis { ref group, .. } = *payload {
                 group
             } else {
                 return;
@@ -1699,7 +1704,7 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
             return;
         }
 
-        if let Some(&Observation::Genesis(_)) = self.event_payload(event) {
+        if let Some(&Observation::Genesis { .. }) = self.event_payload(event) {
             return;
         }
 
@@ -1966,9 +1971,9 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
         };
 
         let starting_index = self.peer_list.accomplice_event_checkpoint_by(creator);
-        for (_, malice) in
-            self.detect_accomplice_for_our_accusations(event_index, starting_index)?
-        {
+        let accusations =
+            self.detect_accomplice_for_our_accusations(event_index, starting_index)?;
+        for (_, malice) in accusations {
             self.accuse(creator, Malice::Accomplice(event_hash, Box::new(malice)));
         }
 
@@ -2026,8 +2031,8 @@ impl<T: NetworkEvent, S: SecretId> Parsec<T, S> {
             .iter()
             .filter_map(|event| {
                 let observation = self.event_payload(&*event)?;
-                if let Observation::Genesis(ref gen) = *observation {
-                    Some(gen.iter().collect())
+                if let Observation::Genesis { ref group, .. } = *observation {
+                    Some(group.iter().collect())
                 } else {
                     None
                 }
@@ -2157,7 +2162,12 @@ impl<T: NetworkEvent, S: SecretId> TestParsec<T, S> {
         genesis_group: &BTreeSet<S::PublicId>,
         consensus_mode: ConsensusMode,
     ) -> Self {
-        TestParsec(Parsec::from_genesis(our_id, genesis_group, consensus_mode))
+        TestParsec(Parsec::from_genesis(
+            our_id,
+            genesis_group,
+            vec![],
+            consensus_mode,
+        ))
     }
 
     pub fn from_existing(