Persist NetworkGraph on removal of stale channels

Add comment to log_warn macro

Author: jurvis

lightning-background-processor/src/lib.rs

@@ -107,6 +107,25 @@ ChannelManagerPersister<Signer, M, T, K, F, L> for Fun where
 	}
 }
 
+/// Trait which handles persisting a [`NetworkGraph`] to disk.
+///
+/// [`NetworkGraph`]: lightning::routing::network_graph::NetworkGraph
+pub trait NetworkGraphPersister {
+	/// Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed
+	/// which will cause the [`BackgroundProcessor`] which called this method to exit
+	/// 
+	/// [`NetworkGraph`]: lightning::routing::network_graph::NetworkGraph
+	fn persist_graph(&self, network_graph: &NetworkGraph) -> Result<(), std::io::Error>;
+}
+
+impl<Fun> NetworkGraphPersister for Fun where
+	Fun: Fn(&NetworkGraph) -> Result<(), std::io::Error>, 
+{
+	fn persist_graph(&self, network_graph: &NetworkGraph) -> Result<(), std::io::Error> {
+		self(network_graph)
+	}	
+}
+
 /// Decorates an [`EventHandler`] with common functionality provided by standard [`EventHandler`]s.
 struct DecoratingEventHandler<
 	E: EventHandler,
@@ -190,8 +209,9 @@ impl BackgroundProcessor {
 		NG: 'static + Deref<Target = NetGraphMsgHandler<G, CA, L>> + Send + Sync,
 		UMH: 'static + Deref + Send + Sync,
 		PM: 'static + Deref<Target = PeerManager<Descriptor, CMH, RMH, L, UMH>> + Send + Sync,
+		NGP:  'static + Send + NetworkGraphPersister,
 	>(
-		persister: CMP, event_handler: EH, chain_monitor: M, channel_manager: CM,
+		channel_manager_persister: CMP, network_graph_persister: NGP, event_handler: EH, chain_monitor: M, channel_manager: CM,
 		net_graph_msg_handler: Option<NG>, peer_manager: PM, logger: L
 	) -> Self
 	where
@@ -234,7 +254,13 @@ impl BackgroundProcessor {
 
 				if updates_available {
 					log_trace!(logger, "Persisting ChannelManager...");
-					persister.persist_manager(&*channel_manager)?;
+					channel_manager_persister.persist_manager(&*channel_manager)?;
+					if let Some(ref handler) = net_graph_msg_handler {
+						if network_graph_persister.persist_graph(handler.network_graph()).is_err() {
+							log_warn!(logger, "Warning: Failed to persist network graph, check your disk and permissions");
+						}
+					}
+
 					log_trace!(logger, "Done persisting ChannelManager.");
 				}
 				// Exit the loop if the background processor was requested to stop.
@@ -277,6 +303,9 @@ impl BackgroundProcessor {
 					if let Some(ref handler) = net_graph_msg_handler {
 						log_trace!(logger, "Pruning network graph of stale entries");
 						handler.network_graph().remove_stale_channels();
+						if network_graph_persister.persist_graph(handler.network_graph()).is_err() {
+							log_warn!(logger, "Warning: Failed to persist network graph, check your disk and permissions");
+						}
 						last_prune_call = Instant::now();
 						have_pruned = true;
 					}
@@ -285,7 +314,7 @@ impl BackgroundProcessor {
 			// After we exit, ensure we persist the ChannelManager one final time - this avoids
 			// some races where users quit while channel updates were in-flight, with
 			// ChannelMonitor update(s) persisted without a corresponding ChannelManager update.
-			persister.persist_manager(&*channel_manager)
+			channel_manager_persister.persist_manager(&*channel_manager)
 		});
 		Self { stop_thread: stop_thread_clone, thread_handle: Some(handle) }
 	}
@@ -525,9 +554,11 @@ mod tests {
 
 		// Initiate the background processors to watch each node.
 		let data_dir = nodes[0].persister.get_data_dir();
-		let persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let channel_manager_persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let data_dir = nodes[0].persister.get_data_dir();
+		let network_graph_persister = move |graph: &NetworkGraph| FilesystemPersister::persist_network_graph(data_dir.clone(), graph);
 		let event_handler = |_: &_| {};
-		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(channel_manager_persister, network_graph_persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 
 		macro_rules! check_persisted_data {
 			($node: expr, $filepath: expr, $expected_bytes: expr) => {
@@ -556,6 +587,7 @@ mod tests {
 		let filepath = get_full_filepath("test_background_processor_persister_0".to_string(), "manager".to_string());
 		let mut expected_bytes = Vec::new();
 		check_persisted_data!(nodes[0].node, filepath.clone(), expected_bytes);
+
 		loop {
 			if !nodes[0].node.get_persistence_condvar_value() { break }
 		}
@@ -570,6 +602,14 @@ mod tests {
 			if !nodes[0].node.get_persistence_condvar_value() { break }
 		}
 
+		// Check network graph is persisted
+		let filepath = get_full_filepath("test_background_processor_persister_0".to_string(), "network_graph".to_string());
+		let mut expected_bytes = Vec::new();
+		if let Some(handler) = nodes[0].net_graph_msg_handler.clone() {
+			let network_graph = handler.network_graph();
+			check_persisted_data!(network_graph, filepath.clone(), expected_bytes);
+		}
+
 		assert!(bg_processor.stop().is_ok());
 	}
 
@@ -579,9 +619,11 @@ mod tests {
 		// `FRESHNESS_TIMER`.
 		let nodes = create_nodes(1, "test_timer_tick_called".to_string());
 		let data_dir = nodes[0].persister.get_data_dir();
-		let persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let channel_manager_persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let data_dir = nodes[0].persister.get_data_dir();
+		let network_graph_persister = move |graph: &NetworkGraph| FilesystemPersister::persist_network_graph(data_dir.clone(), graph);
 		let event_handler = |_: &_| {};
-		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(channel_manager_persister, network_graph_persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 		loop {
 			let log_entries = nodes[0].logger.lines.lock().unwrap();
 			let desired_log = "Calling ChannelManager's timer_tick_occurred".to_string();
@@ -596,14 +638,16 @@ mod tests {
 	}
 
 	#[test]
-	fn test_persist_error() {
+	fn test_channel_manager_persist_error() {
 		// Test that if we encounter an error during manager persistence, the thread panics.
 		let nodes = create_nodes(2, "test_persist_error".to_string());
 		open_channel!(nodes[0], nodes[1], 100000);
 
-		let persister = |_: &_| Err(std::io::Error::new(std::io::ErrorKind::Other, "test"));
+		let channel_manager_persister = |_: &_| Err(std::io::Error::new(std::io::ErrorKind::Other, "test"));
+		let data_dir = nodes[0].persister.get_data_dir();
+		let network_graph_persister = move |graph: &NetworkGraph| FilesystemPersister::persist_network_graph(data_dir.clone(), graph); 
 		let event_handler = |_: &_| {};
-		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(channel_manager_persister, network_graph_persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 		match bg_processor.join() {
 			Ok(_) => panic!("Expected error persisting manager"),
 			Err(e) => {
@@ -618,14 +662,16 @@ mod tests {
 		let mut nodes = create_nodes(2, "test_background_event_handling".to_string());
 		let channel_value = 100000;
 		let data_dir = nodes[0].persister.get_data_dir();
-		let persister = move |node: &_| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let channel_manager_persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let data_dir = nodes[0].persister.get_data_dir();
+		let network_graph_persister = move |graph: &NetworkGraph| FilesystemPersister::persist_network_graph(data_dir.clone(), graph);
 
 		// Set up a background event handler for FundingGenerationReady events.
 		let (sender, receiver) = std::sync::mpsc::sync_channel(1);
 		let event_handler = move |event: &Event| {
 			sender.send(handle_funding_generation_ready!(event, channel_value)).unwrap();
 		};
-		let bg_processor = BackgroundProcessor::start(persister.clone(), event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(channel_manager_persister.clone(), network_graph_persister.clone(), event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 
 		// Open a channel and check that the FundingGenerationReady event was handled.
 		begin_open_channel!(nodes[0], nodes[1], channel_value);
@@ -649,7 +695,7 @@ mod tests {
 		// Set up a background event handler for SpendableOutputs events.
 		let (sender, receiver) = std::sync::mpsc::sync_channel(1);
 		let event_handler = move |event: &Event| sender.send(event.clone()).unwrap();
-		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(channel_manager_persister, network_graph_persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 
 		// Force close the channel and check that the SpendableOutputs event was handled.
 		nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id).unwrap();
@@ -675,12 +721,14 @@ mod tests {
 
 		// Initiate the background processors to watch each node.
 		let data_dir = nodes[0].persister.get_data_dir();
-		let persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let channel_manager_persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
+		let data_dir = nodes[0].persister.get_data_dir();
+		let network_graph_persister = move |graph: &NetworkGraph| FilesystemPersister::persist_network_graph(data_dir.clone(), graph);
 		let scorer = Arc::new(Mutex::new(test_utils::TestScorer::with_penalty(0)));
 		let router = DefaultRouter::new(Arc::clone(&nodes[0].network_graph), Arc::clone(&nodes[0].logger), random_seed_bytes);
 		let invoice_payer = Arc::new(InvoicePayer::new(Arc::clone(&nodes[0].node), router, scorer, Arc::clone(&nodes[0].logger), |_: &_| {}, RetryAttempts(2)));
 		let event_handler = Arc::clone(&invoice_payer);
-		let bg_processor = BackgroundProcessor::start(persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
+		let bg_processor = BackgroundProcessor::start(channel_manager_persister, network_graph_persister, event_handler, nodes[0].chain_monitor.clone(), nodes[0].node.clone(), nodes[0].net_graph_msg_handler.clone(), nodes[0].peer_manager.clone(), nodes[0].logger.clone());
 		assert!(bg_processor.stop().is_ok());
 	}
 }

lightning-persister/src/lib.rs

@@ -110,6 +110,13 @@ impl FilesystemPersister {
 		util::write_to_file(path, "manager".to_string(), manager)
 	}
 
+	/// Write the provided `NetworkGraph` to the path provided at `FilesystemPersister`
+	/// initialization, within a file called "network_graph"
+	pub fn persist_network_graph(data_dir: String, network_graph: &NetworkGraph) -> Result<(), std::io::Error> {
+		let path = PathBuf::from(data_dir);
+		util::write_to_file(path, "network_graph".to_string(), network_graph)
+	}
+
 	/// Read `ChannelMonitor`s from disk.
 	pub fn read_channelmonitors<Signer: Sign, K: Deref> (
 		&self, keys_manager: K

lightning/src/util/macro_logger.rs

@@ -193,6 +193,8 @@ macro_rules! log_error {
 	)
 }
 
+/// Log a warning
+#[macro_export]
 macro_rules! log_warn {
 	($logger: expr, $($arg:tt)*) => (
 		log_given_level!($logger, $crate::util::logger::Level::Warn, $($arg)*);