move copy_ledger() back into ledger.rs

Don't recover() for copy(), as copy() is already tolerant of things
    recover() guards against.  Note: recover() is problematic if the ledger is
    "live", i.e. is currently being written to.

src/fullnode.rs

@@ -143,14 +143,14 @@ impl FullNode {
     pub fn new_without_sigverify(
         node: TestNode,
         leader: bool,
-        ledger: &str,
+        ledger_path: &str,
         keypair: KeyPair,
         network_entry_for_validator: Option<SocketAddr>,
     ) -> FullNode {
         FullNode::new_internal(
             node,
             leader,
-            ledger,
+            ledger_path,
             keypair,
             network_entry_for_validator,
             true,

src/ledger.rs

@@ -222,6 +222,9 @@ fn recover_ledger(ledger_path: &Path) -> io::Result<()> {
             }
         }
     }
+    let num_entries = index.metadata()?.len() / SIZEOF_U64;
+    trace!("recover: done. {} entries", num_entries);
+
     // flush everything to disk...
     index.sync_all()?;
     data.sync_all()
@@ -258,24 +261,24 @@ impl LedgerWriter {
         } else {
             recover_ledger(ledger_path)?;
         }
-        let mut index = OpenOptions::new()
+        let index = OpenOptions::new()
             .create(create)
             .append(true)
             .open(ledger_path.join("index"))?;
 
         if log_enabled!(Trace) {
-            let offset = index.seek(SeekFrom::Current(0))?;
-            trace!("LedgerWriter::new: index fp:{}", offset);
+            let len = index.metadata()?.len();
+            trace!("LedgerWriter::new: index fp:{}", len);
         }
 
-        let mut data = OpenOptions::new()
+        let data = OpenOptions::new()
             .create(create)
             .append(true)
             .open(ledger_path.join("data"))?;
 
         if log_enabled!(Trace) {
-            let offset = data.seek(SeekFrom::Current(0))?;
-            trace!("LedgerWriter::new: data fp:{}", offset);
+            let len = data.metadata()?.len();
+            trace!("LedgerWriter::new: data fp:{}", len);
         }
 
         Ok(LedgerWriter { index, data })
@@ -349,6 +352,22 @@ pub fn read_ledger(ledger_path: &str) -> io::Result<impl Iterator<Item = io::Res
     Ok(LedgerReader { data })
 }
 
+/// copy ledger is doesn't fix up the "from" ledger
+pub fn copy_ledger(from: &str, to: &str) -> io::Result<()> {
+    let mut to = LedgerWriter::new(to, true)?;
+
+    let from = Path::new(&from);
+
+    // for a copy, we read "readonly" from data
+    let data = File::open(from.join("data"))?;
+
+    for entry in (LedgerReader { data }) {
+        let entry = entry?;
+        to.write_entry(&entry)?;
+    }
+    Ok(())
+}
+
 // a Block is a slice of Entries
 pub trait Block {
     /// Verifies the hashes and counts of a slice of transactions are all consistent.
@@ -764,4 +783,31 @@ mod tests {
         let _ignored = remove_dir_all(&ledger_path);
     }
 
+    #[test]
+    fn test_copy_ledger() {
+        use logger;
+        logger::setup();
+
+        let from = tmp_ledger_path("test_ledger_copy_from");
+        let entries = make_tiny_test_entries(10);
+
+        let mut writer = LedgerWriter::new(&from, true).unwrap();
+        writer.write_entries(entries.clone()).unwrap();
+
+        let to = tmp_ledger_path("test_ledger_copy_to");
+
+        copy_ledger(&from, &to).unwrap();
+
+        let mut read_entries = vec![];
+        for x in read_ledger(&to).unwrap() {
+            let entry = x.unwrap();
+            trace!("entry... {:?}", entry);
+            read_entries.push(entry);
+        }
+        assert_eq!(read_entries, entries);
+
+        std::fs::remove_dir_all(from).unwrap();
+        std::fs::remove_dir_all(to).unwrap();
+    }
+
 }

tests/multinode.rs

@@ -6,7 +6,7 @@ extern crate solana;
 
 use solana::crdt::{Crdt, NodeInfo, TestNode};
 use solana::fullnode::FullNode;
-use solana::ledger::{read_ledger, LedgerWriter};
+use solana::ledger::{copy_ledger, LedgerWriter};
 use solana::logger;
 use solana::mint::Mint;
 use solana::ncp::Ncp;
@@ -18,7 +18,6 @@ use solana::timing::duration_as_s;
 use std::cmp::max;
 use std::env;
 use std::fs::remove_dir_all;
-use std::io;
 use std::net::UdpSocket;
 use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, RwLock};
@@ -90,40 +89,6 @@ fn genesis(name: &str, num: i64) -> (Mint, String) {
     (mint, path)
 }
 
-//#[test]
-//fn test_copy_ledger() {
-//    let from = tmp_ledger_path("test_ledger_copy_from");
-//    let entries = make_tiny_test_entries(10);
-//
-//    let mut writer = LedgerWriter::new(&from, true).unwrap();
-//    writer.write_entries(entries.clone()).unwrap();
-//
-//    let to = tmp_ledger_path("test_ledger_copy_to");
-//
-//    copy_ledger(&from, &to).unwrap();
-//
-//    let mut read_entries = vec![];
-//    for x in read_ledger(&to).unwrap() {
-//        let entry = x.unwrap();
-//        trace!("entry... {:?}", entry);
-//        read_entries.push(entry);
-//    }
-//    assert_eq!(read_entries, entries);
-//
-//    std::fs::remove_dir_all(from).unwrap();
-//    std::fs::remove_dir_all(to).unwrap();
-//}
-//
-fn copy_ledger(from: &str, to: &str) -> io::Result<()> {
-    let mut to = LedgerWriter::new(to, true)?;
-
-    for entry in read_ledger(from)? {
-        let entry = entry?;
-        to.write_entry(&entry)?;
-    }
-    Ok(())
-}
-
 fn tmp_copy_ledger(from: &str, name: &str) -> String {
     let to = tmp_ledger_path(name);
     copy_ledger(from, &to).unwrap();