Update timestamp on network graph upon rapid sync completion.

Author: arik-so

fuzz/src/process_network_graph.rs

@@ -1,11 +1,15 @@
-// Import that needs to be added manually
+// Imports that need to be added manually
+use std::sync::Arc;
+
+use lightning_rapid_gossip_sync::RapidGossipSync;
 use utils::test_logger;
 
 /// Actual fuzz test, method signature and name are fixed
 fn do_test(data: &[u8]) {
 	let block_hash = bitcoin::BlockHash::default();
 	let network_graph = lightning::routing::network_graph::NetworkGraph::new(block_hash);
-	lightning_rapid_gossip_sync::processing::update_network_graph(&network_graph, data);
+	let rapid_sync = RapidGossipSync::new(Arc::new(network_graph));
+	rapid_sync.update_network_graph(data);
 }
 
 /// Method that needs to be added manually, {name}_test

lightning-background-processor/Cargo.toml

@@ -16,9 +16,9 @@ rustdoc-args = ["--cfg", "docsrs"]
 [dependencies]
 bitcoin = "0.28.1"
 lightning = { version = "0.0.106", path = "../lightning", features = ["std"] }
+lightning-rapid-gossip-sync = { version = "0.0.106", path = "../lightning-rapid-gossip-sync" }
 
 [dev-dependencies]
 lightning = { version = "0.0.106", path = "../lightning", features = ["_test_utils"] }
 lightning-invoice = { version = "0.14.0", path = "../lightning-invoice" }
 lightning-persister = { version = "0.0.106", path = "../lightning-persister" }
-lightning-rapid-gossip-sync = { version = "0.0.106", path = "../lightning-rapid-gossip-sync" }

lightning-background-processor/src/lib.rs

@@ -293,24 +293,24 @@ impl BackgroundProcessor {
 						if is_initial_sync_complete.load(Ordering::Acquire) {
 							log_trace!(logger, "Pruning network graph of stale entries");
 							handler.network_graph().remove_stale_channels();
+
+							if let Err(e) = persister.persist_graph(handler.network_graph()) {
+								log_error!(logger, "Error: Failed to persist network graph, check your disk and permissions {}", e)
+							}
+
+							last_prune_call = Instant::now();
+							have_pruned = true;
 						} else {
 							log_trace!(logger, "Not pruning network graph due to pending gossip sync");
-							continue;
-						}
-
-						if let Err(e) = persister.persist_graph(handler.network_graph()) {
-							log_error!(logger, "Error: Failed to persist network graph, check your disk and permissions {}", e)
-						}
-					}
-					if let Some(ref scorer) = scorer {
-						log_trace!(logger, "Persisting scorer");
-						if let Err(e) = persister.persist_scorer(&scorer) {
-							log_error!(logger, "Error: Failed to persist scorer, check your disk and permissions {}", e)
 						}
 					}
+				}
 
-					last_prune_call = Instant::now();
-					have_pruned = true;
+				if let Some(ref scorer) = scorer {
+					log_trace!(logger, "Persisting scorer");
+					if let Err(e) = persister.persist_scorer(&scorer) {
+						log_error!(logger, "Error: Failed to persist scorer, check your disk and permissions {}", e)
+					}
 				}
 			}
 

lightning-rapid-gossip-sync/src/lib.rs

@@ -27,13 +27,16 @@
 //! its contents from disk, which we do by calling the `sync_network_graph_with_file_path` method:
 //!
 //! ```
+//! use std::sync::Arc;
 //! use bitcoin::blockdata::constants::genesis_block;
 //! use bitcoin::Network;
 //! use lightning::routing::network_graph::NetworkGraph;
+//! use lightning_rapid_gossip_sync::RapidGossipSync;
 //!
 //! let block_hash = genesis_block(Network::Bitcoin).header.block_hash();
-//! let network_graph = NetworkGraph::new(block_hash);
-//! let new_last_sync_timestamp_result = lightning_rapid_gossip_sync::sync_network_graph_with_file_path(&network_graph, "./rapid_sync.lngossip");
+//! let network_graph = Arc::new(NetworkGraph::new(block_hash));
+//! let rapid_sync = RapidGossipSync::new(network_graph);
+//! let new_last_sync_timestamp_result = rapid_sync.sync_network_graph_with_file_path("./rapid_sync.lngossip");
 //! ```
 //!
 //! The primary benefit this syncing mechanism provides is that given a trusted server, a

lightning-rapid-gossip-sync/src/processing.rs

@@ -226,6 +226,7 @@ impl<NG: Deref<Target=NetworkGraph>> RapidGossipSync<NG> {
 			network_graph.update_channel_unsigned(&synthetic_update)?;
 		}
 
+		self.network_graph.set_last_rapid_gossip_sync_timestamps(latest_seen_timestamp);
 		self.is_initial_sync_complete.store(true, Ordering::Release);
 		Ok(latest_seen_timestamp)
 	}

lightning/src/routing/network_graph.rs

@@ -123,9 +123,7 @@ impl Readable for NodeId {
 
 /// Represents the network as nodes and channels between them
 pub struct NetworkGraph {
-	/// The unix timestamp in UTC provided by the most recent rapid gossip sync
-	/// It will be set by the rapid sync process after every sync completion
-	pub last_rapid_gossip_sync_timestamp: Option<u32>,
+	last_rapid_gossip_sync_timestamp: Mutex<Option<u32>>,
 	genesis_hash: BlockHash,
 	// Lock order: channels -> nodes
 	channels: RwLock<BTreeMap<u64, ChannelInfo>>,
@@ -136,11 +134,12 @@ impl Clone for NetworkGraph {
 	fn clone(&self) -> Self {
 		let channels = self.channels.read().unwrap();
 		let nodes = self.nodes.read().unwrap();
+		let last_rapid_gossip_sync_timestamp = self.get_last_rapid_gossip_sync_timestamp();
 		Self {
 			genesis_hash: self.genesis_hash.clone(),
 			channels: RwLock::new(channels.clone()),
 			nodes: RwLock::new(nodes.clone()),
-			last_rapid_gossip_sync_timestamp: self.last_rapid_gossip_sync_timestamp.clone(),
+			last_rapid_gossip_sync_timestamp: Mutex::new(last_rapid_gossip_sync_timestamp)
 		}
 	}
 }
@@ -994,8 +993,9 @@ impl Writeable for NetworkGraph {
 			node_info.write(writer)?;
 		}
 
+		let last_rapid_gossip_sync_timestamp = self.get_last_rapid_gossip_sync_timestamp();
 		write_tlv_fields!(writer, {
-			(1, self.last_rapid_gossip_sync_timestamp, option),
+			(1, last_rapid_gossip_sync_timestamp, option),
 		});
 		Ok(())
 	}
@@ -1030,7 +1030,7 @@ impl Readable for NetworkGraph {
 			genesis_hash,
 			channels: RwLock::new(channels),
 			nodes: RwLock::new(nodes),
-			last_rapid_gossip_sync_timestamp,
+			last_rapid_gossip_sync_timestamp: Mutex::new(last_rapid_gossip_sync_timestamp),
 		})
 	}
 }
@@ -1064,7 +1064,7 @@ impl NetworkGraph {
 			genesis_hash,
 			channels: RwLock::new(BTreeMap::new()),
 			nodes: RwLock::new(BTreeMap::new()),
-			last_rapid_gossip_sync_timestamp: None,
+			last_rapid_gossip_sync_timestamp: Mutex::new(None),
 		}
 	}
 
@@ -1078,6 +1078,18 @@ impl NetworkGraph {
 		}
 	}
 
+	/// The unix timestamp in UTC provided by the most recent rapid gossip sync.
+	/// It will be set by the rapid sync process after every sync completion.
+	pub fn get_last_rapid_gossip_sync_timestamp(&self) -> Option<u32> {
+		self.last_rapid_gossip_sync_timestamp.lock().unwrap().clone()
+	}
+
+	/// Update the UTC timestamp provided by the most recent rapid gossip sync.
+	/// This should be done automatically by the rapid sync process after every sync completion.
+	pub fn set_last_rapid_gossip_sync_timestamps(&self, last_rapid_gossip_sync_timestamp: u32) {
+		self.last_rapid_gossip_sync_timestamp.lock().unwrap().replace(last_rapid_gossip_sync_timestamp);
+	}
+
 	/// Clears the `NodeAnnouncementInfo` field for all nodes in the `NetworkGraph` for testing
 	/// purposes.
 	#[cfg(test)]
@@ -2374,13 +2386,13 @@ mod tests {
 	#[test]
 	fn network_graph_tlv_serialization() {
 		let mut network_graph = create_network_graph();
-		network_graph.last_rapid_gossip_sync_timestamp.replace(42);
+		network_graph.set_last_rapid_gossip_sync_timestamps(42);
 
 		let mut w = test_utils::TestVecWriter(Vec::new());
 		network_graph.write(&mut w).unwrap();
 		let reassembled_network_graph: NetworkGraph = Readable::read(&mut io::Cursor::new(&w.0)).unwrap();
 		assert!(reassembled_network_graph == network_graph);
-		assert_eq!(reassembled_network_graph.last_rapid_gossip_sync_timestamp.unwrap(), 42);
+		assert_eq!(reassembled_network_graph.get_last_rapid_gossip_sync_timestamp().unwrap(), 42);
 	}
 
 	#[test]