f - Add GossipSync::None instead of using Option<GossipSync>

Author: jkczyz

lightning-background-processor/src/lib.rs

@@ -40,8 +40,8 @@ use std::ops::Deref;
 ///   [`ChannelManager`] persistence should be done in the background.
 /// * Calling [`ChannelManager::timer_tick_occurred`] and [`PeerManager::timer_tick_occurred`]
 ///   at the appropriate intervals.
-/// * Calling [`NetworkGraph::remove_stale_channels`] (if a [`GossipSync`] is provided to
-///   [`BackgroundProcessor::start`]).
+/// * Calling [`NetworkGraph::remove_stale_channels`] (if a [`GossipSync`] with a [`NetworkGraph`]
+///   is provided to [`BackgroundProcessor::start`]).
 ///
 /// It will also call [`PeerManager::process_events`] periodically though this shouldn't be relied
 /// upon as doing so may result in high latency.
@@ -102,6 +102,8 @@ where A::Target: chain::Access, L::Target: Logger {
 	P2P(P),
 	/// Rapid gossip sync from a trusted server.
 	Rapid(R),
+	/// No gossip sync.
+	None,
 }
 
 impl<
@@ -112,10 +114,11 @@ impl<
 	L: Deref,
 > GossipSync<P, R, G, A, L>
 where A::Target: chain::Access, L::Target: Logger {
-	fn network_graph(&self) -> &G {
+	fn network_graph(&self) -> Option<&G> {
 		match self {
-			GossipSync::P2P(gossip_sync) => gossip_sync.network_graph(),
-			GossipSync::Rapid(gossip_sync) => gossip_sync.network_graph(),
+			GossipSync::P2P(gossip_sync) => Some(gossip_sync.network_graph()),
+			GossipSync::Rapid(gossip_sync) => Some(gossip_sync.network_graph()),
+			GossipSync::None => None,
 		}
 	}
 
@@ -129,14 +132,15 @@ where A::Target: chain::Access, L::Target: Logger {
 					None
 				}
 			},
+			GossipSync::None => None,
 		}
 	}
 }
 
 /// Decorates an [`EventHandler`] with common functionality provided by standard [`EventHandler`]s.
 struct DecoratingEventHandler<
+	'a,
 	E: EventHandler,
-	GS: Deref<Target = GossipSync<PGS, RGS, G, A, L>>,
 	PGS: Deref<Target = P2PGossipSync<G, A, L>>,
 	RGS: Deref<Target = RapidGossipSync<G, L>>,
 	G: Deref<Target = NetworkGraph<L>>,
@@ -145,22 +149,22 @@ struct DecoratingEventHandler<
 >
 where A::Target: chain::Access, L::Target: Logger {
 	event_handler: E,
-	gossip_sync: Option<GS>,
+	gossip_sync: &'a GossipSync<PGS, RGS, G, A, L>,
 }
 
 impl<
+	'a,
 	E: EventHandler,
-	GS: Deref<Target = GossipSync<PGS, RGS, G, A, L>>,
 	PGS: Deref<Target = P2PGossipSync<G, A, L>>,
 	RGS: Deref<Target = RapidGossipSync<G, L>>,
 	G: Deref<Target = NetworkGraph<L>>,
 	A: Deref,
 	L: Deref,
-> EventHandler for DecoratingEventHandler<E, GS, PGS, RGS, G, A, L>
+> EventHandler for DecoratingEventHandler<'a, E, PGS, RGS, G, A, L>
 where A::Target: chain::Access, L::Target: Logger {
 	fn handle_event(&self, event: &Event) {
-		if let Some(gossip_sync) = &self.gossip_sync {
-			gossip_sync.network_graph().handle_event(event);
+		if let Some(network_graph) = self.gossip_sync.network_graph() {
+			network_graph.handle_event(event);
 		}
 		self.event_handler.handle_event(event);
 	}
@@ -198,9 +202,9 @@ impl BackgroundProcessor {
 	///
 	/// # Rapid Gossip Sync
 	///
-	/// If rapid gossip sync is meant to run at startup, pass an optional [`RapidGossipSync`]
-	/// to `gossip_sync` to indicate that the [`BackgroundProcessor`] should not prune the
-	/// [`NetworkGraph`] instance until the [`RapidGossipSync`] instance completes its first sync.
+	/// If rapid gossip sync is meant to run at startup, pass a [`RapidGossipSync`] to `gossip_sync`
+	/// to indicate that the [`BackgroundProcessor`] should not prune the [`NetworkGraph`] instance
+	/// until the [`RapidGossipSync`] instance completes its first sync.
 	///
 	/// [top-level documentation]: BackgroundProcessor
 	/// [`join`]: Self::join
@@ -238,8 +242,7 @@ impl BackgroundProcessor {
 		SC: WriteableScore<'a>,
 	>(
 		persister: PS, event_handler: EH, chain_monitor: M, channel_manager: CM,
-		gossip_sync: Option<GossipSync<PGS, RGS, G, CA, L>>, peer_manager: PM, logger: L,
-		scorer: Option<S>,
+		gossip_sync: GossipSync<PGS, RGS, G, CA, L>, peer_manager: PM, logger: L, scorer: Option<S>,
 	) -> Self
 	where
 		CA::Target: 'static + chain::Access,
@@ -260,7 +263,7 @@ impl BackgroundProcessor {
 		let handle = thread::spawn(move || -> Result<(), std::io::Error> {
 			let event_handler = DecoratingEventHandler {
 				event_handler,
-				gossip_sync: gossip_sync.as_ref(),
+				gossip_sync: &gossip_sync,
 			};
 
 			log_trace!(logger, "Calling ChannelManager's timer_tick_occurred on startup");
@@ -340,10 +343,7 @@ impl BackgroundProcessor {
 				if last_prune_call.elapsed().as_secs() > if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER } {
 					// The network graph must not be pruned while rapid sync completion is pending
 					log_trace!(logger, "Assessing prunability of network graph");
-					let graph_to_prune = gossip_sync
-						.as_ref()
-						.and_then(|gossip_sync| gossip_sync.prunable_network_graph());
-					if let Some(network_graph) = graph_to_prune {
+					if let Some(network_graph) = gossip_sync.prunable_network_graph() {
 						network_graph.remove_stale_channels();
 
 						if let Err(e) = persister.persist_graph(network_graph) {
@@ -379,8 +379,8 @@ impl BackgroundProcessor {
 			}
 
 			// Persist NetworkGraph on exit
-			if let Some(ref gossip_sync) = gossip_sync {
-				persister.persist_graph(gossip_sync.network_graph())?;
+			if let Some(network_graph) = gossip_sync.network_graph() {
+				persister.persist_graph(network_graph)?;
 			}
 
 			Ok(())
@@ -500,16 +500,16 @@ mod tests {
 	}
 
 	impl Node {
-		fn p2p_gossip_sync(&self) -> Option<GossipSync<PGS, RGS, Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>> {
-			Some(GossipSync::P2P(self.p2p_gossip_sync.clone()))
+		fn p2p_gossip_sync(&self) -> GossipSync<PGS, RGS, Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>> {
+			GossipSync::P2P(self.p2p_gossip_sync.clone())
 		}
 
-		fn rapid_gossip_sync(&self) -> Option<GossipSync<PGS, RGS, Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>> {
-			Some(GossipSync::Rapid(self.rapid_gossip_sync.clone()))
+		fn rapid_gossip_sync(&self) -> GossipSync<PGS, RGS, Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>> {
+			GossipSync::Rapid(self.rapid_gossip_sync.clone())
 		}
 
-		fn no_gossip_sync(&self) -> Option<GossipSync<PGS, RGS, Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>> {
-			None
+		fn no_gossip_sync(&self) -> GossipSync<PGS, RGS, Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>> {
+			GossipSync::None
 		}
 	}