Merge branch 'unstable' of https://github.com/sigp/lighthouse into merge-unstable-deneb-june-6th

beacon_node/network/src/sync/range_sync/chain.rs

@@ -1,5 +1,5 @@
 use super::batch::{BatchInfo, BatchProcessingResult, BatchState};
-use crate::beacon_processor::{ChainSegmentProcessId, WorkEvent as BeaconWorkEvent};
+use crate::network_beacon_processor::ChainSegmentProcessId;
 use crate::sync::{
     manager::Id, network_context::SyncNetworkContext, BatchOperationOutcome, BatchProcessResult,
 };
@@ -294,8 +294,8 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
             return Ok(KeepChain);
         }
 
-        let beacon_processor_send = match network.processor_channel_if_enabled() {
-            Some(channel) => channel,
+        let beacon_processor = match network.beacon_processor_if_enabled() {
+            Some(beacon_processor) => beacon_processor,
             None => return Ok(KeepChain),
         };
 
@@ -317,9 +317,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
         let process_id = ChainSegmentProcessId::RangeBatchId(self.id, batch_id);
         self.current_processing_batch = Some(batch_id);
 
-        let work_event = BeaconWorkEvent::chain_segment(process_id, blocks);
-
-        if let Err(e) = beacon_processor_send.try_send(work_event) {
+        if let Err(e) = beacon_processor.send_chain_segment(process_id, blocks) {
             crit!(self.log, "Failed to send chain segment to processor."; "msg" => "process_batch",
                 "error" => %e, "batch" => self.processing_target);
             // This is unlikely to happen but it would stall syncing since the batch now has no

beacon_node/network/src/sync/range_sync/range.rs

@@ -379,25 +379,25 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
-    use crate::beacon_processor::{BeaconProcessorSend, WorkEvent as BeaconWorkEvent};
+    use crate::network_beacon_processor::NetworkBeaconProcessor;
     use crate::service::RequestId;
     use crate::NetworkMessage;
-    use beacon_chain::{
-        builder::Witness,
-        eth1_chain::CachingEth1Backend,
-        parking_lot::RwLock,
-        test_utils::{build_log, BeaconChainHarness, EphemeralHarnessType},
-        EngineState,
-    };
-    use lighthouse_network::{
-        rpc::{BlocksByRangeRequest, StatusMessage},
-        NetworkGlobals, Request,
-    };
-    use slog::o;
-    use slot_clock::TestingSlotClock;
-    use std::{collections::HashSet, sync::Arc};
+
+    use super::*;
+    use beacon_chain::builder::Witness;
+    use beacon_chain::eth1_chain::CachingEth1Backend;
+    use beacon_chain::parking_lot::RwLock;
+    use beacon_chain::EngineState;
+    use beacon_processor::WorkEvent as BeaconWorkEvent;
+    use lighthouse_network::rpc::BlocksByRangeRequest;
+    use lighthouse_network::Request;
+    use lighthouse_network::{rpc::StatusMessage, NetworkGlobals};
+    use slog::{o, Drain};
+    use tokio::sync::mpsc;
+
+    use slot_clock::ManualSlotClock;
+    use std::collections::HashSet;
+    use std::sync::Arc;
     use store::MemoryStore;
     use tokio::sync::mpsc;
     use types::{Hash256, MinimalEthSpec as E};
@@ -449,11 +449,23 @@ mod tests {
     type TestBeaconChainType =
         Witness<TestingSlotClock, CachingEth1Backend<E>, E, MemoryStore<E>, MemoryStore<E>>;
 
+    fn build_log(level: slog::Level, enabled: bool) -> slog::Logger {
+        let decorator = slog_term::TermDecorator::new().build();
+        let drain = slog_term::FullFormat::new(decorator).build().fuse();
+        let drain = slog_async::Async::new(drain).build().fuse();
+
+        if enabled {
+            slog::Logger::root(drain.filter_level(level).fuse(), o!())
+        } else {
+            slog::Logger::root(drain.filter(|_| false).fuse(), o!())
+        }
+    }
+
     #[allow(unused)]
     struct TestRig {
         log: slog::Logger,
         /// To check what does sync send to the beacon processor.
-        beacon_processor_rx: mpsc::Receiver<BeaconWorkEvent<TestBeaconChainType>>,
+        beacon_processor_rx: mpsc::Receiver<BeaconWorkEvent<E>>,
         /// To set up different scenarios where sync is told about known/unkown blocks.
         chain: Arc<FakeStorage>,
         /// Needed by range to handle communication with the network.
@@ -581,7 +593,7 @@ mod tests {
         fn expect_chain_segment(&mut self) {
             match self.beacon_processor_rx.try_recv() {
                 Ok(work) => {
-                    assert_eq!(work.work_type(), crate::beacon_processor::CHAIN_SEGMENT);
+                    assert_eq!(work.work_type(), beacon_processor::CHAIN_SEGMENT);
                 }
                 other => panic!("Expected chain segment process, found {:?}", other),
             }
@@ -607,10 +619,11 @@ mod tests {
         );
         let (network_tx, network_rx) = mpsc::unbounded_channel();
         let globals = Arc::new(NetworkGlobals::new_test_globals(Vec::new(), &log));
+        let (network_beacon_processor, beacon_processor_rx) =
+            NetworkBeaconProcessor::null_for_testing(globals.clone());
         let cx = SyncNetworkContext::new(
             network_tx,
-            globals.clone(),
-            BeaconProcessorSend(beacon_processor_tx),
+            Arc::new(network_beacon_processor),
             chain,
             log.new(o!("component" => "network_context")),
         );