X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-background-processor%2Fsrc%2Flib.rs;h=21e9d419471ee6cc5fb619a0480642600096513c;hb=1ceb41e08b2d76b23d2505a10a88db8d840895ca;hp=1d0d787388e43d8e5d2564cd54f16ebff4b127c7;hpb=b0bf50fa2493e5364511eb781db9772a06e140f9;p=rust-lightning diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index 1d0d7873..21e9d419 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -7,7 +7,7 @@ #![deny(private_intra_doc_links)] #![deny(missing_docs)] -#![deny(unsafe_code)] +#![cfg_attr(not(feature = "futures"), deny(unsafe_code))] #![cfg_attr(docsrs, feature(doc_auto_cfg))] @@ -26,6 +26,9 @@ use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use lightning::chain::chainmonitor::{ChainMonitor, Persist}; use lightning::chain::keysinterface::{EntropySource, NodeSigner, SignerProvider}; +use lightning::events::{Event, PathFailure}; +#[cfg(feature = "std")] +use lightning::events::{EventHandler, EventsProvider}; use lightning::ln::channelmanager::ChannelManager; use lightning::ln::msgs::{ChannelMessageHandler, OnionMessageHandler, RoutingMessageHandler}; use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor}; @@ -33,11 +36,10 @@ use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; use lightning::routing::utxo::UtxoLookup; use lightning::routing::router::Router; use lightning::routing::scoring::{Score, WriteableScore}; -use lightning::util::events::{Event, PathFailure}; -#[cfg(feature = "std")] -use lightning::util::events::{EventHandler, EventsProvider}; use lightning::util::logger::Logger; use lightning::util::persist::Persister; +#[cfg(feature = "std")] +use lightning::util::wakers::Sleeper; use lightning_rapid_gossip_sync::RapidGossipSync; use core::ops::Deref; @@ -52,8 +54,6 @@ 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; @@ -80,7 +80,7 @@ use alloc::vec::Vec; /// unilateral chain closure fees are at risk. /// /// [`ChannelMonitor`]: lightning::chain::channelmonitor::ChannelMonitor -/// [`Event`]: lightning::util::events::Event +/// [`Event`]: lightning::events::Event #[cfg(feature = "std")] #[must_use = "BackgroundProcessor will immediately stop on drop. It should be stored until shutdown."] pub struct BackgroundProcessor { @@ -116,6 +116,13 @@ const FIRST_NETWORK_PRUNE_TIMER: u64 = 60; #[cfg(test)] const FIRST_NETWORK_PRUNE_TIMER: u64 = 1; +#[cfg(feature = "futures")] +/// core::cmp::min is not currently const, so we define a trivial (and equivalent) replacement +const fn min_u64(a: u64, b: u64) -> u64 { if a < b { a } else { b } } +#[cfg(feature = "futures")] +const FASTEST_TIMER: u64 = min_u64(min_u64(FRESHNESS_TIMER, PING_TIMER), + min_u64(SCORER_PERSIST_TIMER, FIRST_NETWORK_PRUNE_TIMER)); + /// Either [`P2PGossipSync`] or [`RapidGossipSync`]. pub enum GossipSync< P: Deref>, @@ -258,7 +265,8 @@ macro_rules! define_run_body { ($persister: ident, $chain_monitor: ident, $process_chain_monitor_events: expr, $channel_manager: ident, $process_channel_manager_events: expr, $gossip_sync: ident, $peer_manager: ident, $logger: ident, $scorer: ident, - $loop_exit_check: expr, $await: expr, $get_timer: expr, $timer_elapsed: expr) + $loop_exit_check: expr, $await: expr, $get_timer: expr, $timer_elapsed: expr, + $check_slow_await: expr) => { { log_trace!($logger, "Calling ChannelManager's timer_tick_occurred on startup"); $channel_manager.timer_tick_occurred(); @@ -288,9 +296,10 @@ macro_rules! define_run_body { // We wait up to 100ms, but track how long it takes to detect being put to sleep, // see `await_start`'s use below. - let mut await_start = $get_timer(1); + let mut await_start = None; + if $check_slow_await { await_start = Some($get_timer(1)); } let updates_available = $await; - let await_slow = $timer_elapsed(&mut await_start, 1); + let await_slow = if $check_slow_await { $timer_elapsed(&mut await_start.unwrap(), 1) } else { false }; if updates_available { log_trace!($logger, "Persisting ChannelManager..."); @@ -384,6 +393,59 @@ macro_rules! define_run_body { } } } +#[cfg(feature = "futures")] +pub(crate) mod futures_util { + use core::future::Future; + use core::task::{Poll, Waker, RawWaker, RawWakerVTable}; + use core::pin::Pin; + use core::marker::Unpin; + pub(crate) struct Selector< + A: Future + Unpin, B: Future + Unpin, C: Future + Unpin + > { + pub a: A, + pub b: B, + pub c: C, + } + pub(crate) enum SelectorOutput { + A, B, C(bool), + } + + impl< + A: Future + Unpin, B: Future + Unpin, C: Future + Unpin + > Future for Selector { + type Output = SelectorOutput; + fn poll(mut self: Pin<&mut Self>, ctx: &mut core::task::Context<'_>) -> Poll { + match Pin::new(&mut self.a).poll(ctx) { + Poll::Ready(()) => { return Poll::Ready(SelectorOutput::A); }, + Poll::Pending => {}, + } + match Pin::new(&mut self.b).poll(ctx) { + Poll::Ready(()) => { return Poll::Ready(SelectorOutput::B); }, + Poll::Pending => {}, + } + match Pin::new(&mut self.c).poll(ctx) { + Poll::Ready(res) => { return Poll::Ready(SelectorOutput::C(res)); }, + Poll::Pending => {}, + } + Poll::Pending + } + } + + // If we want to poll a future without an async context to figure out if it has completed or + // not without awaiting, we need a Waker, which needs a vtable...we fill it with dummy values + // but sadly there's a good bit of boilerplate here. + fn dummy_waker_clone(_: *const ()) -> RawWaker { RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE) } + fn dummy_waker_action(_: *const ()) { } + + const DUMMY_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new( + dummy_waker_clone, dummy_waker_action, dummy_waker_action, dummy_waker_action); + pub(crate) fn dummy_waker() -> Waker { unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE)) } } +} +#[cfg(feature = "futures")] +use futures_util::{Selector, SelectorOutput, dummy_waker}; +#[cfg(feature = "futures")] +use core::task; + /// Processes background events in a future. /// /// `sleeper` should return a future which completes in the given amount of time and returns a @@ -396,6 +458,11 @@ macro_rules! define_run_body { /// 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. +/// +/// The `mobile_interruptable_platform` flag should be set if we're currently running on a +/// mobile device, where we may need to check for interruption of the application regularly. If you +/// are unsure, you should set the flag, as the performance impact of it is minimal unless there +/// are hundreds or thousands of simultaneous process calls running. #[cfg(feature = "futures")] pub async fn process_events_async< 'a, @@ -431,7 +498,7 @@ pub async fn process_events_async< >( persister: PS, event_handler: EventHandler, chain_monitor: M, channel_manager: CM, gossip_sync: GossipSync, peer_manager: PM, logger: L, scorer: Option, - sleeper: Sleeper, + sleeper: Sleeper, mobile_interruptable_platform: bool, ) -> Result<(), lightning::io::Error> where UL::Target: 'static + UtxoLookup, @@ -451,7 +518,7 @@ where UMH::Target: 'static + CustomMessageHandler, PS::Target: 'static + Persister<'a, CW, T, ES, NS, SP, F, R, L, SC>, { - let mut should_break = true; + let mut should_break = false; let async_event_handler = |event| { let network_graph = gossip_sync.network_graph(); let event_handler = &event_handler; @@ -470,19 +537,28 @@ where chain_monitor, chain_monitor.process_pending_events_async(async_event_handler).await, channel_manager, channel_manager.process_pending_events_async(async_event_handler).await, gossip_sync, peer_manager, logger, scorer, should_break, { - select_biased! { - _ = channel_manager.get_persistable_update_future().fuse() => true, - exit = sleeper(Duration::from_millis(100)).fuse() => { + let fut = Selector { + a: channel_manager.get_persistable_update_future(), + b: chain_monitor.get_update_future(), + c: sleeper(if mobile_interruptable_platform { Duration::from_millis(100) } else { Duration::from_secs(FASTEST_TIMER) }), + }; + match fut.await { + SelectorOutput::A => true, + SelectorOutput::B => false, + SelectorOutput::C(exit) => { should_break = exit; false } } }, |t| sleeper(Duration::from_secs(t)), |fut: &mut SleepFuture, _| { - let mut waker = task::noop_waker(); + let mut waker = dummy_waker(); let mut ctx = task::Context::from_waker(&mut waker); - core::pin::Pin::new(fut).poll(&mut ctx).is_ready() - }) + match core::pin::Pin::new(fut).poll(&mut ctx) { + task::Poll::Ready(exit) => { should_break = exit; true }, + task::Poll::Pending => false, + } + }, mobile_interruptable_platform) } #[cfg(feature = "std")] @@ -597,8 +673,11 @@ impl BackgroundProcessor { define_run_body!(persister, chain_monitor, chain_monitor.process_pending_events(&event_handler), channel_manager, channel_manager.process_pending_events(&event_handler), gossip_sync, peer_manager, logger, scorer, stop_thread.load(Ordering::Acquire), - channel_manager.await_persistable_update_timeout(Duration::from_millis(100)), - |_| Instant::now(), |time: &Instant, dur| time.elapsed().as_secs() > dur) + Sleeper::from_two_futures( + channel_manager.get_persistable_update_future(), + chain_monitor.get_update_future() + ).wait_timeout(Duration::from_millis(100)), + |_| Instant::now(), |time: &Instant, dur| time.elapsed().as_secs() > dur, false) }); Self { stop_thread: stop_thread_clone, thread_handle: Some(handle) } } @@ -663,7 +742,8 @@ mod tests { use lightning::chain::channelmonitor::ANTI_REORG_DELAY; use lightning::chain::keysinterface::{InMemorySigner, KeysManager}; use lightning::chain::transaction::OutPoint; - use lightning::get_event_msg; + use lightning::events::{Event, PathFailure, MessageSendEventsProvider, MessageSendEvent}; + use lightning::{get_event_msg, get_event}; use lightning::ln::PaymentHash; use lightning::ln::channelmanager; use lightning::ln::channelmanager::{BREAKDOWN_TIMEOUT, ChainParameters, MIN_CLTV_EXPIRY_DELTA, PaymentId}; @@ -674,7 +754,6 @@ mod tests { use lightning::routing::router::{DefaultRouter, RouteHop}; use lightning::routing::scoring::{ChannelUsage, Score}; use lightning::util::config::UserConfig; - use lightning::util::events::{Event, PathFailure, MessageSendEventsProvider, MessageSendEvent}; use lightning::util::ser::Writeable; use lightning::util::test_utils; use lightning::util::persist::KVStorePersister; @@ -978,7 +1057,11 @@ mod tests { let events = $node_a.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); let (temporary_channel_id, tx) = handle_funding_generation_ready!(events[0], $channel_value); - end_open_channel!($node_a, $node_b, temporary_channel_id, tx); + $node_a.node.funding_transaction_generated(&temporary_channel_id, &$node_b.node.get_our_node_id(), tx.clone()).unwrap(); + $node_b.node.handle_funding_created(&$node_a.node.get_our_node_id(), &get_event_msg!($node_a, MessageSendEvent::SendFundingCreated, $node_b.node.get_our_node_id())); + get_event!($node_b, Event::ChannelPending); + $node_a.node.handle_funding_signed(&$node_b.node.get_our_node_id(), &get_event_msg!($node_b, MessageSendEvent::SendFundingSigned, $node_a.node.get_our_node_id())); + get_event!($node_a, Event::ChannelPending); tx }} } @@ -1008,14 +1091,6 @@ mod tests { }} } - macro_rules! end_open_channel { - ($node_a: expr, $node_b: expr, $temporary_channel_id: expr, $tx: expr) => {{ - $node_a.node.funding_transaction_generated(&$temporary_channel_id, &$node_b.node.get_our_node_id(), $tx.clone()).unwrap(); - $node_b.node.handle_funding_created(&$node_a.node.get_our_node_id(), &get_event_msg!($node_a, MessageSendEvent::SendFundingCreated, $node_b.node.get_our_node_id())); - $node_a.node.handle_funding_signed(&$node_b.node.get_our_node_id(), &get_event_msg!($node_b, MessageSendEvent::SendFundingSigned, $node_a.node.get_our_node_id())); - }} - } - fn confirm_transaction_depth(node: &mut Node, tx: &Transaction, depth: u32) { for i in 1..=depth { let prev_blockhash = node.best_block.block_hash(); @@ -1107,7 +1182,9 @@ mod tests { let filepath = get_full_filepath("test_background_processor_persister_0".to_string(), "scorer".to_string()); check_persisted_data!(nodes[0].scorer, filepath.clone()); - assert!(bg_processor.stop().is_ok()); + if !std::thread::panicking() { + bg_processor.stop().unwrap(); + } } #[test] @@ -1129,7 +1206,9 @@ mod tests { } } - assert!(bg_processor.stop().is_ok()); + if !std::thread::panicking() { + bg_processor.stop().unwrap(); + } } #[test] @@ -1151,6 +1230,35 @@ mod tests { } } + #[tokio::test] + #[cfg(feature = "futures")] + async fn test_channel_manager_persist_error_async() { + // Test that if we encounter an error during manager persistence, the thread panics. + let nodes = create_nodes(2, "test_persist_error_sync".to_string()); + open_channel!(nodes[0], nodes[1], 100000); + + let data_dir = nodes[0].persister.get_data_dir(); + let persister = Arc::new(Persister::new(data_dir).with_manager_error(std::io::ErrorKind::Other, "test")); + + let bp_future = super::process_events_async( + persister, |_: _| {async {}}, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), + nodes[0].rapid_gossip_sync(), nodes[0].peer_manager.clone(), nodes[0].logger.clone(), + Some(nodes[0].scorer.clone()), move |dur: Duration| { + Box::pin(async move { + tokio::time::sleep(dur).await; + false // Never exit + }) + }, false, + ); + match bp_future.await { + Ok(_) => panic!("Expected error persisting manager"), + Err(e) => { + assert_eq!(e.kind(), std::io::ErrorKind::Other); + assert_eq!(e.get_ref().unwrap().to_string(), "test"); + }, + } + } + #[test] fn test_network_graph_persist_error() { // Test that if we encounter an error during network graph persistence, an error gets returned. @@ -1195,9 +1303,11 @@ mod tests { let persister = Arc::new(Persister::new(data_dir.clone())); // Set up a background event handler for FundingGenerationReady events. - let (sender, receiver) = std::sync::mpsc::sync_channel(1); + let (funding_generation_send, funding_generation_recv) = std::sync::mpsc::sync_channel(1); + let (channel_pending_send, channel_pending_recv) = std::sync::mpsc::sync_channel(1); let event_handler = move |event: Event| match event { - Event::FundingGenerationReady { .. } => sender.send(handle_funding_generation_ready!(event, channel_value)).unwrap(), + Event::FundingGenerationReady { .. } => funding_generation_send.send(handle_funding_generation_ready!(event, channel_value)).unwrap(), + Event::ChannelPending { .. } => channel_pending_send.send(()).unwrap(), Event::ChannelReady { .. } => {}, _ => panic!("Unexpected event: {:?}", event), }; @@ -1206,10 +1316,15 @@ mod tests { // Open a channel and check that the FundingGenerationReady event was handled. begin_open_channel!(nodes[0], nodes[1], channel_value); - let (temporary_channel_id, funding_tx) = receiver + let (temporary_channel_id, funding_tx) = funding_generation_recv .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) .expect("FundingGenerationReady not handled within deadline"); - end_open_channel!(nodes[0], nodes[1], temporary_channel_id, funding_tx); + nodes[0].node.funding_transaction_generated(&temporary_channel_id, &nodes[1].node.get_our_node_id(), funding_tx.clone()).unwrap(); + nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id())); + get_event!(nodes[1], Event::ChannelPending); + nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id())); + let _ = channel_pending_recv.recv_timeout(Duration::from_secs(EVENT_DEADLINE)) + .expect("ChannelPending not handled within deadline"); // Confirm the funding transaction. confirm_transaction(&mut nodes[0], &funding_tx); @@ -1221,7 +1336,9 @@ mod tests { nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_funding); let _bs_channel_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); - assert!(bg_processor.stop().is_ok()); + if !std::thread::panicking() { + bg_processor.stop().unwrap(); + } // Set up a background event handler for SpendableOutputs events. let (sender, receiver) = std::sync::mpsc::sync_channel(1); @@ -1247,7 +1364,9 @@ mod tests { _ => panic!("Unexpected event: {:?}", event), } - assert!(bg_processor.stop().is_ok()); + if !std::thread::panicking() { + bg_processor.stop().unwrap(); + } } #[test] @@ -1266,73 +1385,213 @@ mod tests { } } - assert!(bg_processor.stop().is_ok()); + if !std::thread::panicking() { + bg_processor.stop().unwrap(); + } + } + + macro_rules! do_test_not_pruning_network_graph_until_graph_sync_completion { + ($nodes: expr, $receive: expr, $sleep: expr) => { + let features = ChannelFeatures::empty(); + $nodes[0].network_graph.add_channel_from_partial_announcement( + 42, 53, features, $nodes[0].node.get_our_node_id(), $nodes[1].node.get_our_node_id() + ).expect("Failed to update channel from partial announcement"); + let original_graph_description = $nodes[0].network_graph.to_string(); + assert!(original_graph_description.contains("42: features: 0000, node_one:")); + assert_eq!($nodes[0].network_graph.read_only().channels().len(), 1); + + loop { + $sleep; + let log_entries = $nodes[0].logger.lines.lock().unwrap(); + let loop_counter = "Calling ChannelManager's timer_tick_occurred".to_string(); + if *log_entries.get(&("lightning_background_processor".to_string(), loop_counter)) + .unwrap_or(&0) > 1 + { + // Wait until the loop has gone around at least twice. + break + } + } + + let initialization_input = vec![ + 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247, + 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218, + 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251, + 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125, + 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136, + 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106, + 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138, + 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175, + 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128, + 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68, + 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 2, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232, + 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0, + 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192, + ]; + $nodes[0].rapid_gossip_sync.update_network_graph_no_std(&initialization_input[..], Some(1642291930)).unwrap(); + + // this should have added two channels + assert_eq!($nodes[0].network_graph.read_only().channels().len(), 3); + + $receive.expect("Network graph not pruned within deadline"); + + // all channels should now be pruned + assert_eq!($nodes[0].network_graph.read_only().channels().len(), 0); + } } #[test] fn test_not_pruning_network_graph_until_graph_sync_completion() { + let (sender, receiver) = std::sync::mpsc::sync_channel(1); + let nodes = create_nodes(2, "test_not_pruning_network_graph_until_graph_sync_completion".to_string()); let data_dir = nodes[0].persister.get_data_dir(); - let (sender, receiver) = std::sync::mpsc::sync_channel(1); let persister = Arc::new(Persister::new(data_dir).with_graph_persistence_notifier(sender)); - let network_graph = nodes[0].network_graph.clone(); - let features = ChannelFeatures::empty(); - network_graph.add_channel_from_partial_announcement(42, 53, features, nodes[0].node.get_our_node_id(), nodes[1].node.get_our_node_id()) - .expect("Failed to update channel from partial announcement"); - let original_graph_description = network_graph.to_string(); - assert!(original_graph_description.contains("42: features: 0000, node_one:")); - assert_eq!(network_graph.read_only().channels().len(), 1); let event_handler = |_: _| {}; let background_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].rapid_gossip_sync(), nodes[0].peer_manager.clone(), nodes[0].logger.clone(), Some(nodes[0].scorer.clone())); - loop { - let log_entries = nodes[0].logger.lines.lock().unwrap(); - let loop_counter = "Calling ChannelManager's timer_tick_occurred".to_string(); - if *log_entries.get(&("lightning_background_processor".to_string(), loop_counter)) - .unwrap_or(&0) > 1 - { - // Wait until the loop has gone around at least twice. - break + do_test_not_pruning_network_graph_until_graph_sync_completion!(nodes, + receiver.recv_timeout(Duration::from_secs(super::FIRST_NETWORK_PRUNE_TIMER * 5)), + std::thread::sleep(Duration::from_millis(1))); + + background_processor.stop().unwrap(); + } + + #[tokio::test] + #[cfg(feature = "futures")] + async fn test_not_pruning_network_graph_until_graph_sync_completion_async() { + let (sender, receiver) = std::sync::mpsc::sync_channel(1); + + let nodes = create_nodes(2, "test_not_pruning_network_graph_until_graph_sync_completion_async".to_string()); + let data_dir = nodes[0].persister.get_data_dir(); + let persister = Arc::new(Persister::new(data_dir).with_graph_persistence_notifier(sender)); + + let (exit_sender, exit_receiver) = tokio::sync::watch::channel(()); + let bp_future = super::process_events_async( + persister, |_: _| {async {}}, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), + nodes[0].rapid_gossip_sync(), nodes[0].peer_manager.clone(), nodes[0].logger.clone(), + Some(nodes[0].scorer.clone()), move |dur: Duration| { + let mut exit_receiver = exit_receiver.clone(); + Box::pin(async move { + tokio::select! { + _ = tokio::time::sleep(dur) => false, + _ = exit_receiver.changed() => true, + } + }) + }, false, + ); + // TODO: Drop _local and simply spawn after #2003 + let local_set = tokio::task::LocalSet::new(); + local_set.spawn_local(bp_future); + local_set.spawn_local(async move { + do_test_not_pruning_network_graph_until_graph_sync_completion!(nodes, { + let mut i = 0; + loop { + tokio::time::sleep(Duration::from_secs(super::FIRST_NETWORK_PRUNE_TIMER)).await; + if let Ok(()) = receiver.try_recv() { break Ok::<(), ()>(()); } + assert!(i < 5); + i += 1; + } + }, tokio::time::sleep(Duration::from_millis(1)).await); + exit_sender.send(()).unwrap(); + }); + local_set.await; + } + + macro_rules! do_test_payment_path_scoring { + ($nodes: expr, $receive: expr) => { + // 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). + // A background event handler for FundingGenerationReady events must be hooked up to a + // running background processor. + 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, + failure: PathFailure::OnPath { network_update: None }, + path: path.clone(), + short_channel_id: Some(scored_scid), + }); + let event = $receive.expect("PaymentPathFailed not handled within deadline"); + match event { + Event::PaymentPathFailed { .. } => {}, + _ => panic!("Unexpected event"), } - } - let initialization_input = vec![ - 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247, - 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218, - 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251, - 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125, - 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136, - 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106, - 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138, - 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175, - 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128, - 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68, - 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 2, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232, - 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0, - 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192, - ]; - nodes[0].rapid_gossip_sync.update_network_graph_no_std(&initialization_input[..], Some(1642291930)).unwrap(); - - // this should have added two channels - assert_eq!(network_graph.read_only().channels().len(), 3); - - receiver - .recv_timeout(Duration::from_secs(super::FIRST_NETWORK_PRUNE_TIMER * 5)) - .expect("Network graph not pruned within deadline"); + // 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, + failure: PathFailure::OnPath { network_update: None }, + path: path.clone(), + short_channel_id: None, + }); + let event = $receive.expect("PaymentPathFailed not handled within deadline"); + match event { + Event::PaymentPathFailed { .. } => {}, + _ => panic!("Unexpected event"), + } - background_processor.stop().unwrap(); + $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 = $receive.expect("PaymentPathSuccessful not handled within deadline"); + match event { + Event::PaymentPathSuccessful { .. } => {}, + _ => panic!("Unexpected event"), + } - // all channels should now be pruned - assert_eq!(network_graph.read_only().channels().len(), 0); + $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 = $receive.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, + short_channel_id: Some(scored_scid), + }); + let event = $receive.expect("ProbeFailure not handled within deadline"); + match event { + Event::ProbeFailed { .. } => {}, + _ => panic!("Unexpected event"), + } + } } #[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(), @@ -1347,99 +1606,56 @@ mod tests { let persister = Arc::new(Persister::new(data_dir)); 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, - failure: PathFailure::OnPath { network_update: None }, - path: path.clone(), - short_channel_id: Some(scored_scid), - }); - let event = receiver - .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) - .expect("PaymentPathFailed not handled within deadline"); - match event { - Event::PaymentPathFailed { .. } => {}, - _ => panic!("Unexpected event"), - } + do_test_payment_path_scoring!(nodes, receiver.recv_timeout(Duration::from_secs(EVENT_DEADLINE))); - // 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, - failure: PathFailure::OnPath { network_update: None }, - path: path.clone(), - short_channel_id: None, - }); - let event = receiver - .recv_timeout(Duration::from_secs(EVENT_DEADLINE)) - .expect("PaymentPathFailed not handled within deadline"); - match event { - Event::PaymentPathFailed { .. } => {}, - _ => panic!("Unexpected event"), + if !std::thread::panicking() { + bg_processor.stop().unwrap(); } + } - 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"), - } + #[tokio::test] + #[cfg(feature = "futures")] + async fn test_payment_path_scoring_async() { + let (sender, mut receiver) = tokio::sync::mpsc::channel(1); + let event_handler = move |event: Event| { + let sender_ref = sender.clone(); + async move { + match event { + Event::PaymentPathFailed { .. } => { sender_ref.send(event).await.unwrap() }, + Event::PaymentPathSuccessful { .. } => { sender_ref.send(event).await.unwrap() }, + Event::ProbeSuccessful { .. } => { sender_ref.send(event).await.unwrap() }, + Event::ProbeFailed { .. } => { sender_ref.send(event).await.unwrap() }, + _ => panic!("Unexpected event: {:?}", 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"), - } + let nodes = create_nodes(1, "test_payment_path_scoring_async".to_string()); + let data_dir = nodes[0].persister.get_data_dir(); + let persister = Arc::new(Persister::new(data_dir)); - 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, - short_channel_id: Some(scored_scid), + let (exit_sender, exit_receiver) = tokio::sync::watch::channel(()); + + let bp_future = super::process_events_async( + 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()), move |dur: Duration| { + let mut exit_receiver = exit_receiver.clone(); + Box::pin(async move { + tokio::select! { + _ = tokio::time::sleep(dur) => false, + _ = exit_receiver.changed() => true, + } + }) + }, false, + ); + // TODO: Drop _local and simply spawn after #2003 + let local_set = tokio::task::LocalSet::new(); + local_set.spawn_local(bp_future); + local_set.spawn_local(async move { + do_test_payment_path_scoring!(nodes, receiver.recv().await); + exit_sender.send(()).unwrap(); }); - 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()); + local_set.await; } }