fixup! Integrate TierStore into NodeBuilder

Refactor backup storage to local SQLite

Replaces the builder's BYO backup-store configuration with a
path-based local SQLite backup mirror. The builder now constructs the
backup store internally using a dedicated backup database file name and
rejects configurations where the backup path conflicts with the primary
storage path.

Also adds test coverage for full-cycle backup mirroring and same-path
rejection, as well as a `setup_node_with_builder` test helper to allow
builder customization in integration tests.

Author: enigbe

src/builder.rs

@@ -158,14 +158,14 @@ impl std::fmt::Debug for LogWriterConfig {
 #[derive(Default)]
 struct TierStoreConfig {
 	ephemeral: Option<Arc<DynStore>>,
-	backup: Option<Arc<DynStore>>,
+	backup_storage_dir_path: Option<PathBuf>,
 }
 
 impl std::fmt::Debug for TierStoreConfig {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.debug_struct("TierStoreConfig")
 			.field("ephemeral", &self.ephemeral.as_ref().map(|_| "Arc<DynStore>"))
-			.field("backup", &self.backup.as_ref().map(|_| "Arc<DynStore>"))
+			.field("backup_storage_dir_path", &self.backup_storage_dir_path)
 			.finish()
 	}
 }
@@ -216,6 +216,11 @@ pub enum BuildError {
 	AsyncPaymentsConfigMismatch,
 	/// An attempt to setup a DNS Resolver failed.
 	DNSResolverSetupFailed,
+	/// The configured backup storage path conflicts with the primary storage path.
+	///
+	/// Backup storage must use a distinct local directory so that the primary and
+	/// backup stores do not point to the same SQLite database.
+	BackupStorePathConflict,
 }
 
 impl fmt::Display for BuildError {
@@ -253,6 +258,12 @@ impl fmt::Display for BuildError {
 			Self::DNSResolverSetupFailed => {
 				write!(f, "An attempt to setup a DNS resolver has failed.")
 			},
+			Self::BackupStorePathConflict => {
+				write!(
+					f,
+					"The configured backup storage path conflicts with the primary storage path."
+				)
+			},
 		}
 	}
 }
@@ -644,18 +655,26 @@ impl NodeBuilder {
 		self
 	}
 
-	/// Configures the backup store for local disaster recovery.
+	/// Configures a local SQLite backup store for disaster recovery.
 	///
-	/// When building with tiered storage, this store receives a second durable
-	/// copy of data written to the primary store.
+	/// When building with tiered storage, a SQLite store will be created at the
+	/// given directory path using [`SQLITE_BACKUP_DB_FILE_NAME`] as its database
+	/// file name. It receives a second durable copy of data written to the
+	/// primary store.
 	///
 	/// Writes and removals for primary-backed data only succeed once both the
-	/// primary and backup stores complete successfully.
+	/// primary and backup SQLite stores complete successfully.
+	///
+	/// The configured path must point to a distinct local directory from the
+	/// primary storage path. If the backup path equals the primary storage path,
+	/// building will fail with [`BuildError::BackupStorePathConflict`].
 	///
 	/// If not set, durable data will be stored only in the primary store.
-	pub fn set_backup_store(&mut self, backup_store: Arc<DynStore>) -> &mut Self {
+	///
+	/// [`SQLITE_BACKUP_DB_FILE_NAME`]: crate::io::sqlite_store::SQLITE_BACKUP_DB_FILE_NAME
+	pub fn set_backup_storage_dir_path(&mut self, backup_storage_dir_path: String) -> &mut Self {
 		let tier_store_config = self.tier_store_config.get_or_insert(TierStoreConfig::default());
-		tier_store_config.backup = Some(backup_store);
+		tier_store_config.backup_storage_dir_path = Some(backup_storage_dir_path.into());
 		self
 	}
 
@@ -830,11 +849,11 @@ impl NodeBuilder {
 	///
 	/// The provided `kv_store` will be used as the primary storage backend. Optionally,
 	/// an ephemeral store for frequently-accessed non-critical data (e.g., network graph, scorer)
-	/// and a backup store for local disaster recovery can be configured via
-	/// [`set_ephemeral_store`] and [`set_backup_store`].
+	/// and a local SQLite backup store for disaster recovery can be configured via
+	/// [`set_ephemeral_store`] and [`set_backup_storage_dir_path`].
 	///
 	/// [`set_ephemeral_store`]: Self::set_ephemeral_store
-	/// [`set_backup_store`]: Self::set_backup_store
+	/// [`set_backup_storage_dir_path`]: Self::set_backup_storage_dir_path
 	pub fn build_with_store<S: SyncAndAsyncKVStore + Send + Sync + 'static>(
 		&self, node_entropy: NodeEntropy, kv_store: S,
 	) -> Result<Node, BuildError> {
@@ -859,7 +878,29 @@ impl NodeBuilder {
 		let mut tier_store = TierStore::new(primary_store, Arc::clone(&logger));
 		if let Some(config) = ts_config {
 			config.ephemeral.as_ref().map(|s| tier_store.set_ephemeral_store(Arc::clone(s)));
-			config.backup.as_ref().map(|s| tier_store.set_backup_store(Arc::clone(s)));
+			if let Some(backup_storage_dir_path) = config.backup_storage_dir_path.as_ref() {
+				let primary_storage_dir_path = PathBuf::from(&self.config.storage_dir_path);
+				if primary_storage_dir_path == *backup_storage_dir_path {
+					log_error!(
+						logger,
+						"Backup storage path must differ from primary storage path: {}",
+						backup_storage_dir_path.display()
+					);
+					return Err(BuildError::BackupStorePathConflict);
+				}
+
+				let backup_store = SqliteStore::new(
+					backup_storage_dir_path.clone(),
+					Some(io::sqlite_store::SQLITE_BACKUP_DB_FILE_NAME.to_string()),
+					Some(io::sqlite_store::KV_TABLE_NAME.to_string()),
+				)
+				.map_err(|e| {
+					log_error!(logger, "Failed to setup backup SQLite store: {}", e);
+					BuildError::KVStoreSetupFailed
+				})?;
+				let backup_store: Arc<DynStore> = Arc::new(DynStoreWrapper(backup_store));
+				tier_store.set_backup_store(backup_store);
+			}
 		}
 
 		let seed_bytes = node_entropy.to_seed_bytes();

src/io/sqlite_store/mod.rs

@@ -26,6 +26,8 @@ mod migrations;
 
 /// LDK Node's database file name.
 pub const SQLITE_DB_FILE_NAME: &str = "ldk_node_data.sqlite";
+/// LDK Node's backup database file name.
+pub const SQLITE_BACKUP_DB_FILE_NAME: &str = "ldk_node_data_backup.sqlite";
 /// LDK Node's table in which we store all data.
 pub const KV_TABLE_NAME: &str = "ldk_node_data";
 

tests/common/mod.rs

@@ -527,7 +527,17 @@ pub(crate) fn setup_two_nodes_with_store(
 }
 
 pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) -> TestNode {
+	setup_node_with_builder(chain_source, config, |_| {})
+}
+
+pub(crate) fn setup_node_with_builder<F>(
+	chain_source: &TestChainSource, config: TestConfig, configure_builder: F,
+) -> TestNode
+where
+	F: FnOnce(&mut Builder),
+{
 	setup_builder!(builder, config.node_config);
+
 	match chain_source {
 		TestChainSource::Esplora(electrsd) => {
 			let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
@@ -586,6 +596,8 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 		builder.set_wallet_recovery_mode();
 	}
 
+	configure_builder(&mut builder);
+
 	let node = match config.store_type {
 		TestStoreType::TestSyncStore => {
 			let kv_store = TestSyncStore::new(config.node_config.storage_dir_path.into());
@@ -594,10 +606,6 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 		TestStoreType::Sqlite => builder.build(config.node_entropy.into()).unwrap(),
 	};
 
-	if config.recovery_mode {
-		builder.set_wallet_recovery_mode();
-	}
-
 	node.start().unwrap();
 	assert!(node.status().is_running);
 	assert!(node.status().latest_fee_rate_cache_update_timestamp.is_some());

tests/integration_tests_rust.rs

@@ -30,6 +30,7 @@ use electrsd::corepc_node::Node as BitcoinD;
 use electrsd::ElectrsD;
 use ldk_node::config::{AsyncPaymentsRole, EsploraSyncConfig};
 use ldk_node::entropy::NodeEntropy;
+use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::liquidity::LSPS2ServiceConfig;
 use ldk_node::payment::{
 	ConfirmationStatus, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,
@@ -39,6 +40,7 @@ use ldk_node::{Builder, Event, NodeError};
 use lightning::ln::channelmanager::PaymentId;
 use lightning::routing::gossip::{NodeAlias, NodeId};
 use lightning::routing::router::RouteParametersConfig;
+use lightning::util::persist::KVStoreSync;
 use lightning_invoice::{Bolt11InvoiceDescription, Description};
 use lightning_types::payment::{PaymentHash, PaymentPreimage};
 use log::LevelFilter;
@@ -2957,3 +2959,75 @@ async fn splice_in_with_all_balance() {
 	node_a.stop().unwrap();
 	node_b.stop().unwrap();
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn builder_configures_sqlite_backup_store() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = random_chain_source(&bitcoind, &electrsd);
+
+	let mut config_a = random_config(true);
+	config_a.store_type = TestStoreType::Sqlite;
+	let primary_dir = config_a.node_config.storage_dir_path.clone();
+	let backup_dir = common::random_storage_path();
+	let node_a = common::setup_node_with_builder(&chain_source, config_a.clone(), |builder| {
+		builder.set_backup_storage_dir_path(backup_dir.to_str().unwrap().to_owned());
+	});
+
+	let config_b = random_config(true);
+	let node_b = setup_node(&chain_source, config_b);
+
+	do_channel_full_cycle(
+		node_a,
+		node_b,
+		&bitcoind.client,
+		&electrsd.client,
+		false,
+		true,
+		true,
+		false,
+	)
+	.await;
+
+	let primary_store = SqliteStore::new(
+		primary_dir.into(),
+		Some(ldk_node::io::sqlite_store::SQLITE_DB_FILE_NAME.to_string()),
+		Some(ldk_node::io::sqlite_store::KV_TABLE_NAME.to_string()),
+	)
+	.unwrap();
+
+	let backup_store = SqliteStore::new(
+		backup_dir,
+		Some(ldk_node::io::sqlite_store::SQLITE_BACKUP_DB_FILE_NAME.to_string()),
+		Some(ldk_node::io::sqlite_store::KV_TABLE_NAME.to_string()),
+	)
+	.unwrap();
+
+	for (pn, sn, key) in [
+		("bdk_wallet", "", "descriptor"),
+		("bdk_wallet", "", "change_descriptor"),
+		("bdk_wallet", "", "network"),
+		("", "", "node_metrics"),
+		("", "", "events"),
+		("", "", "peers"),
+	] {
+		let primary = KVStoreSync::read(&primary_store, pn, sn, key).unwrap();
+		let backup = KVStoreSync::read(&backup_store, pn, sn, key).unwrap();
+
+		assert_eq!(backup, primary, "backup mismatch for {pn}/{sn}/{key}");
+	}
+}
+
+#[test]
+fn sqlite_backup_rejects_primary_storage_path() {
+	let mut config = random_config(false);
+	config.store_type = TestStoreType::Sqlite;
+
+	let primary_dir = config.node_config.storage_dir_path.clone();
+
+	setup_builder!(builder, config.node_config);
+	builder.set_backup_storage_dir_path(primary_dir);
+
+	let res = builder.build(config.node_entropy.into());
+
+	assert!(matches!(res, Err(ldk_node::BuildError::BackupStorePathConflict)));
+}