Rocks db window service (#1888)

* Add db_window module for windowing functions from RocksDb

* Replace window with db_window functions in window_service

* Fix tests

* Make note of change in db_window

* Create RocksDb ledger in bin/fullnode

* Make db_ledger functions generic

* Add db_ledger to bin/replicator

src/replicator.rs

@@ -1,5 +1,6 @@
 use blob_fetch_stage::BlobFetchStage;
 use cluster_info::{ClusterInfo, Node, NodeInfo};
+use db_ledger::DbLedger;
 use leader_scheduler::LeaderScheduler;
 use ncp::Ncp;
 use service::Service;
@@ -104,9 +105,20 @@ impl Replicator {
         let (entry_window_sender, entry_window_receiver) = channel();
         // todo: pull blobs off the retransmit_receiver and recycle them?
         let (retransmit_sender, retransmit_receiver) = channel();
+
+        // Create the RocksDb ledger, eventually will simply repurpose the input
+        // ledger path as the RocksDb ledger path once we replace the ledger with
+        // RocksDb. Note for now, this ledger will not contain any of the existing entries
+        // in the ledger located at ledger_path, and will only append on newly received
+        // entries after being passed to window_service
+        let db_ledger = Arc::new(RwLock::new(
+            DbLedger::open(&ledger_path.unwrap())
+                .expect("Expected to be able to open database ledger"),
+        ));
+
         let t_window = window_service(
+            db_ledger,
             cluster_info.clone(),
-            shared_window.clone(),
             0,
             entry_height,
             max_entry_height,
@@ -165,6 +177,7 @@ impl Replicator {
 mod tests {
     use client::mk_client;
     use cluster_info::Node;
+    use db_ledger::DbLedger;
     use fullnode::Fullnode;
     use leader_scheduler::LeaderScheduler;
     use ledger::{create_tmp_genesis, get_tmp_ledger_path, read_ledger};
@@ -204,67 +217,73 @@ mod tests {
         let (mint, leader_ledger_path) =
             create_tmp_genesis(leader_ledger_path, 100, leader_info.id, 1);
 
-        let leader = Fullnode::new(
-            leader_node,
-            &leader_ledger_path,
-            leader_keypair,
-            vote_account_keypair,
-            None,
-            false,
-            LeaderScheduler::from_bootstrap_leader(leader_info.id),
-            None,
-        );
+        {
+            let leader = Fullnode::new(
+                leader_node,
+                &leader_ledger_path,
+                leader_keypair,
+                vote_account_keypair,
+                None,
+                false,
+                LeaderScheduler::from_bootstrap_leader(leader_info.id),
+                None,
+            );
 
-        let mut leader_client = mk_client(&leader_info);
+            let mut leader_client = mk_client(&leader_info);
 
-        let bob = Keypair::new();
+            let bob = Keypair::new();
 
-        let last_id = leader_client.get_last_id();
-        leader_client
-            .transfer(1, &mint.keypair(), bob.pubkey(), &last_id)
-            .unwrap();
-
-        let replicator_keypair = Keypair::new();
-
-        info!("starting replicator node");
-        let replicator_node = Node::new_localhost_with_pubkey(replicator_keypair.pubkey());
-        let (replicator, _leader_info) = Replicator::new(
-            entry_height,
-            1,
-            &exit,
-            Some(replicator_ledger_path),
-            replicator_node,
-            Some(network_addr),
-            done.clone(),
-        );
-
-        let mut num_entries = 0;
-        for _ in 0..60 {
-            match read_ledger(replicator_ledger_path, true) {
-                Ok(entries) => {
-                    for _ in entries {
-                        num_entries += 1;
-                    }
-                    info!("{} entries", num_entries);
-                    if num_entries > 0 {
-                        break;
-                    }
-                }
-                Err(e) => {
-                    info!("error reading ledger: {:?}", e);
-                }
-            }
-            sleep(Duration::from_millis(300));
             let last_id = leader_client.get_last_id();
             leader_client
                 .transfer(1, &mint.keypair(), bob.pubkey(), &last_id)
                 .unwrap();
+
+            let replicator_keypair = Keypair::new();
+
+            info!("starting replicator node");
+            let replicator_node = Node::new_localhost_with_pubkey(replicator_keypair.pubkey());
+            let (replicator, _leader_info) = Replicator::new(
+                entry_height,
+                1,
+                &exit,
+                Some(replicator_ledger_path),
+                replicator_node,
+                Some(network_addr),
+                done.clone(),
+            );
+
+            let mut num_entries = 0;
+            for _ in 0..60 {
+                match read_ledger(replicator_ledger_path, true) {
+                    Ok(entries) => {
+                        for _ in entries {
+                            num_entries += 1;
+                        }
+                        info!("{} entries", num_entries);
+                        if num_entries > 0 {
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        info!("error reading ledger: {:?}", e);
+                    }
+                }
+                sleep(Duration::from_millis(300));
+                let last_id = leader_client.get_last_id();
+                leader_client
+                    .transfer(1, &mint.keypair(), bob.pubkey(), &last_id)
+                    .unwrap();
+            }
+            assert_eq!(done.load(Ordering::Relaxed), true);
+            assert!(num_entries > 0);
+            exit.store(true, Ordering::Relaxed);
+            replicator.join();
+            leader.exit();
         }
-        assert_eq!(done.load(Ordering::Relaxed), true);
-        assert!(num_entries > 0);
-        exit.store(true, Ordering::Relaxed);
-        replicator.join();
-        leader.exit();
+
+        DbLedger::destroy(&leader_ledger_path).expect("Expected successful database destuction");
+        DbLedger::destroy(&replicator_ledger_path)
+            .expect("Expected successful database destuction");
         let _ignored = remove_dir_all(&leader_ledger_path);
         let _ignored = remove_dir_all(&replicator_ledger_path);
     }