X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-background-processor%2Fsrc%2Flib.rs;h=541813c7e42c72f68568ec1c397fc531156d158c;hb=7ca37097274d5d2ed66e5f42e9948f71a344681f;hp=4bd5e463f93d5a877d157e9d5d668e30f7ca9808;hpb=153b04833201d1de59104ed2671fafeb2b8ad509;p=rust-lightning diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index 4bd5e463..541813c7 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))] @@ -16,6 +16,9 @@ #[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,17 +26,19 @@ 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}; use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; +use lightning::routing::utxo::UtxoLookup; use lightning::routing::router::Router; -use lightning::routing::scoring::WriteableScore; -use lightning::util::events::{Event, EventHandler, EventsProvider}; +use lightning::routing::scoring::{Score, WriteableScore}; 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; @@ -47,8 +52,8 @@ 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 @@ -73,7 +78,7 @@ use futures_util::{select_biased, future::FutureExt, task}; /// 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 { @@ -111,13 +116,13 @@ const FIRST_NETWORK_PRUNE_TIMER: u64 = 1; /// Either [`P2PGossipSync`] or [`RapidGossipSync`]. pub enum GossipSync< - P: Deref>, + P: Deref>, R: Deref>, G: Deref>, - A: Deref, + U: Deref, L: Deref, > -where A::Target: chain::Access, L::Target: Logger { +where U::Target: UtxoLookup, L::Target: Logger { /// Gossip sync via the lightning peer-to-peer network as defined by BOLT 7. P2P(P), /// Rapid gossip sync from a trusted server. @@ -127,13 +132,13 @@ where A::Target: chain::Access, L::Target: Logger { } impl< - P: Deref>, + P: Deref>, R: Deref>, G: Deref>, - A: Deref, + U: Deref, L: Deref, -> GossipSync -where A::Target: chain::Access, L::Target: Logger { +> GossipSync +where U::Target: UtxoLookup, L::Target: Logger { fn network_graph(&self) -> Option<&G> { match self { GossipSync::P2P(gossip_sync) => Some(gossip_sync.network_graph()), @@ -157,11 +162,11 @@ where A::Target: chain::Access, L::Target: Logger { } } -/// (C-not exported) as the bindings concretize everything and have constructors for us -impl>, G: Deref>, A: Deref, L: Deref> - GossipSync, G, A, L> +/// This is not exported to bindings users as the bindings concretize everything and have constructors for us +impl>, G: Deref>, U: Deref, L: Deref> + GossipSync, G, U, L> where - A::Target: chain::Access, + U::Target: UtxoLookup, L::Target: Logger, { /// Initializes a new [`GossipSync::P2P`] variant. @@ -170,13 +175,13 @@ where } } -/// (C-not exported) as the bindings concretize everything and have constructors for us +/// This is not exported to bindings users as the bindings concretize everything and have constructors for us impl<'a, R: Deref>, G: Deref>, L: Deref> GossipSync< - &P2PGossipSync, + &P2PGossipSync, R, G, - &'a (dyn chain::Access + Send + Sync), + &'a (dyn UtxoLookup + Send + Sync), L, > where @@ -188,13 +193,13 @@ where } } -/// (C-not exported) as the bindings concretize everything and have constructors for us +/// This is not exported to bindings users as the bindings concretize everything and have constructors for us impl<'a, L: Deref> GossipSync< - &P2PGossipSync<&'a NetworkGraph, &'a (dyn chain::Access + Send + Sync), L>, + &P2PGossipSync<&'a NetworkGraph, &'a (dyn UtxoLookup + Send + Sync), L>, &RapidGossipSync<&'a NetworkGraph, L>, &'a NetworkGraph, - &'a (dyn chain::Access + Send + Sync), + &'a (dyn UtxoLookup + Send + Sync), L, > where @@ -209,10 +214,41 @@ where fn handle_network_graph_update( network_graph: &NetworkGraph, event: &Event ) where L::Target: Logger { - if let Event::PaymentPathFailed { ref network_update, .. } = event { - if let Some(network_update) = network_update { - network_graph.handle_network_update(&network_update); - } + if let Event::PaymentPathFailed { + failure: PathFailure::OnPath { network_update: Some(ref upd) }, .. } = event + { + network_graph.handle_network_update(upd); + } +} + +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); + }, + _ => {}, } } @@ -311,9 +347,9 @@ macro_rules! define_run_body { log_error!($logger, "Error: Failed to persist network graph, check your disk and permissions {}", e) } - last_prune_call = $get_timer(NETWORK_PRUNE_TIMER); have_pruned = true; } + last_prune_call = $get_timer(NETWORK_PRUNE_TIMER); } if $timer_elapsed(&mut last_scorer_persist_call, SCORER_PERSIST_TIMER) { @@ -346,6 +382,50 @@ 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 + Unpin, B: Future + Unpin> { + pub a: A, + pub b: B, + } + pub(crate) enum SelectorOutput { + A, B(bool), + } + + impl + Unpin, B: 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(res) => { return Poll::Ready(SelectorOutput::B(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 @@ -361,7 +441,7 @@ macro_rules! define_run_body { #[cfg(feature = "futures")] pub async fn process_events_async< 'a, - CA: 'static + Deref + Send + Sync, + UL: 'static + Deref + Send + Sync, CF: 'static + Deref + Send + Sync, CW: 'static + Deref + Send + Sync, T: 'static + Deref + Send + Sync, @@ -382,21 +462,21 @@ pub async fn process_events_async< PS: 'static + Deref + Send, M: 'static + Deref::Signer, CF, T, F, L, P>> + Send + Sync, CM: 'static + Deref> + Send + Sync, - PGS: 'static + Deref> + Send + Sync, + PGS: 'static + Deref> + Send + Sync, RGS: 'static + Deref> + Send, UMH: '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, + gossip_sync: GossipSync, peer_manager: PM, logger: L, scorer: Option, sleeper: Sleeper, -) -> Result<(), io::Error> +) -> Result<(), lightning::io::Error> where - CA::Target: 'static + chain::Access, + UL::Target: 'static + UtxoLookup, CF::Target: 'static + chain::Filter, CW::Target: 'static + chain::Watch<::Signer>, T::Target: 'static + BroadcasterInterface, @@ -417,10 +497,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; } }; @@ -428,16 +512,20 @@ 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: sleeper(Duration::from_millis(100)), + }; + match fut.await { + SelectorOutput::A => true, + SelectorOutput::B(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() }) @@ -491,7 +579,7 @@ impl BackgroundProcessor { /// [`NetworkGraph::write`]: lightning::routing::gossip::NetworkGraph#impl-Writeable pub fn start< 'a, - CA: 'static + Deref + Send + Sync, + UL: 'static + Deref + Send + Sync, CF: 'static + Deref + Send + Sync, CW: 'static + Deref + Send + Sync, T: 'static + Deref + Send + Sync, @@ -511,18 +599,18 @@ impl BackgroundProcessor { PS: 'static + Deref + Send, M: 'static + Deref::Signer, CF, T, F, L, P>> + Send + Sync, CM: 'static + Deref> + Send + Sync, - PGS: 'static + Deref> + Send + Sync, + PGS: 'static + Deref> + Send + Sync, RGS: 'static + Deref> + Send, UMH: '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, + gossip_sync: GossipSync, peer_manager: PM, logger: L, scorer: Option, ) -> Self where - CA::Target: 'static + chain::Access, + UL::Target: 'static + UtxoLookup, CF::Target: 'static + chain::Filter, CW::Target: 'static + chain::Watch<::Signer>, T::Target: 'static + BroadcasterInterface, @@ -547,6 +635,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), @@ -613,25 +704,28 @@ mod tests { 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, EntropySource, KeysManager}; + use lightning::chain::keysinterface::{InMemorySigner, 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::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}; + 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; use lightning::util::test_utils; 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}; @@ -654,13 +748,15 @@ 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, Arc>>, @@ -670,7 +766,7 @@ mod tests { network_graph: Arc>>, logger: Arc, best_block: BestBlock, - scorer: Arc>>, Arc>>>, + scorer: Arc>, } impl Node { @@ -707,7 +803,7 @@ mod tests { impl Persister { fn new(data_dir: String) -> Self { - let filesystem_persister = FilesystemPersister::new(data_dir.clone()); + let filesystem_persister = FilesystemPersister::new(data_dir); Self { graph_error: None, graph_persistence_notifier: None, manager_error: None, scorer_error: None, filesystem_persister } } @@ -756,6 +852,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); @@ -770,9 +988,8 @@ mod tests { 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(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 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)); @@ -780,11 +997,11 @@ mod tests { 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())); - let best_block = BestBlock::from_genesis(network); + let best_block = BestBlock::from_network(network); let params = ChainParameters { network, best_block }; let manager = Arc::new(ChannelManager::new(fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster.clone(), router.clone(), logger.clone(), keys_manager.clone(), keys_manager.clone(), keys_manager.clone(), UserConfig::default(), params)); 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 rapid_gossip_sync = Arc::new(RapidGossipSync::new(network_graph.clone(), logger.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, 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 }; @@ -793,8 +1010,8 @@ mod tests { for i in 0..num_nodes { for j in (i+1)..num_nodes { - nodes[i].node.peer_connected(&nodes[j].node.get_our_node_id(), &Init { features: nodes[j].node.init_features(), remote_network_address: None }).unwrap(); - nodes[j].node.peer_connected(&nodes[i].node.get_our_node_id(), &Init { features: nodes[i].node.init_features(), remote_network_address: None }).unwrap(); + nodes[i].node.peer_connected(&nodes[j].node.get_our_node_id(), &Init { features: nodes[j].node.init_features(), remote_network_address: None }, true).unwrap(); + nodes[j].node.peer_connected(&nodes[i].node.get_our_node_id(), &Init { features: nodes[i].node.init_features(), remote_network_address: None }, false).unwrap(); } } @@ -841,7 +1058,10 @@ mod tests { ($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())); + 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); }} } @@ -1055,7 +1275,7 @@ mod tests { // Set up a background event handler for SpendableOutputs events. let (sender, receiver) = std::sync::mpsc::sync_channel(1); let event_handler = move |event: Event| match event { - Event::SpendableOutputs { .. } => sender.send(event.clone()).unwrap(), + Event::SpendableOutputs { .. } => sender.send(event).unwrap(), Event::ChannelReady { .. } => {}, Event::ChannelClosed { .. } => {}, _ => panic!("Unexpected event: {:?}", event), @@ -1103,7 +1323,7 @@ mod tests { 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.clone()).with_graph_persistence_notifier(sender)); + 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()) @@ -1141,12 +1361,12 @@ mod tests { 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(&initialization_input[..]).unwrap(); + 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); - let _ = receiver + receiver .recv_timeout(Duration::from_secs(super::FIRST_NETWORK_PRUNE_TIMER * 5)) .expect("Network graph not pruned within deadline"); @@ -1157,18 +1377,118 @@ mod tests { } #[test] - fn test_invoice_payer() { - let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); - let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let nodes = create_nodes(2, "test_invoice_payer".to_string()); + 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), + }; - // Initiate the background processors to watch each node. + 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)); - 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())); + + 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"), + } + + // 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"), + } + + 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, + 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()); } }