f - Implement EventHandler directly on NetworkGraph

Author: jkczyz

lightning-background-processor/src/lib.rs

@@ -92,7 +92,6 @@ 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>>,
@@ -101,23 +100,20 @@ 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<'a, E, P, G, A, L>
+> EventHandler for DecoratingEventHandler<E, P, G, A, L>
 where A::Target: chain::Access, L::Target: Logger {
 	fn handle_event(&self, event: &Event) {
 		if let Some(gossip_sync) = &self.p2p_gossip_sync {
-			let event_handler = (gossip_sync.network_graph(), self.logger);
-			event_handler.handle_event(event);
+			gossip_sync.network_graph().handle_event(event);
 		}
 		self.event_handler.handle_event(event);
 	}
@@ -217,7 +213,6 @@ impl BackgroundProcessor {
 		let handle = thread::spawn(move || -> Result<(), std::io::Error> {
 			let event_handler = DecoratingEventHandler {
 				event_handler,
-				logger: &logger,
 				p2p_gossip_sync: p2p_gossip_sync.as_ref().map(|t| t.deref()),
 			};
 

lightning/src/routing/gossip.rs

@@ -126,7 +126,7 @@ pub struct NetworkGraph<L: Deref> where L::Target: Logger {
 	secp_ctx: Secp256k1<secp256k1::VerifyOnly>,
 	last_rapid_gossip_sync_timestamp: Mutex<Option<u32>>,
 	genesis_hash: BlockHash,
-	_logger: L,
+	logger: L,
 	// Lock order: channels -> nodes
 	channels: RwLock<BTreeMap<u64, ChannelInfo>>,
 	nodes: RwLock<BTreeMap<NodeId, NodeInfo>>,
@@ -248,29 +248,27 @@ where C::Target: chain::Access, L::Target: Logger
 	}
 }
 
-impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> EventHandler for (&G, &L)
-where L::Target: Logger {
+impl<L: Deref> EventHandler for NetworkGraph<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);
+						log_debug!(self.logger, "Updating channel with channel_update from a payment failure. Channel {} is {}.", short_channel_id, status);
+						let _ = self.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);
+						log_debug!(self.logger, "{} channel graph entry for {} due to a payment failure.", action, short_channel_id);
+						self.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);
+						log_debug!(self.logger, "{} node graph entry for {} due to a payment failure.", action, node_id);
+						self.node_failed(node_id, is_permanent);
 					},
 				}
 			}
@@ -984,7 +982,7 @@ impl<L: Deref> Writeable for NetworkGraph<L> where L::Target: Logger {
 }
 
 impl<L: Deref> ReadableArgs<L> for NetworkGraph<L> where L::Target: Logger {
-	fn read<R: io::Read>(reader: &mut R, _logger: L) -> Result<NetworkGraph<L>, DecodeError> {
+	fn read<R: io::Read>(reader: &mut R, logger: L) -> Result<NetworkGraph<L>, DecodeError> {
 		let _ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
 
 		let genesis_hash: BlockHash = Readable::read(reader)?;
@@ -1011,7 +1009,7 @@ impl<L: Deref> ReadableArgs<L> for NetworkGraph<L> where L::Target: Logger {
 		Ok(NetworkGraph {
 			secp_ctx: Secp256k1::verification_only(),
 			genesis_hash,
-			_logger,
+			logger,
 			channels: RwLock::new(channels),
 			nodes: RwLock::new(nodes),
 			last_rapid_gossip_sync_timestamp: Mutex::new(last_rapid_gossip_sync_timestamp),
@@ -1043,11 +1041,11 @@ impl<L: Deref> PartialEq for NetworkGraph<L> where L::Target: Logger {
 
 impl<L: Deref> NetworkGraph<L> where L::Target: Logger {
 	/// Creates a new, empty, network graph.
-	pub fn new(genesis_hash: BlockHash, _logger: L) -> NetworkGraph<L> {
+	pub fn new(genesis_hash: BlockHash, logger: L) -> NetworkGraph<L> {
 		Self {
 			secp_ctx: Secp256k1::verification_only(),
 			genesis_hash,
-			_logger,
+			logger,
 			channels: RwLock::new(BTreeMap::new()),
 			nodes: RwLock::new(BTreeMap::new()),
 			last_rapid_gossip_sync_timestamp: Mutex::new(None),