Introduce separate stop signal for background processor

Previously, we'd use the same stop signal for the background processor
as for all other background tasks which could result in the BP getting
stopped while other tasks are still produced changes that needed to be
processed before shutdown. Here we introduce a separate stop signal for
LDK's background processor, ensuring we first shutdown everything else
and disconnect all peers before finally sending the BP shutdown signal
and awaiting its shutdown.

Author: tnull

src/builder.rs

@@ -1668,11 +1668,13 @@ fn build_with_store_internal(
 	};
 
 	let (stop_sender, _) = tokio::sync::watch::channel(());
+	let (background_processor_stop_sender, _) = tokio::sync::watch::channel(());
 	let is_running = Arc::new(RwLock::new(false));
 
 	Ok(Node {
 		runtime,
 		stop_sender,
+		background_processor_stop_sender,
 		config,
 		wallet,
 		chain_source,

src/lib.rs

@@ -180,6 +180,7 @@ uniffi::include_scaffolding!("ldk_node");
 pub struct Node {
 	runtime: Arc<Runtime>,
 	stop_sender: tokio::sync::watch::Sender<()>,
+	background_processor_stop_sender: tokio::sync::watch::Sender<()>,
 	config: Arc<Config>,
 	wallet: Arc<Wallet>,
 	chain_source: Arc<ChainSource>,
@@ -525,7 +526,7 @@ impl Node {
 		let background_logger = Arc::clone(&self.logger);
 		let background_error_logger = Arc::clone(&self.logger);
 		let background_scorer = Arc::clone(&self.scorer);
-		let stop_bp = self.stop_sender.subscribe();
+		let stop_bp = self.background_processor_stop_sender.subscribe();
 		let sleeper_logger = Arc::clone(&self.logger);
 		let sleeper = move |d| {
 			let mut stop = stop_bp.clone();
@@ -607,18 +608,20 @@ impl Node {
 		// Stop any runtime-dependant chain sources.
 		self.chain_source.stop();
 
-		// Stop the runtime.
-		match self.stop_sender.send(()) {
-			Ok(_) => log_trace!(self.logger, "Sent shutdown signal to background tasks."),
-			Err(e) => {
+		// Stop background tasks.
+		self.stop_sender
+			.send(())
+			.map(|_| {
+				log_trace!(self.logger, "Sent shutdown signal to background tasks.");
+			})
+			.unwrap_or_else(|e| {
 				log_error!(
 					self.logger,
 					"Failed to send shutdown signal. This should never happen: {}",
 					e
 				);
 				debug_assert!(false);
-			},
-		}
+			});
 
 		// Cancel cancellable background tasks
 		self.runtime.abort_cancellable_background_tasks();
@@ -634,6 +637,21 @@ impl Node {
 		// Wait until non-cancellable background tasks (mod LDK's background processor) are done.
 		self.runtime.wait_on_background_tasks();
 
+		// Stop the background processor.
+		self.background_processor_stop_sender
+			.send(())
+			.map(|_| {
+				log_trace!(self.logger, "Sent shutdown signal to background processor.");
+			})
+			.unwrap_or_else(|e| {
+				log_error!(
+					self.logger,
+					"Failed to send shutdown signal. This should never happen: {}",
+					e
+				);
+				debug_assert!(false);
+			});
+
 		// Finally, wait until background processing stopped, at least until a timeout is reached.
 		self.runtime.wait_on_background_processor_task();