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/beacon_chain/src/migrate.rs

@@ -9,14 +9,16 @@ use std::sync::Arc;
 use std::thread;
 use store::hot_cold_store::{process_finalization, HotColdDBError};
 use store::iter::{ParentRootBlockIterator, RootsIterator};
-use store::{Error, Store, StoreOp};
+use store::{Error, ItemStore, StoreOp};
 pub use store::{HotColdDB, MemoryStore};
 use types::*;
 use types::{BeaconState, EthSpec, Hash256, Slot};
 
 /// Trait for migration processes that update the database upon finalization.
-pub trait Migrate<E: EthSpec>: Send + Sync + 'static {
-    fn new(db: Arc<HotColdDB<E>>, log: Logger) -> Self;
+pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:
+    Send + Sync + 'static
+{
+    fn new(db: Arc<HotColdDB<E, Hot, Cold>>, log: Logger) -> Self;
 
     fn process_finalization(
         &self,
@@ -30,13 +32,13 @@ pub trait Migrate<E: EthSpec>: Send + Sync + 'static {
     }
 
     /// Traverses live heads and prunes blocks and states of chains that we know can't be built
-    /// upon because finalization would prohibit it.  This is a optimisation intended to save disk
+    /// upon because finalization would prohibit it.  This is an optimisation intended to save disk
     /// space.
     ///
     /// Assumptions:
     ///  * It is called after every finalization.
     fn prune_abandoned_forks(
-        store: Arc<HotColdDB<E>>,
+        store: Arc<HotColdDB<E, Hot, Cold>>,
         head_tracker: Arc<HeadTracker>,
         old_finalized_block_hash: SignedBeaconBlockHash,
         new_finalized_block_hash: SignedBeaconBlockHash,
@@ -171,8 +173,8 @@ pub trait Migrate<E: EthSpec>: Send + Sync + 'static {
 /// Migrator that does nothing, for stores that don't need migration.
 pub struct NullMigrator;
 
-impl<E: EthSpec> Migrate<E> for NullMigrator {
-    fn new(_: Arc<HotColdDB<E>>, _: Logger) -> Self {
+impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold> for NullMigrator {
+    fn new(_: Arc<HotColdDB<E, Hot, Cold>>, _: Logger) -> Self {
         NullMigrator
     }
 }
@@ -180,12 +182,14 @@ impl<E: EthSpec> Migrate<E> for NullMigrator {
 /// Migrator that immediately calls the store's migration function, blocking the current execution.
 ///
 /// Mostly useful for tests.
-pub struct BlockingMigrator<E: EthSpec> {
-    db: Arc<HotColdDB<E>>,
+pub struct BlockingMigrator<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> {
+    db: Arc<HotColdDB<E, Hot, Cold>>,
 }
 
-impl<E: EthSpec> Migrate<E> for BlockingMigrator<E> {
-    fn new(db: Arc<HotColdDB<E>>, _: Logger) -> Self {
+impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold>
+    for BlockingMigrator<E, Hot, Cold>
+{
+    fn new(db: Arc<HotColdDB<E, Hot, Cold>>, _: Logger) -> Self {
         BlockingMigrator { db }
     }
 
@@ -225,14 +229,16 @@ type MpscSender<E> = mpsc::Sender<(
 )>;
 
 /// Migrator that runs a background thread to migrate state from the hot to the cold database.
-pub struct BackgroundMigrator<E: EthSpec> {
-    db: Arc<HotColdDB<E>>,
+pub struct BackgroundMigrator<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> {
+    db: Arc<HotColdDB<E, Hot, Cold>>,
     tx_thread: Mutex<(MpscSender<E>, thread::JoinHandle<()>)>,
     log: Logger,
 }
 
-impl<E: EthSpec> Migrate<E> for BackgroundMigrator<E> {
-    fn new(db: Arc<HotColdDB<E>>, log: Logger) -> Self {
+impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold>
+    for BackgroundMigrator<E, Hot, Cold>
+{
+    fn new(db: Arc<HotColdDB<E, Hot, Cold>>, log: Logger) -> Self {
         let tx_thread = Mutex::new(Self::spawn_thread(db.clone(), log.clone()));
         Self { db, tx_thread, log }
     }
@@ -283,7 +289,7 @@ impl<E: EthSpec> Migrate<E> for BackgroundMigrator<E> {
     }
 }
 
-impl<E: EthSpec> BackgroundMigrator<E> {
+impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> BackgroundMigrator<E, Hot, Cold> {
     /// Return true if a migration needs to be performed, given a new `finalized_slot`.
     fn needs_migration(&self, finalized_slot: Slot, max_finality_distance: u64) -> bool {
         let finality_distance = finalized_slot - self.db.get_split_slot();
@@ -294,7 +300,7 @@ impl<E: EthSpec> BackgroundMigrator<E> {
     ///
     /// Return a channel handle for sending new finalized states to the thread.
     fn spawn_thread(
-        db: Arc<HotColdDB<E>>,
+        db: Arc<HotColdDB<E, Hot, Cold>>,
         log: Logger,
     ) -> (
         mpsc::Sender<(