X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-background-processor%2Fsrc%2Flib.rs;h=16e06780dfce48ade113ddd97aaf06860c6f1596;hb=2f9c3e5ea12483af930c1e0cb843dd33348aeb5f;hp=b2ee865471c89f3ca1d537088c8e3425c9d4cbf8;hpb=e59b3847a363afba5d30e1f1271341e3163f7591;p=rust-lightning diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index b2ee8654..16e06780 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -11,6 +11,14 @@ #![cfg_attr(docsrs, feature(doc_auto_cfg))] +#![cfg_attr(all(not(feature = "std"), not(test)), no_std)] + +#[cfg(any(test, feature = "std"))] +extern crate core; + +#[cfg(not(feature = "std"))] +extern crate alloc; + #[macro_use] extern crate lightning; extern crate lightning_rapid_gossip_sync; @@ -23,20 +31,29 @@ use lightning::ln::msgs::{ChannelMessageHandler, OnionMessageHandler, RoutingMes use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor}; use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; use lightning::routing::router::Router; -use lightning::routing::scoring::WriteableScore; +use lightning::routing::scoring::{Score, WriteableScore}; use lightning::util::events::{Event, EventHandler, EventsProvider}; use lightning::util::logger::Logger; use lightning::util::persist::Persister; use lightning_rapid_gossip_sync::RapidGossipSync; +use lightning::io; + +use core::ops::Deref; +use core::time::Duration; + +#[cfg(feature = "std")] use std::sync::Arc; -use std::sync::atomic::{AtomicBool, Ordering}; -use std::thread; -use std::thread::JoinHandle; -use std::time::{Duration, Instant}; -use std::ops::Deref; +#[cfg(feature = "std")] +use core::sync::atomic::{AtomicBool, Ordering}; +#[cfg(feature = "std")] +use std::thread::{self, JoinHandle}; +#[cfg(feature = "std")] +use std::time::Instant; #[cfg(feature = "futures")] use futures_util::{select_biased, future::FutureExt, task}; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; /// `BackgroundProcessor` takes care of tasks that (1) need to happen periodically to keep /// Rust-Lightning running properly, and (2) either can or should be run in the background. Its @@ -62,6 +79,7 @@ use futures_util::{select_biased, future::FutureExt, task}; /// /// [`ChannelMonitor`]: lightning::chain::channelmonitor::ChannelMonitor /// [`Event`]: lightning::util::events::Event +#[cfg(feature = "std")] #[must_use = "BackgroundProcessor will immediately stop on drop. It should be stored until shutdown."] pub struct BackgroundProcessor { stop_thread: Arc, @@ -203,6 +221,37 @@ fn handle_network_graph_update( } } +fn update_scorer<'a, S: 'static + Deref + Send + Sync, SC: 'a + WriteableScore<'a>>( + scorer: &'a S, event: &Event +) { + let mut score = scorer.lock(); + match event { + Event::PaymentPathFailed { ref path, short_channel_id: Some(scid), .. } => { + let path = path.iter().collect::>(); + score.payment_path_failed(&path, *scid); + }, + Event::PaymentPathFailed { ref path, payment_failed_permanently: true, .. } => { + // Reached if the destination explicitly failed it back. We treat this as a successful probe + // because the payment made it all the way to the destination with sufficient liquidity. + let path = path.iter().collect::>(); + score.probe_successful(&path); + }, + Event::PaymentPathSuccessful { path, .. } => { + let path = path.iter().collect::>(); + score.payment_path_successful(&path); + }, + Event::ProbeSuccessful { path, .. } => { + let path = path.iter().collect::>(); + score.probe_successful(&path); + }, + Event::ProbeFailed { path, short_channel_id: Some(scid), .. } => { + let path = path.iter().collect::>(); + score.probe_failed(&path, *scid); + }, + _ => {}, + } +} + macro_rules! define_run_body { ($persister: ident, $chain_monitor: ident, $process_chain_monitor_events: expr, $channel_manager: ident, $process_channel_manager_events: expr, @@ -285,8 +334,14 @@ macro_rules! define_run_body { if $timer_elapsed(&mut last_prune_call, if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER }) { // The network graph must not be pruned while rapid sync completion is pending if let Some(network_graph) = $gossip_sync.prunable_network_graph() { - log_trace!($logger, "Pruning and persisting network graph."); - network_graph.remove_stale_channels_and_tracking(); + #[cfg(feature = "std")] { + log_trace!($logger, "Pruning and persisting network graph."); + network_graph.remove_stale_channels_and_tracking(); + } + #[cfg(not(feature = "std"))] { + log_warn!($logger, "Not pruning network graph, consider enabling `std` or doing so manually with remove_stale_channels_and_tracking_with_time."); + log_trace!($logger, "Persisting network graph."); + } if let Err(e) = $persister.persist_graph(network_graph) { log_error!($logger, "Error: Failed to persist network graph, check your disk and permissions {}", e) @@ -334,6 +389,11 @@ macro_rules! define_run_body { /// future which outputs true, the loop will exit and this function's future will complete. /// /// See [`BackgroundProcessor::start`] for information on which actions this handles. +/// +/// Requires the `futures` feature. Note that while this method is available without the `std` +/// feature, doing so will skip calling [`NetworkGraph::remove_stale_channels_and_tracking`], +/// you should call [`NetworkGraph::remove_stale_channels_and_tracking_with_time`] regularly +/// manually instead. #[cfg(feature = "futures")] pub async fn process_events_async< 'a, @@ -361,16 +421,16 @@ pub async fn process_events_async< PGS: 'static + Deref> + Send + Sync, RGS: 'static + Deref> + Send, UMH: 'static + Deref + Send + Sync, - PM: 'static + Deref> + Send + Sync, + PM: 'static + Deref> + Send + Sync, S: 'static + Deref + Send + Sync, - SC: WriteableScore<'a>, + SC: for<'b> WriteableScore<'b>, SleepFuture: core::future::Future + core::marker::Unpin, Sleeper: Fn(Duration) -> SleepFuture >( persister: PS, event_handler: EventHandler, chain_monitor: M, channel_manager: CM, gossip_sync: GossipSync, peer_manager: PM, logger: L, scorer: Option, sleeper: Sleeper, -) -> Result<(), std::io::Error> +) -> Result<(), io::Error> where CA::Target: 'static + chain::Access, CF::Target: 'static + chain::Filter, @@ -393,10 +453,14 @@ where let async_event_handler = |event| { let network_graph = gossip_sync.network_graph(); let event_handler = &event_handler; + let scorer = &scorer; async move { if let Some(network_graph) = network_graph { handle_network_graph_update(network_graph, &event) } + if let Some(ref scorer) = scorer { + update_scorer(scorer, &event); + } event_handler(event).await; } }; @@ -419,6 +483,7 @@ where }) } +#[cfg(feature = "std")] impl BackgroundProcessor { /// Start a background thread that takes care of responsibilities enumerated in the [top-level /// documentation]. @@ -489,9 +554,9 @@ impl BackgroundProcessor { PGS: 'static + Deref> + Send + Sync, RGS: 'static + Deref> + Send, UMH: 'static + Deref + Send + Sync, - PM: 'static + Deref> + Send + Sync, + PM: 'static + Deref> + Send + Sync, S: 'static + Deref + Send + Sync, - SC: WriteableScore<'a>, + SC: for <'b> WriteableScore<'b>, >( persister: PS, event_handler: EH, chain_monitor: M, channel_manager: CM, gossip_sync: GossipSync, peer_manager: PM, logger: L, scorer: Option, @@ -522,6 +587,9 @@ impl BackgroundProcessor { if let Some(network_graph) = network_graph { handle_network_graph_update(network_graph, &event) } + if let Some(ref scorer) = scorer { + update_scorer(scorer, &event); + } event_handler.handle_event(event); }; define_run_body!(persister, chain_monitor, chain_monitor.process_pending_events(&event_handler), @@ -574,31 +642,35 @@ impl BackgroundProcessor { } } +#[cfg(feature = "std")] impl Drop for BackgroundProcessor { fn drop(&mut self) { self.stop_and_join_thread().unwrap(); } } -#[cfg(test)] +#[cfg(all(feature = "std", test))] mod tests { use bitcoin::blockdata::block::BlockHeader; use bitcoin::blockdata::constants::genesis_block; use bitcoin::blockdata::locktime::PackedLockTime; use bitcoin::blockdata::transaction::{Transaction, TxOut}; use bitcoin::network::constants::Network; + use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1}; use lightning::chain::{BestBlock, Confirm, chainmonitor}; use lightning::chain::channelmonitor::ANTI_REORG_DELAY; - use lightning::chain::keysinterface::{InMemorySigner, Recipient, EntropySource, KeysManager, NodeSigner}; + use lightning::chain::keysinterface::{InMemorySigner, EntropySource, KeysManager}; use lightning::chain::transaction::OutPoint; use lightning::get_event_msg; - use lightning::ln::channelmanager::{BREAKDOWN_TIMEOUT, ChainParameters, ChannelManager, SimpleArcChannelManager}; - use lightning::ln::features::ChannelFeatures; + use lightning::ln::PaymentHash; + use lightning::ln::channelmanager; + use lightning::ln::channelmanager::{BREAKDOWN_TIMEOUT, ChainParameters, MIN_CLTV_EXPIRY_DELTA, PaymentId}; + use lightning::ln::features::{ChannelFeatures, NodeFeatures}; use lightning::ln::msgs::{ChannelMessageHandler, Init}; use lightning::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler}; - use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; - use lightning::routing::router::DefaultRouter; - use lightning::routing::scoring::{ProbabilisticScoringParameters, ProbabilisticScorer}; + use lightning::routing::gossip::{NetworkGraph, NodeId, P2PGossipSync}; + use lightning::routing::router::{DefaultRouter, RouteHop}; + use lightning::routing::scoring::{ChannelUsage, Score}; use lightning::util::config::UserConfig; use lightning::util::events::{Event, MessageSendEventsProvider, MessageSendEvent}; use lightning::util::ser::Writeable; @@ -606,6 +678,7 @@ mod tests { use lightning::util::persist::KVStorePersister; use lightning_invoice::payment::{InvoicePayer, Retry}; use lightning_persister::FilesystemPersister; + use std::collections::VecDeque; use std::fs; use std::path::PathBuf; use std::sync::{Arc, Mutex}; @@ -628,23 +701,25 @@ mod tests { fn disconnect_socket(&mut self) {} } + type ChannelManager = channelmanager::ChannelManager, Arc, Arc, Arc, Arc, Arc, Arc>>, Arc, Arc>>>, Arc>; + type ChainMonitor = chainmonitor::ChainMonitor, Arc, Arc, Arc, Arc>; type PGS = Arc>>, Arc, Arc>>; type RGS = Arc>>, Arc>>; struct Node { - node: Arc>, + node: Arc, p2p_gossip_sync: PGS, rapid_gossip_sync: RGS, - peer_manager: Arc, Arc, IgnoringMessageHandler, Arc, IgnoringMessageHandler>>, + peer_manager: Arc, Arc, IgnoringMessageHandler, Arc, IgnoringMessageHandler, Arc>>, chain_monitor: Arc, persister: Arc, tx_broadcaster: Arc, network_graph: Arc>>, logger: Arc, best_block: BestBlock, - scorer: Arc>>, Arc>>>, + scorer: Arc>, } impl Node { @@ -730,6 +805,128 @@ mod tests { } } + struct TestScorer { + event_expectations: Option>, + } + + #[derive(Debug)] + enum TestResult { + PaymentFailure { path: Vec, short_channel_id: u64 }, + PaymentSuccess { path: Vec }, + ProbeFailure { path: Vec }, + ProbeSuccess { path: Vec }, + } + + impl TestScorer { + fn new() -> Self { + Self { event_expectations: None } + } + + fn expect(&mut self, expectation: TestResult) { + self.event_expectations.get_or_insert_with(|| VecDeque::new()).push_back(expectation); + } + } + + impl lightning::util::ser::Writeable for TestScorer { + fn write(&self, _: &mut W) -> Result<(), lightning::io::Error> { Ok(()) } + } + + impl Score for TestScorer { + fn channel_penalty_msat( + &self, _short_channel_id: u64, _source: &NodeId, _target: &NodeId, _usage: ChannelUsage + ) -> u64 { unimplemented!(); } + + fn payment_path_failed(&mut self, actual_path: &[&RouteHop], actual_short_channel_id: u64) { + if let Some(expectations) = &mut self.event_expectations { + match expectations.pop_front().unwrap() { + TestResult::PaymentFailure { path, short_channel_id } => { + assert_eq!(actual_path, &path.iter().collect::>()[..]); + assert_eq!(actual_short_channel_id, short_channel_id); + }, + TestResult::PaymentSuccess { path } => { + panic!("Unexpected successful payment path: {:?}", path) + }, + TestResult::ProbeFailure { path } => { + panic!("Unexpected probe failure: {:?}", path) + }, + TestResult::ProbeSuccess { path } => { + panic!("Unexpected probe success: {:?}", path) + } + } + } + } + + fn payment_path_successful(&mut self, actual_path: &[&RouteHop]) { + if let Some(expectations) = &mut self.event_expectations { + match expectations.pop_front().unwrap() { + TestResult::PaymentFailure { path, .. } => { + panic!("Unexpected payment path failure: {:?}", path) + }, + TestResult::PaymentSuccess { path } => { + assert_eq!(actual_path, &path.iter().collect::>()[..]); + }, + TestResult::ProbeFailure { path } => { + panic!("Unexpected probe failure: {:?}", path) + }, + TestResult::ProbeSuccess { path } => { + panic!("Unexpected probe success: {:?}", path) + } + } + } + } + + fn probe_failed(&mut self, actual_path: &[&RouteHop], _: u64) { + if let Some(expectations) = &mut self.event_expectations { + match expectations.pop_front().unwrap() { + TestResult::PaymentFailure { path, .. } => { + panic!("Unexpected payment path failure: {:?}", path) + }, + TestResult::PaymentSuccess { path } => { + panic!("Unexpected payment path success: {:?}", path) + }, + TestResult::ProbeFailure { path } => { + assert_eq!(actual_path, &path.iter().collect::>()[..]); + }, + TestResult::ProbeSuccess { path } => { + panic!("Unexpected probe success: {:?}", path) + } + } + } + } + fn probe_successful(&mut self, actual_path: &[&RouteHop]) { + if let Some(expectations) = &mut self.event_expectations { + match expectations.pop_front().unwrap() { + TestResult::PaymentFailure { path, .. } => { + panic!("Unexpected payment path failure: {:?}", path) + }, + TestResult::PaymentSuccess { path } => { + panic!("Unexpected payment path success: {:?}", path) + }, + TestResult::ProbeFailure { path } => { + panic!("Unexpected probe failure: {:?}", path) + }, + TestResult::ProbeSuccess { path } => { + assert_eq!(actual_path, &path.iter().collect::>()[..]); + } + } + } + } + } + + impl Drop for TestScorer { + fn drop(&mut self) { + if std::thread::panicking() { + return; + } + + if let Some(event_expectations) = &self.event_expectations { + if !event_expectations.is_empty() { + panic!("Unsatisfied event expectations: {:?}", event_expectations); + } + } + } + } + fn get_full_filepath(filepath: String, filename: String) -> String { let mut path = PathBuf::from(filepath); path.push(filename); @@ -745,8 +942,7 @@ mod tests { let network = Network::Testnet; let genesis_block = genesis_block(network); let network_graph = Arc::new(NetworkGraph::new(genesis_block.header.block_hash(), logger.clone())); - let params = ProbabilisticScoringParameters::default(); - let scorer = Arc::new(Mutex::new(ProbabilisticScorer::new(params, network_graph.clone(), logger.clone()))); + let scorer = Arc::new(Mutex::new(TestScorer::new())); let seed = [i as u8; 32]; let router = Arc::new(DefaultRouter::new(network_graph.clone(), logger.clone(), seed, scorer.clone())); let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet)); @@ -760,7 +956,7 @@ mod tests { let p2p_gossip_sync = Arc::new(P2PGossipSync::new(network_graph.clone(), Some(chain_source.clone()), logger.clone())); let rapid_gossip_sync = Arc::new(RapidGossipSync::new(network_graph.clone())); let msg_handler = MessageHandler { chan_handler: Arc::new(test_utils::TestChannelMessageHandler::new()), route_handler: Arc::new(test_utils::TestRoutingMessageHandler::new()), onion_message_handler: IgnoringMessageHandler{}}; - let peer_manager = Arc::new(PeerManager::new(msg_handler, keys_manager.get_node_secret(Recipient::Node).unwrap(), 0, &seed, logger.clone(), IgnoringMessageHandler{})); + let peer_manager = Arc::new(PeerManager::new(msg_handler, 0, &seed, logger.clone(), IgnoringMessageHandler{}, keys_manager.clone())); let node = Node { node: manager, p2p_gossip_sync, rapid_gossip_sync, peer_manager, chain_monitor, persister, tx_broadcaster, network_graph, logger, best_block, scorer }; nodes.push(node); } @@ -789,8 +985,8 @@ mod tests { macro_rules! begin_open_channel { ($node_a: expr, $node_b: expr, $channel_value: expr) => {{ $node_a.node.create_channel($node_b.node.get_our_node_id(), $channel_value, 100, 42, None).unwrap(); - $node_b.node.handle_open_channel(&$node_a.node.get_our_node_id(), $node_a.node.init_features(), &get_event_msg!($node_a, MessageSendEvent::SendOpenChannel, $node_b.node.get_our_node_id())); - $node_a.node.handle_accept_channel(&$node_b.node.get_our_node_id(), $node_b.node.init_features(), &get_event_msg!($node_b, MessageSendEvent::SendAcceptChannel, $node_a.node.get_our_node_id())); + $node_b.node.handle_open_channel(&$node_a.node.get_our_node_id(), &get_event_msg!($node_a, MessageSendEvent::SendOpenChannel, $node_b.node.get_our_node_id())); + $node_a.node.handle_accept_channel(&$node_b.node.get_our_node_id(), &get_event_msg!($node_b, MessageSendEvent::SendAcceptChannel, $node_a.node.get_our_node_id())); }} } @@ -1139,10 +1335,130 @@ mod tests { // Initiate the background processors to watch each node. let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir)); - let router = DefaultRouter::new(Arc::clone(&nodes[0].network_graph), Arc::clone(&nodes[0].logger), random_seed_bytes, Arc::clone(&nodes[0].scorer)); + let router = Arc::new(DefaultRouter::new(Arc::clone(&nodes[0].network_graph), Arc::clone(&nodes[0].logger), random_seed_bytes, Arc::clone(&nodes[0].scorer))); let invoice_payer = Arc::new(InvoicePayer::new(Arc::clone(&nodes[0].node), router, Arc::clone(&nodes[0].logger), |_: _| {}, Retry::Attempts(2))); let event_handler = Arc::clone(&invoice_payer); let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].no_gossip_sync(), nodes[0].peer_manager.clone(), nodes[0].logger.clone(), Some(nodes[0].scorer.clone())); assert!(bg_processor.stop().is_ok()); } + + #[test] + fn test_payment_path_scoring() { + // Ensure that we update the scorer when relevant events are processed. In this case, we ensure + // that we update the scorer upon a payment path succeeding (note that the channel must be + // public or else we won't score it). + // Set up a background event handler for FundingGenerationReady events. + let (sender, receiver) = std::sync::mpsc::sync_channel(1); + let event_handler = move |event: Event| match event { + Event::PaymentPathFailed { .. } => sender.send(event).unwrap(), + Event::PaymentPathSuccessful { .. } => sender.send(event).unwrap(), + Event::ProbeSuccessful { .. } => sender.send(event).unwrap(), + Event::ProbeFailed { .. } => sender.send(event).unwrap(), + _ => panic!("Unexpected event: {:?}", event), + }; + + let nodes = create_nodes(1, "test_payment_path_scoring".to_string()); + let data_dir = nodes[0].persister.get_data_dir(); + let persister = Arc::new(Persister::new(data_dir.clone())); + let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].no_gossip_sync(), nodes[0].peer_manager.clone(), nodes[0].logger.clone(), Some(nodes[0].scorer.clone())); + + let scored_scid = 4242; + let secp_ctx = Secp256k1::new(); + let node_1_privkey = SecretKey::from_slice(&[42; 32]).unwrap(); + let node_1_id = PublicKey::from_secret_key(&secp_ctx, &node_1_privkey); + + let path = vec![RouteHop { + pubkey: node_1_id, + node_features: NodeFeatures::empty(), + short_channel_id: scored_scid, + channel_features: ChannelFeatures::empty(), + fee_msat: 0, + cltv_expiry_delta: MIN_CLTV_EXPIRY_DELTA as u32, + }]; + + nodes[0].scorer.lock().unwrap().expect(TestResult::PaymentFailure { path: path.clone(), short_channel_id: scored_scid }); + nodes[0].node.push_pending_event(Event::PaymentPathFailed { + payment_id: None, + payment_hash: PaymentHash([42; 32]), + payment_failed_permanently: false, + network_update: None, + all_paths_failed: true, + path: path.clone(), + short_channel_id: Some(scored_scid), + retry: None, + }); + let event = receiver + .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) + .expect("PaymentPathFailed not handled within deadline"); + match event { + Event::PaymentPathFailed { .. } => {}, + _ => panic!("Unexpected event"), + } + + // Ensure we'll score payments that were explicitly failed back by the destination as + // ProbeSuccess. + nodes[0].scorer.lock().unwrap().expect(TestResult::ProbeSuccess { path: path.clone() }); + nodes[0].node.push_pending_event(Event::PaymentPathFailed { + payment_id: None, + payment_hash: PaymentHash([42; 32]), + payment_failed_permanently: true, + network_update: None, + all_paths_failed: true, + path: path.clone(), + short_channel_id: None, + retry: None, + }); + let event = receiver + .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) + .expect("PaymentPathFailed not handled within deadline"); + match event { + Event::PaymentPathFailed { .. } => {}, + _ => panic!("Unexpected event"), + } + + nodes[0].scorer.lock().unwrap().expect(TestResult::PaymentSuccess { path: path.clone() }); + nodes[0].node.push_pending_event(Event::PaymentPathSuccessful { + payment_id: PaymentId([42; 32]), + payment_hash: None, + path: path.clone(), + }); + let event = receiver + .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) + .expect("PaymentPathSuccessful not handled within deadline"); + match event { + Event::PaymentPathSuccessful { .. } => {}, + _ => panic!("Unexpected event"), + } + + nodes[0].scorer.lock().unwrap().expect(TestResult::ProbeSuccess { path: path.clone() }); + nodes[0].node.push_pending_event(Event::ProbeSuccessful { + payment_id: PaymentId([42; 32]), + payment_hash: PaymentHash([42; 32]), + path: path.clone(), + }); + let event = receiver + .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) + .expect("ProbeSuccessful not handled within deadline"); + match event { + Event::ProbeSuccessful { .. } => {}, + _ => panic!("Unexpected event"), + } + + nodes[0].scorer.lock().unwrap().expect(TestResult::ProbeFailure { path: path.clone() }); + nodes[0].node.push_pending_event(Event::ProbeFailed { + payment_id: PaymentId([42; 32]), + payment_hash: PaymentHash([42; 32]), + path: path.clone(), + short_channel_id: Some(scored_scid), + }); + let event = receiver + .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) + .expect("ProbeFailure not handled within deadline"); + match event { + Event::ProbeFailed { .. } => {}, + _ => panic!("Unexpected event"), + } + + assert!(bg_processor.stop().is_ok()); + } }