Add feature flag for writing ssz pre/post to disk (#1046)

beacon_node/Cargo.toml

@@ -11,6 +11,9 @@ path = "src/lib.rs"
 [dev-dependencies]
 node_test_rig = { path = "../tests/node_test_rig" }
 
+[features]
+write_ssz_files = ["beacon_chain/write_ssz_files"]  # Writes debugging .ssz files to /tmp during block processing.
+
 [dependencies]
 eth2_config = { path = "../eth2/utils/eth2_config" }
 beacon_chain = { path = "beacon_chain" }

beacon_node/beacon_chain/Cargo.toml

@@ -5,7 +5,6 @@ authors = ["Paul Hauner <paul@paulhauner.com>", "Age Manning <Age@AgeManning.com
 edition = "2018"
 
 [features]
-
 write_ssz_files = []  # Writes debugging .ssz files to /tmp during block processing.
 
 [dependencies]

beacon_node/beacon_chain/src/block_verification.rs

@@ -49,7 +49,9 @@ use crate::{
     metrics, BeaconChain, BeaconChainError, BeaconChainTypes, BeaconSnapshot,
 };
 use parking_lot::RwLockReadGuard;
+use slog::{error, Logger};
 use slot_clock::SlotClock;
+use ssz::Encode;
 use state_processing::{
     block_signature_verifier::{
         BlockSignatureVerifier, Error as BlockSignatureVerifierError, G1Point,
@@ -58,7 +60,10 @@ use state_processing::{
     SlotProcessingError,
 };
 use std::borrow::Cow;
+use std::fs;
+use std::io::Write;
 use store::{Error as DBError, StateBatch};
+use tree_hash::TreeHash;
 use types::{
     BeaconBlock, BeaconState, BeaconStateError, ChainSpec, CloneConfig, EthSpec, Hash256,
     RelativeEpoch, SignedBeaconBlock, Slot,
@@ -71,6 +76,12 @@ pub use block_processing_outcome::BlockProcessingOutcome;
 /// Maximum block slot number. Block with slots bigger than this constant will NOT be processed.
 const MAXIMUM_BLOCK_SLOT_NUMBER: u64 = 4_294_967_296; // 2^32
 
+/// If true, everytime a block is processed the pre-state, post-state and block are written to SSZ
+/// files in the temp directory.
+///
+/// Only useful for testing.
+const WRITE_BLOCK_PROCESSING_SSZ: bool = cfg!(feature = "write_ssz_files");
+
 /// Returned when a block was not verified. A block is not verified for two reasons:
 ///
 /// - The block is malformed/invalid (indicated by all results other than `BeaconChainError`.
@@ -521,6 +532,13 @@ impl<T: BeaconChainTypes> FullyVerifiedBlock<T> {
          * invalid.
          */
 
+        write_state(
+            &format!("state_pre_block_{}", block_root),
+            &state,
+            &chain.log,
+        );
+        write_block(&block, block_root, &chain.log);
+
         let core_timer = metrics::start_timer(&metrics::BLOCK_PROCESSING_CORE);
 
         if let Err(err) = per_block_processing(
@@ -551,6 +569,12 @@ impl<T: BeaconChainTypes> FullyVerifiedBlock<T> {
 
         metrics::stop_timer(state_root_timer);
 
+        write_state(
+            &format!("state_post_block_{}", block_root),
+            &state,
+            &chain.log,
+        );
+
         /*
          * Check to ensure the state root on the block matches the one we have calculated.
          */
@@ -806,3 +830,46 @@ fn get_signature_verifier<'a, E: EthSpec>(
         spec,
     )
 }
+
+fn write_state<T: EthSpec>(prefix: &str, state: &BeaconState<T>, log: &Logger) {
+    if WRITE_BLOCK_PROCESSING_SSZ {
+        let root = state.tree_hash_root();
+        let filename = format!("{}_slot_{}_root_{}.ssz", prefix, state.slot, root);
+        let mut path = std::env::temp_dir().join("lighthouse");
+        let _ = fs::create_dir_all(path.clone());
+        path = path.join(filename);
+
+        match fs::File::create(path.clone()) {
+            Ok(mut file) => {
+                let _ = file.write_all(&state.as_ssz_bytes());
+            }
+            Err(e) => error!(
+                log,
+                "Failed to log state";
+                "path" => format!("{:?}", path),
+                "error" => format!("{:?}", e)
+            ),
+        }
+    }
+}
+
+fn write_block<T: EthSpec>(block: &SignedBeaconBlock<T>, root: Hash256, log: &Logger) {
+    if WRITE_BLOCK_PROCESSING_SSZ {
+        let filename = format!("block_slot_{}_root{}.ssz", block.message.slot, root);
+        let mut path = std::env::temp_dir().join("lighthouse");
+        let _ = fs::create_dir_all(path.clone());
+        path = path.join(filename);
+
+        match fs::File::create(path.clone()) {
+            Ok(mut file) => {
+                let _ = file.write_all(&block.as_ssz_bytes());
+            }
+            Err(e) => error!(
+                log,
+                "Failed to log block";
+                "path" => format!("{:?}", path),
+                "error" => format!("{:?}", e)
+            ),
+        }
+    }
+}

lighthouse/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.2.0"
 authors = ["Sigma Prime <contact@sigmaprime.io>"]
 edition = "2018"
 
+[features]
+write_ssz_files = ["beacon_node/write_ssz_files"]  # Writes debugging .ssz files to /tmp during block processing.
+
 [dependencies]
 beacon_node = { "path" = "../beacon_node" }
 tokio = "0.1.22"