Make space for a write_entry() that only writes entries

src/entry_writer.rs

@@ -25,15 +25,22 @@ impl<'a> EntryWriter<'a> {
         EntryWriter { bank }
     }
 
-    fn write_entry<W: Write>(&self, writer: &Mutex<W>, entry: &Entry) -> io::Result<()> {
-        trace!("write_entry entry");
+    fn write_and_register_entry<W: Write>(
+        &self,
+        writer: &Mutex<W>,
+        entry: &Entry,
+    ) -> io::Result<()> {
+        trace!("write_and_register_entry entry");
         if !entry.has_more {
             self.bank.register_entry_id(&entry.id);
         }
         writeln!(
-            writer.lock().expect("'writer' lock in fn fn write_entry"),
+            writer
+                .lock()
+                .expect("'writer' lock in fn fn write_and_register_entry"),
             "{}",
-            serde_json::to_string(&entry).expect("'entry' to_strong in fn write_entry")
+            serde_json::to_string(&entry)
+                .expect("'entry' to_strong in fn write_and_register_entry")
         )
     }
 
@@ -45,10 +52,10 @@ impl<'a> EntryWriter<'a> {
         //TODO implement a serialize for channel that does this without allocations
         let mut l = vec![];
         let entry = entry_receiver.recv_timeout(Duration::new(1, 0))?;
-        self.write_entry(writer, &entry)?;
+        self.write_and_register_entry(writer, &entry)?;
         l.push(entry);
         while let Ok(entry) = entry_receiver.try_recv() {
-            self.write_entry(writer, &entry)?;
+            self.write_and_register_entry(writer, &entry)?;
             l.push(entry);
         }
         Ok(l)
@@ -110,14 +117,18 @@ mod tests {
         assert!(entries[0].has_more);
         assert!(!entries[1].has_more);
 
-        // Verify that write_entry doesn't register the first entries after a split.
+        // Verify that write_and_register_entry doesn't register the first entries after a split.
         assert_eq!(bank.last_id(), mint.last_id());
         let writer = Mutex::new(sink());
-        entry_writer.write_entry(&writer, &entries[0]).unwrap();
+        entry_writer
+            .write_and_register_entry(&writer, &entries[0])
+            .unwrap();
         assert_eq!(bank.last_id(), mint.last_id());
 
-        // Verify that write_entry registers the final entry after a split.
-        entry_writer.write_entry(&writer, &entries[1]).unwrap();
+        // Verify that write_and_register_entry registers the final entry after a split.
+        entry_writer
+            .write_and_register_entry(&writer, &entries[1])
+            .unwrap();
         assert_eq!(bank.last_id(), entries[1].id);
     }
 }