Use updated sync terminology.

Author: arik-so

lightning-background-processor/src/lib.rs

@@ -57,7 +57,7 @@ use std::ops::Deref;
 pub struct BackgroundProcessor {
 	stop_thread: Arc<AtomicBool>,
 	thread_handle: Option<JoinHandle<Result<(), std::io::Error>>>,
-	is_awaiting_graph_sync_completion: Arc<AtomicBool>
+	is_awaiting_rapid_sync_completion: Arc<AtomicBool>
 }
 
 #[cfg(not(test))]
@@ -153,11 +153,11 @@ impl BackgroundProcessor {
 	/// [`NetworkGraph`]: lightning::routing::network_graph::NetworkGraph
 	/// [`NetworkGraph::write`]: lightning::routing::network_graph::NetworkGraph#impl-Writeable
 	///
-	/// # Graph Sync
+	/// # Rapid Gossip Sync
 	///
-	/// If a rapid graph sync is meant to run at startup, set `await_graph_sync_completion` to true
-	/// to indicate to [`BackgroundProcessor`] not to prune the [`NetworkGraph`] instance until
-	/// [`graph_sync_complete`] is called.
+	/// If a rapid gossip sync is meant to run at startup, set `await_rapid_gossip_sync_completion`
+	/// to true to indicate to [`BackgroundProcessor`] not to prune the [`NetworkGraph`] instance
+	/// until [`rapid_gossip_sync_complete`] is called.
 	pub fn start<
 		'a,
 		Signer: 'static + Sign,
@@ -184,7 +184,7 @@ impl BackgroundProcessor {
 		SC: WriteableScore<'a>,
 	>(
 		persister: PS, event_handler: EH, chain_monitor: M, channel_manager: CM,
-		net_graph_msg_handler: Option<NG>, peer_manager: PM, await_graph_sync_completion: bool, logger: L, scorer: Option<S>
+		net_graph_msg_handler: Option<NG>, peer_manager: PM, await_rapid_gossip_sync_completion: bool, logger: L, scorer: Option<S>
 	) -> Self
 	where
 		CA::Target: 'static + chain::Access,
@@ -202,7 +202,7 @@ impl BackgroundProcessor {
 	{
 		let stop_thread = Arc::new(AtomicBool::new(false));
 		let stop_thread_clone = stop_thread.clone();
-		let is_awaiting_graph_sync_completion = Arc::new(AtomicBool::new(await_graph_sync_completion));
+		let is_awaiting_graph_sync_completion = Arc::new(AtomicBool::new(await_rapid_gossip_sync_completion));
 		let is_awaiting_graph_sync_completion_clone = is_awaiting_graph_sync_completion.clone();
 		let handle = thread::spawn(move || -> Result<(), std::io::Error> {
 			let event_handler = DecoratingEventHandler { event_handler, net_graph_msg_handler: net_graph_msg_handler.as_ref().map(|t| t.deref()) };
@@ -283,10 +283,10 @@ impl BackgroundProcessor {
 				if last_prune_call.elapsed().as_secs() > if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER } {
 					if let Some(ref handler) = net_graph_msg_handler {
 						log_trace!(logger, "Assessing prunability of network graph");
-						// The network graph must not be pruned while graph sync completion is pending
+						// The network graph must not be pruned while rapid sync completion is pending
 						let is_currently_awaiting_graph_sync = is_awaiting_graph_sync_completion_clone.load(Ordering::Acquire);
 						if is_currently_awaiting_graph_sync {
-							log_trace!(logger, "Not pruning network graph due to pending graph sync");
+							log_trace!(logger, "Not pruning network graph due to pending gossip sync");
 							continue;
 						}
 						log_trace!(logger, "Pruning network graph of stale entries");
@@ -324,7 +324,7 @@ impl BackgroundProcessor {
 
 			Ok(())
 		});
-		Self { stop_thread: stop_thread_clone, thread_handle: Some(handle), is_awaiting_graph_sync_completion }
+		Self { stop_thread: stop_thread_clone, thread_handle: Some(handle), is_awaiting_rapid_sync_completion: is_awaiting_graph_sync_completion }
 	}
 
 	/// Join `BackgroundProcessor`'s thread, returning any error that occurred while persisting
@@ -355,12 +355,12 @@ impl BackgroundProcessor {
 		self.stop_and_join_thread()
 	}
 
-	/// Signal to [`BackgroundProcessor`] that the initial rapid graph sync has completed.
+	/// Signal to [`BackgroundProcessor`] that the initial rapid gossip sync has completed.
 	///
 	/// This function can only be called usefully once, so there is an implicit understanding
-	/// that running graph sync multiple times after startup is API misuse.
-	pub fn graph_sync_complete(&self) {
-		self.is_awaiting_graph_sync_completion.store(false, Ordering::Release)
+	/// that running rapid sync multiple times after startup is API misuse.
+	pub fn rapid_gossip_sync_complete(&self) {
+		self.is_awaiting_rapid_sync_completion.store(false, Ordering::Release)
 	}
 
 	fn stop_and_join_thread(&mut self) -> Result<(), std::io::Error> {
@@ -844,14 +844,14 @@ mod tests {
 		loop {
 			let log_entries = nodes[0].logger.lines.lock().unwrap();
 			let expected_log_a = "Assessing prunability of network graph".to_string();
-			let expected_log_b = "Not pruning network graph due to pending graph sync".to_string();
+			let expected_log_b = "Not pruning network graph due to pending gossip sync".to_string();
 			if log_entries.get(&("lightning_background_processor".to_string(), expected_log_a)).is_some() &&
 				log_entries.get(&("lightning_background_processor".to_string(), expected_log_b)).is_some() {
 				break
 			}
 		}
 
-		bg_processor.graph_sync_complete();
+		bg_processor.rapid_gossip_sync_complete();
 
 		let _ = receiver
 			.recv_timeout(Duration::from_secs(super::FIRST_NETWORK_PRUNE_TIMER * 2))