f Skip unnecessary wallet syncs, but wait

Author: tnull

src/lib.rs

@@ -542,11 +542,15 @@ impl Node {
 						match wallet.sync().await {
 							Ok(()) => log_info!(
 								sync_logger,
-								"On-chain wallet sync finished in {}ms.",
+								"Background sync of on-chain wallet finished in {}ms.",
 								now.elapsed().as_millis()
 							),
 							Err(err) => {
-								log_error!(sync_logger, "On-chain wallet sync failed: {}", err)
+								log_error!(
+									sync_logger,
+									"Background sync of on-chain wallet failed: {}",
+									err
+								)
 							}
 						}
 						tokio::time::sleep(Duration::from_secs(20)).await;
@@ -570,11 +574,11 @@ impl Node {
 				match tx_sync.sync(confirmables).await {
 					Ok(()) => log_info!(
 						sync_logger,
-						"Lightning wallet sync finished in {}ms.",
+						"Background sync of Lightning wallet finished in {}ms.",
 						now.elapsed().as_millis()
 					),
 					Err(e) => {
-						log_error!(sync_logger, "Lightning wallet sync failed: {}", e)
+						log_error!(sync_logger, "Background sync of Lightning wallet failed: {}", e)
 					}
 				}
 				tokio::time::sleep(Duration::from_secs(5)).await;
@@ -798,22 +802,54 @@ impl Node {
 		let tx_sync = Arc::clone(&self.tx_sync);
 		let sync_cman = Arc::clone(&self.channel_manager);
 		let sync_cmon = Arc::clone(&self.chain_monitor);
+		let sync_logger = Arc::clone(&self.logger);
 		let confirmables = vec![
 			&*sync_cman as &(dyn Confirm + Sync + Send),
 			&*sync_cmon as &(dyn Confirm + Sync + Send),
 		];
 
 		let runtime = runtime_lock.as_ref().unwrap();
 		tokio::task::block_in_place(move || {
-			tokio::runtime::Builder::new_current_thread()
-				.enable_all()
-				.build()
-				.unwrap()
-				.block_on(async move { wallet.sync().await })
+			tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(
+				async move {
+					let now = Instant::now();
+					match wallet.sync().await {
+						Ok(()) => {
+							log_info!(
+								sync_logger,
+								"Sync of on-chain wallet finished in {}ms.",
+								now.elapsed().as_millis()
+							);
+							Ok(())
+						}
+						Err(e) => {
+							log_error!(sync_logger, "Sync of on-chain wallet failed: {}", e);
+							Err(e)
+						}
+					}
+				},
+			)
 		})?;
 
+		let sync_logger = Arc::clone(&self.logger);
 		tokio::task::block_in_place(move || {
-			runtime.tokio_runtime.block_on(async move { tx_sync.sync(confirmables).await })
+			runtime.tokio_runtime.block_on(async move {
+				let now = Instant::now();
+				match tx_sync.sync(confirmables).await {
+					Ok(()) => {
+						log_info!(
+							sync_logger,
+							"Sync of Lightning wallet finished in {}ms.",
+							now.elapsed().as_millis()
+						);
+						Ok(())
+					}
+					Err(e) => {
+						log_error!(sync_logger, "Sync of Lightning wallet failed: {}", e);
+						Err(e)
+					}
+				}
+			})
 		})?;
 
 		Ok(())

src/wallet.rs

@@ -1,4 +1,4 @@
-use crate::logger::{log_error, log_trace, FilesystemLogger, Logger};
+use crate::logger::{log_error, log_info, log_trace, FilesystemLogger, Logger};
 
 use crate::Error;
 
@@ -25,7 +25,7 @@ use bitcoin::secp256k1::{PublicKey, Scalar, Secp256k1, Signing};
 use bitcoin::{Script, Transaction, TxOut};
 
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex, RwLock};
+use std::sync::{Arc, Condvar, Mutex, RwLock};
 
 pub struct Wallet<D>
 where
@@ -38,6 +38,7 @@ where
 	// A cache storing the most recently retrieved fee rate estimations.
 	fee_rate_cache: RwLock<HashMap<ConfirmationTarget, FeeRate>>,
 	tokio_runtime: RwLock<Option<Arc<tokio::runtime::Runtime>>>,
+	sync_lock: (Mutex<()>, Condvar),
 	logger: Arc<FilesystemLogger>,
 }
 
@@ -51,10 +52,24 @@ where
 		let inner = Mutex::new(wallet);
 		let fee_rate_cache = RwLock::new(HashMap::new());
 		let tokio_runtime = RwLock::new(None);
-		Self { blockchain, inner, fee_rate_cache, tokio_runtime, logger }
+		let sync_lock = (Mutex::new(()), Condvar::new());
+		Self { blockchain, inner, fee_rate_cache, tokio_runtime, sync_lock, logger }
 	}
 
 	pub(crate) async fn sync(&self) -> Result<(), Error> {
+		let (lock, cvar) = &self.sync_lock;
+
+		let guard = match lock.try_lock() {
+			Ok(guard) => guard,
+			Err(_) => {
+				log_info!(self.logger, "Sync in progress, skipping.");
+				let guard = cvar.wait(lock.lock().unwrap());
+				drop(guard);
+				cvar.notify_all();
+				return Ok(());
+			}
+		};
+
 		match self.update_fee_estimates().await {
 			Ok(()) => (),
 			Err(e) => {
@@ -64,13 +79,17 @@ where
 		}
 
 		let sync_options = SyncOptions { progress: None };
-		match self.inner.lock().unwrap().sync(&self.blockchain, sync_options).await {
+		let res = match self.inner.lock().unwrap().sync(&self.blockchain, sync_options).await {
 			Ok(()) => Ok(()),
 			Err(e) => {
 				log_error!(self.logger, "Wallet sync error: {}", e);
 				Err(From::from(e))
 			}
-		}
+		};
+
+		drop(guard);
+		cvar.notify_all();
+		res
 	}
 
 	pub(crate) fn set_runtime(&self, tokio_runtime: Arc<tokio::runtime::Runtime>) {