Receive entries first, then write

src/entry_writer.rs

@@ -51,12 +51,13 @@ impl<'a> EntryWriter<'a> {
     ) -> Result<Vec<Entry>> {
         //TODO implement a serialize for channel that does this without allocations
         let entry = entry_receiver.recv_timeout(Duration::new(1, 0))?;
-        self.write_and_register_entry(writer, &entry)?;
         let mut entries = vec![entry];
         while let Ok(entry) = entry_receiver.try_recv() {
-            self.write_and_register_entry(writer, &entry)?;
             entries.push(entry);
         }
+        for entry in &entries {
+            self.write_and_register_entry(writer, &entry)?;
+        }
         Ok(entries)
     }
 
@@ -64,18 +65,18 @@ impl<'a> EntryWriter<'a> {
     /// continuosly broadcast blobs of entries out
     pub fn write_and_send_entries<W: Write>(
         &self,
-        broadcast: &BlobSender,
+        blob_sender: &BlobSender,
         blob_recycler: &BlobRecycler,
         writer: &Mutex<W>,
         entry_receiver: &Receiver<Entry>,
     ) -> Result<()> {
-        let mut q = VecDeque::new();
+        let entries = self.write_entries(writer, entry_receiver)?;
-        let list = self.write_entries(writer, entry_receiver)?;
+        trace!("New blobs? {}", entries.len());
-        trace!("New blobs? {}", list.len());
+        let mut blobs = VecDeque::new();
-        list.to_blobs(blob_recycler, &mut q);
+        entries.to_blobs(blob_recycler, &mut blobs);
-        if !q.is_empty() {
+        if !blobs.is_empty() {
-            trace!("broadcasting {}", q.len());
+            trace!("broadcasting {}", blobs.len());
-            broadcast.send(q)?;
+            blob_sender.send(blobs)?;
         }
         Ok(())
     }