Make key value storage abstractions more accurate (#1267)

* Layer do_atomically() abstractions properly

* Reduce allocs and DRY get_key_for_col()

* Parameterize HotColdDB with hot and cold item stores

* -impl Store for MemoryStore

* Replace Store uses with HotColdDB

* Ditch Store trait

* cargo fmt

* Style fix

* Readd missing dep that broke the build

beacon_node/network/src/attestation_service/tests/mod.rs

@@ -17,19 +17,21 @@ mod tests {
     use sloggers::{null::NullLoggerBuilder, Build};
     use slot_clock::{SlotClock, SystemTimeSlotClock};
     use std::time::{Duration, SystemTime};
-    use store::MemoryStore;
+    use store::config::StoreConfig;
+    use store::{HotColdDB, MemoryStore};
     use tempfile::tempdir;
     use types::{CommitteeIndex, EnrForkId, EthSpec, MinimalEthSpec};
 
     const SLOT_DURATION_MILLIS: u64 = 200;
 
     type TestBeaconChainType = Witness<
-        MemoryStore<MinimalEthSpec>,
         NullMigrator,
         SystemTimeSlotClock,
-        CachingEth1Backend<MinimalEthSpec, MemoryStore<MinimalEthSpec>>,
+        CachingEth1Backend<MinimalEthSpec>,
         MinimalEthSpec,
         NullEventHandler<MinimalEthSpec>,
+        MemoryStore<MinimalEthSpec>,
+        MemoryStore<MinimalEthSpec>,
     >;
 
     pub struct TestBeaconChain {
@@ -44,11 +46,14 @@ mod tests {
             let keypairs = generate_deterministic_keypairs(1);
 
             let log = get_logger();
+            let store =
+                HotColdDB::open_ephemeral(StoreConfig::default(), spec.clone(), log.clone())
+                    .unwrap();
             let chain = Arc::new(
                 BeaconChainBuilder::new(MinimalEthSpec)
                     .logger(log.clone())
                     .custom_spec(spec.clone())
-                    .store(Arc::new(MemoryStore::open()))
+                    .store(Arc::new(store))
                     .store_migrator(NullMigrator)
                     .data_dir(data_dir.path().to_path_buf())
                     .genesis_state(
@@ -85,7 +90,7 @@ mod tests {
     }
 
     lazy_static! {
-        static ref CHAIN: TestBeaconChain = { TestBeaconChain::new_with_system_clock() };
+        static ref CHAIN: TestBeaconChain = TestBeaconChain::new_with_system_clock();
     }
 
     fn get_attestation_service() -> AttestationService<TestBeaconChainType> {

beacon_node/network/src/persisted_dht.rs

@@ -1,13 +1,15 @@
 use eth2_libp2p::Enr;
 use rlp;
 use std::sync::Arc;
-use store::{DBColumn, Error as StoreError, Store, StoreItem};
+use store::{DBColumn, Error as StoreError, HotColdDB, ItemStore, StoreItem};
 use types::{EthSpec, Hash256};
 
 /// 32-byte key for accessing the `DhtEnrs`.
 pub const DHT_DB_KEY: &str = "PERSISTEDDHTPERSISTEDDHTPERSISTE";
 
-pub fn load_dht<T: Store<E>, E: EthSpec>(store: Arc<T>) -> Vec<Enr> {
+pub fn load_dht<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
+    store: Arc<HotColdDB<E, Hot, Cold>>,
+) -> Vec<Enr> {
     // Load DHT from store
     let key = Hash256::from_slice(&DHT_DB_KEY.as_bytes());
     match store.get_item(&key) {
@@ -20,8 +22,8 @@ pub fn load_dht<T: Store<E>, E: EthSpec>(store: Arc<T>) -> Vec<Enr> {
 }
 
 /// Attempt to persist the ENR's in the DHT to `self.store`.
-pub fn persist_dht<T: Store<E>, E: EthSpec>(
-    store: Arc<T>,
+pub fn persist_dht<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
+    store: Arc<HotColdDB<E, Hot, Cold>>,
     enrs: Vec<Enr>,
 ) -> Result<(), store::Error> {
     let key = Hash256::from_slice(&DHT_DB_KEY.as_bytes());
@@ -56,14 +58,19 @@ impl StoreItem for PersistedDht {
 mod tests {
     use super::*;
     use eth2_libp2p::Enr;
+    use sloggers::{null::NullLoggerBuilder, Build};
     use std::str::FromStr;
-    use std::sync::Arc;
-    use store::{MemoryStore, Store};
-    use types::Hash256;
-    use types::MinimalEthSpec;
+    use store::config::StoreConfig;
+    use store::{HotColdDB, MemoryStore};
+    use types::{ChainSpec, Hash256, MinimalEthSpec};
     #[test]
     fn test_persisted_dht() {
-        let store = Arc::new(MemoryStore::<MinimalEthSpec>::open());
+        let log = NullLoggerBuilder.build().unwrap();
+        let store: HotColdDB<
+            MinimalEthSpec,
+            MemoryStore<MinimalEthSpec>,
+            MemoryStore<MinimalEthSpec>,
+        > = HotColdDB::open_ephemeral(StoreConfig::default(), ChainSpec::minimal(), log).unwrap();
         let enrs = vec![Enr::from_str("enr:-IS4QHCYrYZbAKWCBRlAy5zzaDZXJBGkcnh4MHcBFZntXNFrdvJjX04jRzjzCBOonrkTfj499SZuOh8R33Ls8RRcy5wBgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQPKY0yuDUmstAHYpMa2_oxVtw0RW_QAdpzBQA8yWM0xOIN1ZHCCdl8").unwrap()];
         let key = Hash256::from_slice(&DHT_DB_KEY.as_bytes());
         store

beacon_node/network/src/router/processor.rs

@@ -13,7 +13,6 @@ use itertools::process_results;
 use slog::{debug, error, o, trace, warn};
 use ssz::Encode;
 use std::sync::Arc;
-use store::Store;
 use tokio::sync::mpsc;
 use types::{
     Attestation, ChainSpec, Epoch, EthSpec, Hash256, SignedAggregateAndProof, SignedBeaconBlock,

beacon_node/network/src/service.rs

@@ -17,6 +17,7 @@ use rest_types::ValidatorSubscription;
 use slog::{debug, error, info, o, trace};
 use std::sync::Arc;
 use std::time::Duration;
+use store::HotColdDB;
 use tokio::sync::mpsc;
 use tokio::time::Delay;
 use types::EthSpec;
@@ -40,7 +41,7 @@ pub struct NetworkService<T: BeaconChainTypes> {
     /// lighthouse.
     router_send: mpsc::UnboundedSender<RouterMessage<T::EthSpec>>,
     /// A reference to lighthouse's database to persist the DHT.
-    store: Arc<T::Store>,
+    store: Arc<HotColdDB<T::EthSpec, T::HotStore, T::ColdStore>>,
     /// A collection of global variables, accessible outside of the network service.
     network_globals: Arc<NetworkGlobals<T::EthSpec>>,
     /// A delay that expires when a new fork takes place.
@@ -78,7 +79,7 @@ impl<T: BeaconChainTypes> NetworkService<T> {
         let (network_globals, mut libp2p) =
             LibP2PService::new(executor.clone(), config, enr_fork_id, &network_log)?;
 
-        for enr in load_dht::<T::Store, T::EthSpec>(store.clone()) {
+        for enr in load_dht::<T::EthSpec, T::HotStore, T::ColdStore>(store.clone()) {
             libp2p.swarm.add_enr(enr);
         }
 
@@ -142,7 +143,7 @@ fn spawn_service<T: BeaconChainTypes>(
                         "Number of peers" => format!("{}", enrs.len()),
                     );
 
-                    match persist_dht::<T::Store, T::EthSpec>(service.store.clone(), enrs) {
+                    match persist_dht::<T::EthSpec, T::HotStore, T::ColdStore>(service.store.clone(), enrs) {
                         Err(e) => error!(
                             service.log,
                             "Failed to persist DHT on drop";

beacon_node/network/src/service/tests.rs

@@ -9,6 +9,7 @@ mod tests {
     use sloggers::{null::NullLoggerBuilder, Build};
     use std::str::FromStr;
     use std::sync::Arc;
+    use store::config::StoreConfig;
     use tokio::runtime::Runtime;
     use types::{test_utils::generate_deterministic_keypairs, MinimalEthSpec};
 
@@ -22,7 +23,12 @@ mod tests {
         let log = get_logger();
 
         let beacon_chain = Arc::new(
-            BeaconChainHarness::new(MinimalEthSpec, generate_deterministic_keypairs(8)).chain,
+            BeaconChainHarness::new(
+                MinimalEthSpec,
+                generate_deterministic_keypairs(8),
+                StoreConfig::default(),
+            )
+            .chain,
         );
 
         let store = beacon_chain.store.clone();