Improve API of PeerListBuilder

light-client/src/builder/supervisor.rs

@@ -53,8 +53,8 @@ impl SupervisorBuilder<Init> {
         address: net::Address,
         instance: Instance,
     ) -> SupervisorBuilder<HasPrimary> {
-        self.instances = self.instances.primary(peer_id, instance);
-        self.addresses = self.addresses.primary(peer_id, address);
+        self.instances.primary(peer_id, instance);
+        self.addresses.primary(peer_id, address);
 
         self.with_state(HasPrimary)
     }
@@ -68,8 +68,8 @@ impl SupervisorBuilder<HasPrimary> {
         address: net::Address,
         instance: Instance,
     ) -> SupervisorBuilder<Done> {
-        self.instances = self.instances.witness(peer_id, instance);
-        self.addresses = self.addresses.witness(peer_id, address);
+        self.instances.witness(peer_id, instance);
+        self.addresses.witness(peer_id, address);
 
         self.with_state(Done)
     }

light-client/src/peer_list.rs

@@ -193,33 +193,30 @@ impl<T> Default for PeerListBuilder<T> {
 impl<T> PeerListBuilder<T> {
     /// Register the given peer id and instance as the primary.
     /// Overrides the previous primary if it was already set.
-    pub fn primary(mut self, peer_id: PeerId, value: T) -> Self {
+    pub fn primary(&mut self, peer_id: PeerId, value: T) {
         self.primary = Some(peer_id);
         self.values.insert(peer_id, value);
-        self
     }
 
     /// Register the given peer id and value as a witness.
     #[pre(self.primary != Some(peer_id))]
-    pub fn witness(mut self, peer_id: PeerId, value: T) -> Self {
+    pub fn witness(&mut self, peer_id: PeerId, value: T) {
         self.values.insert(peer_id, value);
         self.witnesses.insert(peer_id);
-        self
     }
 
     /// Register the given peer id and value as a full node.
     #[pre(self.primary != Some(peer_id))]
-    pub fn full_node(mut self, peer_id: PeerId, value: T) -> Self {
+    pub fn full_node(&mut self, peer_id: PeerId, value: T) {
         self.values.insert(peer_id, value);
         self.full_nodes.insert(peer_id);
-        self
     }
+
     /// Register the given peer id and value as a faulty node.
     #[pre(self.primary != Some(peer_id))]
-    pub fn faulty_node(mut self, peer_id: PeerId, value: T) -> Self {
+    pub fn faulty_node(&mut self, peer_id: PeerId, value: T) {
         self.values.insert(peer_id, value);
         self.faulty_nodes.insert(peer_id);
-        self
     }
 
     /// Builds the `PeerList`.
@@ -266,12 +263,11 @@ mod tests {
         "da918eef62d986812b4e6271de78db4ec52594eb".parse().unwrap()
     }
     fn dummy_peer_list() -> PeerList<u32> {
-        let builder = PeerList::builder();
-        builder
-            .primary(a(), 1_u32)
-            .witness(b(), 2_u32)
-            .full_node(c(), 3_u32)
-            .build()
+        let mut builder = PeerList::builder();
+        builder.primary(a(), 1_u32);
+        builder.witness(b(), 2_u32);
+        builder.full_node(c(), 3_u32);
+        builder.build()
     }
 
     #[test]
@@ -289,8 +285,10 @@ mod tests {
     #[test]
     #[should_panic(expected = "Pre-condition of build violated")]
     fn builder_fails_if_no_primary() {
-        let builder = PeerList::builder();
-        let _ = builder.witness(b(), 2_u32).full_node(c(), 3_u32).build();
+        let mut builder = PeerList::builder();
+        builder.witness(b(), 2_u32);
+        builder.full_node(c(), 3_u32);
+        let _ = builder.build();
         unreachable!();
     }
 

light-client/tests/integration.rs

@@ -93,10 +93,12 @@ fn sync() {
     let primary_instance = make_instance(primary, options, primary_io);
     let witness_instance = make_instance(witness, options, witness_io);
 
-    let peer_list = PeerList::builder()
-        .primary(primary, primary_instance)
-        .witness(witness, witness_instance)
-        .build();
+    let peer_list = {
+        let mut builder = PeerList::builder();
+        builder.primary(primary, primary_instance);
+        builder.witness(witness, witness_instance);
+        builder.build()
+    };
 
     let supervisor = Supervisor::new(peer_list, ProdForkDetector::default(), TestEvidenceReporter);
 

light-client/tests/supervisor.rs

@@ -72,14 +72,14 @@ fn run_multipeer_test(tc: TestBisection<AnonLightBlock>) {
     let primary_instance = make_instance(primary, tc.trust_options.clone(), io.clone(), tc.now);
 
     let mut peer_list = PeerList::builder();
-    peer_list = peer_list.primary(primary, primary_instance);
+    peer_list.primary(primary, primary_instance);
 
     for provider in tc.witnesses.into_iter() {
         let peer_id = provider.value.lite_blocks[0].provider;
         println!("Witness: {}", peer_id);
         let io = MockIo::new(provider.value.chain_id, provider.value.lite_blocks);
         let instance = make_instance(peer_id, tc.trust_options.clone(), io.clone(), tc.now);
-        peer_list = peer_list.witness(peer_id, instance);
+        peer_list.witness(peer_id, instance);
     }
 
     let supervisor = Supervisor::new(

light-node/src/commands/start.rs

@@ -161,32 +161,30 @@ impl StartCmd {
 
     fn construct_supervisor(&self) -> Result<Supervisor, String> {
         let conf = app_config().deref().clone();
-        let options: light_client::Options = conf.into();
-
         let timeout = app_config().rpc_config.request_timeout;
+        let options: light_client::Options = conf.into();
 
         let mut peer_list: PeerListBuilder<Instance> = PeerList::builder();
+
         for (i, light_conf) in app_config().light_clients.iter().enumerate() {
             let instance = self.make_instance(light_conf, options, Some(timeout))?;
 
             if i == 0 {
                 // primary instance
-                peer_list = peer_list.primary(instance.light_client.peer, instance);
+                peer_list.primary(instance.light_client.peer, instance);
             } else {
-                peer_list = peer_list.witness(instance.light_client.peer, instance);
+                peer_list.witness(instance.light_client.peer, instance);
             }
         }
 
-        let peer_list = peer_list.build();
-
         let peer_map: HashMap<_, _> = app_config()
             .light_clients
             .iter()
             .map(|lc| (lc.peer_id, lc.address.clone()))
             .collect();
 
         Ok(Supervisor::new(
-            peer_list,
+            peer_list.build(),
             ProdForkDetector::default(),
             ProdEvidenceReporter::new(peer_map),
         ))