Implement EventHandler for NetworkGraph

Instead of implementing EventHandler for P2PGossipSync, implement it on
NetworkGraph. This allows RapidGossipSync to handle events, too, by
delegating to its NetworkGraph.

Author: jkczyz

lightning-background-processor/src/lib.rs

@@ -92,6 +92,7 @@ const FIRST_NETWORK_PRUNE_TIMER: u64 = 1;
 
 /// Decorates an [`EventHandler`] with common functionality provided by standard [`EventHandler`]s.
 struct DecoratingEventHandler<
+	'a,
 	E: EventHandler,
 	P: Deref<Target = P2PGossipSync<G, A, L>>,
 	G: Deref<Target = NetworkGraph<L>>,
@@ -100,19 +101,22 @@ struct DecoratingEventHandler<
 >
 where A::Target: chain::Access, L::Target: Logger {
 	event_handler: E,
+	logger: &'a L,
 	p2p_gossip_sync: Option<P>,
 }
 
 impl<
+	'a,
 	E: EventHandler,
 	P: Deref<Target = P2PGossipSync<G, A, L>>,
 	G: Deref<Target = NetworkGraph<L>>,
 	A: Deref,
 	L: Deref,
-> EventHandler for DecoratingEventHandler<E, P, G, A, L>
+> EventHandler for DecoratingEventHandler<'a, E, P, G, A, L>
 where A::Target: chain::Access, L::Target: Logger {
 	fn handle_event(&self, event: &Event) {
-		if let Some(event_handler) = &self.p2p_gossip_sync {
+		if let Some(gossip_sync) = &self.p2p_gossip_sync {
+			let event_handler = (gossip_sync.network_graph(), self.logger);
 			event_handler.handle_event(event);
 		}
 		self.event_handler.handle_event(event);
@@ -211,7 +215,11 @@ impl BackgroundProcessor {
 		let stop_thread = Arc::new(AtomicBool::new(false));
 		let stop_thread_clone = stop_thread.clone();
 		let handle = thread::spawn(move || -> Result<(), std::io::Error> {
-			let event_handler = DecoratingEventHandler { event_handler, p2p_gossip_sync: p2p_gossip_sync.as_ref().map(|t| t.deref()) };
+			let event_handler = DecoratingEventHandler {
+				event_handler,
+				logger: &logger,
+				p2p_gossip_sync: p2p_gossip_sync.as_ref().map(|t| t.deref()),
+			};
 
 			log_trace!(logger, "Calling ChannelManager's timer_tick_occurred on startup");
 			channel_manager.timer_tick_occurred();

lightning/src/routing/gossip.rs

@@ -184,17 +184,6 @@ impl_writeable_tlv_based_enum_upgradable!(NetworkUpdate,
 	},
 );
 
-impl<G: Deref<Target=NetworkGraph<L>>, C: Deref, L: Deref> EventHandler for P2PGossipSync<G, C, L>
-where C::Target: chain::Access, L::Target: Logger {
-	fn handle_event(&self, event: &Event) {
-		if let Event::PaymentPathFailed { payment_hash: _, rejected_by_dest: _, network_update, .. } = event {
-			if let Some(network_update) = network_update {
-				self.handle_network_update(network_update);
-			}
-		}
-	}
-}
-
 /// Receives and validates network updates from peers,
 /// stores authentic and relevant data as a network graph.
 /// This network graph is then used for routing payments.
@@ -257,27 +246,34 @@ where C::Target: chain::Access, L::Target: Logger
 			false
 		}
 	}
+}
 
-	/// Applies changes to the [`NetworkGraph`] from the given update.
-	fn handle_network_update(&self, update: &NetworkUpdate) {
-		match *update {
-			NetworkUpdate::ChannelUpdateMessage { ref msg } => {
-				let short_channel_id = msg.contents.short_channel_id;
-				let is_enabled = msg.contents.flags & (1 << 1) != (1 << 1);
-				let status = if is_enabled { "enabled" } else { "disabled" };
-				log_debug!(self.logger, "Updating channel with channel_update from a payment failure. Channel {} is {}.", short_channel_id, status);
-				let _ = self.network_graph.update_channel(msg);
-			},
-			NetworkUpdate::ChannelFailure { short_channel_id, is_permanent } => {
-				let action = if is_permanent { "Removing" } else { "Disabling" };
-				log_debug!(self.logger, "{} channel graph entry for {} due to a payment failure.", action, short_channel_id);
-				self.network_graph.channel_failed(short_channel_id, is_permanent);
-			},
-			NetworkUpdate::NodeFailure { ref node_id, is_permanent } => {
-				let action = if is_permanent { "Removing" } else { "Disabling" };
-				log_debug!(self.logger, "{} node graph entry for {} due to a payment failure.", action, node_id);
-				self.network_graph.node_failed(node_id, is_permanent);
-			},
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> EventHandler for (&G, &L)
+where L::Target: Logger {
+	fn handle_event(&self, event: &Event) {
+		if let Event::PaymentPathFailed { payment_hash: _, rejected_by_dest: _, network_update, .. } = event {
+			if let Some(network_update) = network_update {
+				let (network_graph, logger) = self;
+				match *network_update {
+					NetworkUpdate::ChannelUpdateMessage { ref msg } => {
+						let short_channel_id = msg.contents.short_channel_id;
+						let is_enabled = msg.contents.flags & (1 << 1) != (1 << 1);
+						let status = if is_enabled { "enabled" } else { "disabled" };
+						log_debug!(logger, "Updating channel with channel_update from a payment failure. Channel {} is {}.", short_channel_id, status);
+						let _ = network_graph.update_channel(msg);
+					},
+					NetworkUpdate::ChannelFailure { short_channel_id, is_permanent } => {
+						let action = if is_permanent { "Removing" } else { "Disabling" };
+						log_debug!(logger, "{} channel graph entry for {} due to a payment failure.", action, short_channel_id);
+						network_graph.channel_failed(short_channel_id, is_permanent);
+					},
+					NetworkUpdate::NodeFailure { ref node_id, is_permanent } => {
+						let action = if is_permanent { "Removing" } else { "Disabling" };
+						log_debug!(logger, "{} node graph entry for {} due to a payment failure.", action, node_id);
+						network_graph.node_failed(node_id, is_permanent);
+					},
+				}
+			}
 		}
 	}
 }
@@ -2055,11 +2051,10 @@ mod tests {
 	#[test]
 	fn handling_network_update() {
 		let logger = test_utils::TestLogger::new();
-		let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet));
 		let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
 		let network_graph = NetworkGraph::new(genesis_hash, &logger);
-		let gossip_sync = P2PGossipSync::new(&network_graph, Some(chain_source.clone()), &logger);
 		let secp_ctx = Secp256k1::new();
+		let event_handler = (&&network_graph, &&logger);
 
 		let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
@@ -2081,7 +2076,7 @@ mod tests {
 			let valid_channel_update = get_signed_channel_update(|_| {}, node_1_privkey, &secp_ctx);
 			assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_none());
 
-			gossip_sync.handle_event(&Event::PaymentPathFailed {
+			event_handler.handle_event(&Event::PaymentPathFailed {
 				payment_id: None,
 				payment_hash: PaymentHash([0; 32]),
 				rejected_by_dest: false,
@@ -2108,7 +2103,7 @@ mod tests {
 				}
 			};
 
-			gossip_sync.handle_event(&Event::PaymentPathFailed {
+			event_handler.handle_event(&Event::PaymentPathFailed {
 				payment_id: None,
 				payment_hash: PaymentHash([0; 32]),
 				rejected_by_dest: false,
@@ -2133,7 +2128,7 @@ mod tests {
 		}
 
 		// Permanent closing deletes a channel
-		gossip_sync.handle_event(&Event::PaymentPathFailed {
+		event_handler.handle_event(&Event::PaymentPathFailed {
 			payment_id: None,
 			payment_hash: PaymentHash([0; 32]),
 			rejected_by_dest: false,

lightning/src/util/events.rs

@@ -337,10 +337,9 @@ pub enum Event {
 		/// payment route.
 		///
 		/// Should be applied to the [`NetworkGraph`] so that routing decisions can take into
-		/// account the update. [`P2PGossipSync`] is capable of doing this.
+		/// account the update.
 		///
 		/// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph
-		/// [`P2PGossipSync`]: crate::routing::gossip::P2PGossipSync
 		network_update: Option<NetworkUpdate>,
 		/// For both single-path and multi-path payments, this is set if all paths of the payment have
 		/// failed. This will be set to false if (1) this is an MPP payment and (2) other parts of the