X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-background-processor%2Fsrc%2Flib.rs;h=bc42c6eb68be4967479289b637b9722986a03d1e;hb=88c63e9dbb676d42dfa6ee2318e4535af83b31e3;hp=b249303b57a8be1d3476f88d1d422102657370a7;hpb=5f96d1334435e74545670a5dff24078edf749d60;p=rust-lightning diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index b249303b..bc42c6eb 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -241,26 +241,21 @@ fn update_scorer<'a, S: 'static + Deref + Send + Sync, SC: 'a + Wri 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); + 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); + score.probe_successful(path); }, Event::PaymentPathSuccessful { path, .. } => { - let path = path.iter().collect::>(); - score.payment_path_successful(&path); + score.payment_path_successful(path); }, Event::ProbeSuccessful { path, .. } => { - let path = path.iter().collect::>(); - score.probe_successful(&path); + score.probe_successful(path); }, Event::ProbeFailed { path, short_channel_id: Some(scid), .. } => { - let path = path.iter().collect::>(); - score.probe_failed(&path, *scid); + score.probe_failed(path, *scid); }, _ => {}, } @@ -302,6 +297,12 @@ macro_rules! define_run_body { // persistence. $peer_manager.process_events(); + // Exit the loop if the background processor was requested to stop. + if $loop_exit_check { + log_trace!($logger, "Terminating background processor."); + break; + } + // 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 = None; @@ -309,16 +310,17 @@ macro_rules! define_run_body { let updates_available = $await; let await_slow = if $check_slow_await { $timer_elapsed(&mut await_start.unwrap(), 1) } else { false }; - if updates_available { - log_trace!($logger, "Persisting ChannelManager..."); - $persister.persist_manager(&*$channel_manager)?; - log_trace!($logger, "Done persisting ChannelManager."); - } // Exit the loop if the background processor was requested to stop. if $loop_exit_check { log_trace!($logger, "Terminating background processor."); break; } + + if updates_available { + log_trace!($logger, "Persisting ChannelManager..."); + $persister.persist_manager(&*$channel_manager)?; + log_trace!($logger, "Done persisting ChannelManager."); + } if $timer_elapsed(&mut last_freshness_call, FRESHNESS_TIMER) { log_trace!($logger, "Calling ChannelManager's timer_tick_occurred"); $channel_manager.timer_tick_occurred(); @@ -466,7 +468,8 @@ use core::task; /// /// `sleeper` should return a future which completes in the given amount of time and returns a /// boolean indicating whether the background processing should exit. Once `sleeper` returns a -/// future which outputs true, the loop will exit and this function's future will complete. +/// future which outputs `true`, the loop will exit and this function's future will complete. +/// The `sleeper` future is free to return early after it has triggered the exit condition. /// /// See [`BackgroundProcessor::start`] for information on which actions this handles. /// @@ -479,6 +482,87 @@ use core::task; /// 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. +/// +/// For example, in order to process background events in a [Tokio](https://tokio.rs/) task, you +/// could setup `process_events_async` like this: +/// ``` +/// # struct MyPersister {} +/// # impl lightning::util::persist::KVStorePersister for MyPersister { +/// # fn persist(&self, key: &str, object: &W) -> lightning::io::Result<()> { Ok(()) } +/// # } +/// # struct MyEventHandler {} +/// # impl MyEventHandler { +/// # async fn handle_event(&self, _: lightning::events::Event) {} +/// # } +/// # #[derive(Eq, PartialEq, Clone, Hash)] +/// # struct MySocketDescriptor {} +/// # impl lightning::ln::peer_handler::SocketDescriptor for MySocketDescriptor { +/// # fn send_data(&mut self, _data: &[u8], _resume_read: bool) -> usize { 0 } +/// # fn disconnect_socket(&mut self) {} +/// # } +/// # use std::sync::{Arc, Mutex}; +/// # use std::sync::atomic::{AtomicBool, Ordering}; +/// # use lightning_background_processor::{process_events_async, GossipSync}; +/// # type MyBroadcaster = dyn lightning::chain::chaininterface::BroadcasterInterface + Send + Sync; +/// # type MyFeeEstimator = dyn lightning::chain::chaininterface::FeeEstimator + Send + Sync; +/// # type MyNodeSigner = dyn lightning::chain::keysinterface::NodeSigner + Send + Sync; +/// # type MyUtxoLookup = dyn lightning::routing::utxo::UtxoLookup + Send + Sync; +/// # type MyFilter = dyn lightning::chain::Filter + Send + Sync; +/// # type MyLogger = dyn lightning::util::logger::Logger + Send + Sync; +/// # type MyChainMonitor = lightning::chain::chainmonitor::ChainMonitor, Arc, Arc, Arc, Arc>; +/// # type MyPeerManager = lightning::ln::peer_handler::SimpleArcPeerManager; +/// # type MyNetworkGraph = lightning::routing::gossip::NetworkGraph>; +/// # type MyGossipSync = lightning::routing::gossip::P2PGossipSync, Arc, Arc>; +/// # type MyChannelManager = lightning::ln::channelmanager::SimpleArcChannelManager; +/// # type MyScorer = Mutex, Arc>>; +/// +/// # async fn setup_background_processing(my_persister: Arc, my_event_handler: Arc, my_chain_monitor: Arc, my_channel_manager: Arc, my_gossip_sync: Arc, my_logger: Arc, my_scorer: Arc, my_peer_manager: Arc) { +/// let background_persister = Arc::clone(&my_persister); +/// let background_event_handler = Arc::clone(&my_event_handler); +/// let background_chain_mon = Arc::clone(&my_chain_monitor); +/// let background_chan_man = Arc::clone(&my_channel_manager); +/// let background_gossip_sync = GossipSync::p2p(Arc::clone(&my_gossip_sync)); +/// let background_peer_man = Arc::clone(&my_peer_manager); +/// let background_logger = Arc::clone(&my_logger); +/// let background_scorer = Arc::clone(&my_scorer); +/// +/// // Setup the sleeper. +/// let (stop_sender, stop_receiver) = tokio::sync::watch::channel(()); +/// +/// let sleeper = move |d| { +/// let mut receiver = stop_receiver.clone(); +/// Box::pin(async move { +/// tokio::select!{ +/// _ = tokio::time::sleep(d) => false, +/// _ = receiver.changed() => true, +/// } +/// }) +/// }; +/// +/// let mobile_interruptable_platform = false; +/// +/// let handle = tokio::spawn(async move { +/// process_events_async( +/// background_persister, +/// |e| background_event_handler.handle_event(e), +/// background_chain_mon, +/// background_chan_man, +/// background_gossip_sync, +/// background_peer_man, +/// background_logger, +/// Some(background_scorer), +/// sleeper, +/// mobile_interruptable_platform, +/// ) +/// .await +/// .expect("Failed to process events"); +/// }); +/// +/// // Stop the background processing. +/// stop_sender.send(()).unwrap(); +/// handle.await.unwrap(); +/// # } +///``` #[cfg(feature = "futures")] pub async fn process_events_async< 'a, @@ -767,7 +851,7 @@ mod tests { use lightning::ln::msgs::{ChannelMessageHandler, Init}; use lightning::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler}; use lightning::routing::gossip::{NetworkGraph, NodeId, P2PGossipSync}; - use lightning::routing::router::{DefaultRouter, RouteHop}; + use lightning::routing::router::{DefaultRouter, Path, RouteHop}; use lightning::routing::scoring::{ChannelUsage, Score}; use lightning::util::config::UserConfig; use lightning::util::ser::Writeable; @@ -775,7 +859,7 @@ mod tests { use lightning::util::persist::KVStorePersister; use lightning_persister::FilesystemPersister; use std::collections::VecDeque; - use std::fs; + use std::{fs, env}; use std::path::PathBuf; use std::sync::{Arc, Mutex}; use std::sync::mpsc::SyncSender; @@ -910,10 +994,10 @@ mod tests { #[derive(Debug)] enum TestResult { - PaymentFailure { path: Vec, short_channel_id: u64 }, - PaymentSuccess { path: Vec }, - ProbeFailure { path: Vec }, - ProbeSuccess { path: Vec }, + PaymentFailure { path: Path, short_channel_id: u64 }, + PaymentSuccess { path: Path }, + ProbeFailure { path: Path }, + ProbeSuccess { path: Path }, } impl TestScorer { @@ -935,11 +1019,11 @@ mod tests { &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) { + fn payment_path_failed(&mut self, actual_path: &Path, 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_path, &path); assert_eq!(actual_short_channel_id, short_channel_id); }, TestResult::PaymentSuccess { path } => { @@ -955,14 +1039,14 @@ mod tests { } } - fn payment_path_successful(&mut self, actual_path: &[&RouteHop]) { + fn payment_path_successful(&mut self, actual_path: &Path) { 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::>()[..]); + assert_eq!(actual_path, &path); }, TestResult::ProbeFailure { path } => { panic!("Unexpected probe failure: {:?}", path) @@ -974,7 +1058,7 @@ mod tests { } } - fn probe_failed(&mut self, actual_path: &[&RouteHop], _: u64) { + fn probe_failed(&mut self, actual_path: &Path, _: u64) { if let Some(expectations) = &mut self.event_expectations { match expectations.pop_front().unwrap() { TestResult::PaymentFailure { path, .. } => { @@ -984,7 +1068,7 @@ mod tests { panic!("Unexpected payment path success: {:?}", path) }, TestResult::ProbeFailure { path } => { - assert_eq!(actual_path, &path.iter().collect::>()[..]); + assert_eq!(actual_path, &path); }, TestResult::ProbeSuccess { path } => { panic!("Unexpected probe success: {:?}", path) @@ -992,7 +1076,7 @@ mod tests { } } } - fn probe_successful(&mut self, actual_path: &[&RouteHop]) { + fn probe_successful(&mut self, actual_path: &Path) { if let Some(expectations) = &mut self.event_expectations { match expectations.pop_front().unwrap() { TestResult::PaymentFailure { path, .. } => { @@ -1005,7 +1089,7 @@ mod tests { panic!("Unexpected probe failure: {:?}", path) }, TestResult::ProbeSuccess { path } => { - assert_eq!(actual_path, &path.iter().collect::>()[..]); + assert_eq!(actual_path, &path); } } } @@ -1032,20 +1116,22 @@ mod tests { path.to_str().unwrap().to_string() } - fn create_nodes(num_nodes: usize, persist_dir: String) -> Vec { + fn create_nodes(num_nodes: usize, persist_dir: &str) -> (String, Vec) { + let persist_temp_path = env::temp_dir().join(persist_dir); + let persist_dir = persist_temp_path.to_string_lossy().to_string(); + let network = Network::Testnet; let mut nodes = Vec::new(); for i in 0..num_nodes { - let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))}); + let tx_broadcaster = Arc::new(test_utils::TestBroadcaster::new(network)); let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }); let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i))); - let network = Network::Testnet; let genesis_block = genesis_block(network); let network_graph = Arc::new(NetworkGraph::new(network, 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)); - let persister = Arc::new(FilesystemPersister::new(format!("{}_persister_{}", persist_dir, i))); + let persister = Arc::new(FilesystemPersister::new(format!("{}_persister_{}", &persist_dir, i))); let now = Duration::from_secs(genesis_block.header.time as u64); let keys_manager = Arc::new(KeysManager::new(&seed, now.as_secs(), now.subsec_nanos())); let chain_monitor = Arc::new(chainmonitor::ChainMonitor::new(Some(chain_source.clone()), tx_broadcaster.clone(), logger.clone(), fee_estimator.clone(), persister.clone())); @@ -1067,7 +1153,7 @@ mod tests { } } - nodes + (persist_dir, nodes) } macro_rules! open_channel { @@ -1139,7 +1225,7 @@ mod tests { // Test that when a new channel is created, the ChannelManager needs to be re-persisted with // updates. Also test that when new updates are available, the manager signals that it needs // re-persistence and is successfully re-persisted. - let nodes = create_nodes(2, "test_background_processor".to_string()); + let (persist_dir, nodes) = create_nodes(2, "test_background_processor"); // Go through the channel creation process so that each node has something to persist. Since // open_channel consumes events, it must complete before starting BackgroundProcessor to @@ -1177,7 +1263,7 @@ mod tests { } // Check that the initial channel manager data is persisted as expected. - let filepath = get_full_filepath("test_background_processor_persister_0".to_string(), "manager".to_string()); + let filepath = get_full_filepath(format!("{}_persister_0", &persist_dir), "manager".to_string()); check_persisted_data!(nodes[0].node, filepath.clone()); loop { @@ -1194,11 +1280,11 @@ mod tests { } // Check network graph is persisted - let filepath = get_full_filepath("test_background_processor_persister_0".to_string(), "network_graph".to_string()); + let filepath = get_full_filepath(format!("{}_persister_0", &persist_dir), "network_graph".to_string()); check_persisted_data!(nodes[0].network_graph, filepath.clone()); // Check scorer is persisted - let filepath = get_full_filepath("test_background_processor_persister_0".to_string(), "scorer".to_string()); + let filepath = get_full_filepath(format!("{}_persister_0", &persist_dir), "scorer".to_string()); check_persisted_data!(nodes[0].scorer, filepath.clone()); if !std::thread::panicking() { @@ -1211,7 +1297,7 @@ mod tests { // Test that `ChannelManager::timer_tick_occurred` is called every `FRESHNESS_TIMER`, // `ChainMonitor::rebroadcast_pending_claims` is called every `REBROADCAST_TIMER`, and // `PeerManager::timer_tick_occurred` every `PING_TIMER`. - let nodes = create_nodes(1, "test_timer_tick_called".to_string()); + let (_, nodes) = create_nodes(1, "test_timer_tick_called"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir)); let event_handler = |_: _| {}; @@ -1236,7 +1322,7 @@ mod tests { #[test] fn test_channel_manager_persist_error() { // Test that if we encounter an error during manager persistence, the thread panics. - let nodes = create_nodes(2, "test_persist_error".to_string()); + let (_, nodes) = create_nodes(2, "test_persist_error"); open_channel!(nodes[0], nodes[1], 100000); let data_dir = nodes[0].persister.get_data_dir(); @@ -1256,7 +1342,7 @@ mod tests { #[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()); + let (_, nodes) = create_nodes(2, "test_persist_error_sync"); open_channel!(nodes[0], nodes[1], 100000); let data_dir = nodes[0].persister.get_data_dir(); @@ -1284,7 +1370,7 @@ mod tests { #[test] fn test_network_graph_persist_error() { // Test that if we encounter an error during network graph persistence, an error gets returned. - let nodes = create_nodes(2, "test_persist_network_graph_error".to_string()); + let (_, nodes) = create_nodes(2, "test_persist_network_graph_error"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir).with_graph_error(std::io::ErrorKind::Other, "test")); let event_handler = |_: _| {}; @@ -1302,7 +1388,7 @@ mod tests { #[test] fn test_scorer_persist_error() { // Test that if we encounter an error during scorer persistence, an error gets returned. - let nodes = create_nodes(2, "test_persist_scorer_error".to_string()); + let (_, nodes) = create_nodes(2, "test_persist_scorer_error"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir).with_scorer_error(std::io::ErrorKind::Other, "test")); let event_handler = |_: _| {}; @@ -1319,7 +1405,7 @@ mod tests { #[test] fn test_background_event_handling() { - let mut nodes = create_nodes(2, "test_background_event_handling".to_string()); + let (_, mut nodes) = create_nodes(2, "test_background_event_handling"); let channel_value = 100000; let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir.clone())); @@ -1393,7 +1479,7 @@ mod tests { #[test] fn test_scorer_persistence() { - let nodes = create_nodes(2, "test_scorer_persistence".to_string()); + let (_, nodes) = create_nodes(2, "test_scorer_persistence"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir)); let event_handler = |_: _| {}; @@ -1465,7 +1551,7 @@ mod tests { 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 (_, nodes) = create_nodes(2, "test_not_pruning_network_graph_until_graph_sync_completion"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir).with_graph_persistence_notifier(sender)); @@ -1484,7 +1570,7 @@ mod tests { 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 (_, nodes) = create_nodes(2, "test_not_pruning_network_graph_until_graph_sync_completion_async"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir).with_graph_persistence_notifier(sender)); @@ -1533,14 +1619,14 @@ mod tests { 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 { + let path = Path { hops: 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, - }]; + }], blinded_tail: None }; $nodes[0].scorer.lock().unwrap().expect(TestResult::PaymentFailure { path: path.clone(), short_channel_id: scored_scid }); $nodes[0].node.push_pending_event(Event::PaymentPathFailed { @@ -1624,7 +1710,7 @@ mod tests { _ => panic!("Unexpected event: {:?}", event), }; - let nodes = create_nodes(1, "test_payment_path_scoring".to_string()); + let (_, nodes) = create_nodes(1, "test_payment_path_scoring"); let data_dir = nodes[0].persister.get_data_dir(); 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())); @@ -1653,7 +1739,7 @@ mod tests { } }; - let nodes = create_nodes(1, "test_payment_path_scoring_async".to_string()); + let (_, nodes) = create_nodes(1, "test_payment_path_scoring_async"); let data_dir = nodes[0].persister.get_data_dir(); let persister = Arc::new(Persister::new(data_dir));