plug in new ledger

src/ledger.rs

@@ -39,17 +39,15 @@ fn entry_at(file: &mut File, at: u64) -> io::Result<Entry> {
     deserialize_from(file.take(len)).map_err(err_bincode_to_io)
 }
 
-fn next_offset(file: &mut File) -> io::Result<u64> {
-    deserialize_from(file.take(SIZEOF_U64)).map_err(err_bincode_to_io)
-}
-
-// unused, but would work for the iterator if we only have the data file...
-//
-//fn next_entry(file: &mut File) -> io::Result<Entry> {
-//    let len = deserialize_from(file.take(SIZEOF_USIZE)).map_err(err_bincode_to_io)?;
-//    deserialize_from(file.take(len)).map_err(err_bincode_to_io)
+//fn next_offset(file: &mut File) -> io::Result<u64> {
+//    deserialize_from(file.take(SIZEOF_U64)).map_err(err_bincode_to_io)
 //}
 
+fn next_entry(file: &mut File) -> io::Result<Entry> {
+    let len = deserialize_from(file.take(SIZEOF_USIZE)).map_err(err_bincode_to_io)?;
+    deserialize_from(file.take(len)).map_err(err_bincode_to_io)
+}
+
 fn u64_at(file: &mut File, at: u64) -> io::Result<u64> {
     file.seek(SeekFrom::Start(at))?;
     deserialize_from(file.take(SIZEOF_U64)).map_err(err_bincode_to_io)
@@ -112,7 +110,7 @@ impl LedgerWriter {
         Ok(LedgerWriter { index, data })
     }
 
-    fn write_entry(&mut self, entry: &Entry) -> io::Result<()> {
+    pub fn write_entry(&mut self, entry: &Entry) -> io::Result<()> {
         let offset = self.data.seek(SeekFrom::Current(0))?;
 
         let len = serialized_size(&entry).map_err(err_bincode_to_io)?;
@@ -146,8 +144,8 @@ impl Iterator for LedgerReader {
     type Item = io::Result<Entry>;
 
     fn next(&mut self) -> Option<io::Result<Entry>> {
-        match next_offset(&mut self.index) {
-            Ok(offset) => Some(entry_at(&mut self.data, offset)),
+        match next_entry(&mut self.data) {
+            Ok(entry) => Some(Ok(entry)),
             Err(_) => None,
         }
     }
@@ -163,7 +161,7 @@ pub fn read_ledger(directory: &str) -> io::Result<impl Iterator<Item = io::Resul
     Ok(LedgerReader { index, data })
 }
 
-pub fn copy(from: &str, to: &str) -> io::Result<()> {
+pub fn copy_ledger(from: &str, to: &str) -> io::Result<()> {
     let mut to = LedgerWriter::new(to)?;
 
     for entry in read_ledger(from)? {
@@ -321,6 +319,12 @@ mod tests {
     use std::net::{IpAddr, Ipv4Addr, SocketAddr};
     use transaction::{Transaction, Vote};
 
+    fn tmp_ledger_path(name: &str) -> String {
+        let keypair = KeyPair::new();
+
+        format!("farf/{}-{}", name, keypair.pubkey())
+    }
+
     #[test]
     fn test_verify_slice() {
         let zero = Hash::default();
@@ -437,18 +441,11 @@ mod tests {
         assert!(entries0.verify(&id));
     }
 
-    fn tmp_ledger_path() -> String {
-        let keypair = KeyPair::new();
-
-        format!(
-            "target/test_ledger_reader_writer_window-{}",
-            keypair.pubkey()
-        )
-    }
+    fn tmp_ledger_path() -> String {}
 
     #[test]
     fn test_ledger_reader_writer() {
-        let ledger_path = tmp_ledger_path();
+        let ledger_path = tmp_ledger_path("test_ledger_reader_writer");
         let entries = make_test_entries();
 
         let mut writer = LedgerWriter::new(&ledger_path).unwrap();
@@ -478,16 +475,16 @@ mod tests {
         std::fs::remove_dir_all(ledger_path).unwrap();
     }
     #[test]
-    fn test_ledger_copy() {
-        let from = tmp_ledger_path();
+    fn test_copy_ledger() {
+        let from = tmp_ledger_path("test_ledger_copy_from");
         let entries = make_test_entries();
 
         let mut writer = LedgerWriter::new(&from).unwrap();
         writer.write_entries(entries.clone()).unwrap();
 
-        let to = tmp_ledger_path();
+        let to = tmp_ledger_path("test_ledger_copy_to");
 
-        copy(&from, &to).unwrap();
+        copy_ledger(&from, &to).unwrap();
 
         let mut read_entries = vec![];
         for x in read_ledger(&to).unwrap() {