Implement scorer event handling in DefaultRouter

Author: jurvis

lightning-background-processor/src/lib.rs

@@ -1037,7 +1037,7 @@ 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);
+		let router = 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].scorer), 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()));

lightning-invoice/src/payment.rs

@@ -674,13 +674,8 @@ where
 
 		match event {
 			Event::PaymentPathFailed {
-				payment_id, payment_hash, rejected_by_dest, path, short_channel_id, retry, ..
+				payment_id, payment_hash, rejected_by_dest, retry, ..
 			} => {
-				if let Some(short_channel_id) = short_channel_id {
-					let path = path.iter().collect::<Vec<_>>();
-					self.scorer.lock().payment_path_failed(&path, *short_channel_id);
-				}
-
 				if payment_id.is_none() {
 					log_trace!(self.logger, "Payment {} has no id; not retrying", log_bytes!(payment_hash.0));
 				} else if *rejected_by_dest {
@@ -699,29 +694,13 @@ where
 			Event::PaymentFailed { payment_hash, .. } => {
 				self.remove_cached_payment(&payment_hash);
 			},
-			Event::PaymentPathSuccessful { path, .. } => {
-				let path = path.iter().collect::<Vec<_>>();
-				self.scorer.lock().payment_path_successful(&path);
-			},
 			Event::PaymentSent { payment_hash, .. } => {
 				let mut payment_cache = self.payment_cache.lock().unwrap();
 				let attempts = payment_cache
 					.remove(payment_hash)
 					.map_or(1, |payment_info| payment_info.attempts.count + 1);
 				log_trace!(self.logger, "Payment {} succeeded (attempts: {})", log_bytes!(payment_hash.0), attempts);
 			},
-			Event::ProbeSuccessful { payment_hash, path, .. } => {
-				log_trace!(self.logger, "Probe payment {} of {}msat was successful", log_bytes!(payment_hash.0), path.last().unwrap().fee_msat);
-				let path = path.iter().collect::<Vec<_>>();
-				self.scorer.lock().probe_successful(&path);
-			},
-			Event::ProbeFailed { payment_hash, path, short_channel_id, .. } => {
-				if let Some(short_channel_id) = short_channel_id {
-					log_trace!(self.logger, "Probe payment {} of {}msat failed at channel {}", log_bytes!(payment_hash.0), path.last().unwrap().fee_msat, *short_channel_id);
-					let path = path.iter().collect::<Vec<_>>();
-					self.scorer.lock().probe_failed(&path, *short_channel_id);
-				}
-			},
 			_ => {},
 		}
 

lightning-invoice/src/utils.rs

@@ -22,6 +22,7 @@ use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
 use core::ops::Deref;
 use core::time::Duration;
+use lightning::util::events::{Event, EventHandler};
 use sync::Mutex;
 
 #[cfg(feature = "std")]
@@ -484,6 +485,39 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	}
 }
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> EventHandler for DefaultRouter<G, L, S>  where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
+	fn handle_event(&self, event: &Event) {
+		match event {
+			Event::PaymentPathFailed { short_channel_id, path, .. } => {
+				if let Some(short_channel_id) = short_channel_id {
+					let path = path.iter().collect::<Vec<_>>();
+					self.scorer.lock().payment_path_failed(&path, *short_channel_id);
+				}
+			},
+			Event::PaymentPathSuccessful { path, ..} => {
+				let path = path.iter().collect::<Vec<_>>();
+				self.scorer.lock().payment_path_successful(&path);
+			},
+			Event::ProbeSuccessful { payment_hash, path, .. } => {
+				log_trace!(self.logger, "Probe payment {} of {}msat was successful", log_bytes!(payment_hash.0), path.last().unwrap().fee_msat);
+				let path = path.iter().collect::<Vec<_>>();
+				self.scorer.lock().probe_successful(&path);
+			},
+			Event::ProbeFailed { payment_hash, path, short_channel_id, .. } => {
+				if let Some(short_channel_id) = short_channel_id {
+					log_trace!(self.logger, "Probe payment {} of {}msat failed at channel {}", log_bytes!(payment_hash.0), path.last().unwrap().fee_msat, *short_channel_id);
+					let path = path.iter().collect::<Vec<_>>();
+					self.scorer.lock().probe_failed(&path, *short_channel_id);
+				}
+			},
+			_ => {},
+		}
+	}
+}
+
 impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Payer for ChannelManager<Signer, M, T, K, F, L>
 where
 	M::Target: chain::Watch<Signer>,