wip ChannelManager persister + testing

Author: valentinewallace

lightning-persister/src/lib.rs

@@ -1,3 +1,5 @@
+pub mod manager;
+
 extern crate lightning;
 extern crate bitcoin;
 extern crate libc;
@@ -40,11 +42,11 @@ pub struct FilesystemPersister {
 }
 
 trait DiskWriteable {
-	fn write(&self, writer: &mut fs::File) -> Result<(), Error>;
+	fn write_to_file(&self, writer: &mut fs::File) -> Result<(), Error>;
 }
 
 impl<ChanSigner: ChannelKeys + Writeable> DiskWriteable for ChannelMonitor<ChanSigner> {
-	fn write(&self, writer: &mut fs::File) -> Result<(), Error> {
+	fn write_to_file(&self, writer: &mut fs::File) -> Result<(), Error> {
 		self.serialize_for_disk(writer)
 	}
 }
@@ -79,7 +81,7 @@ impl FilesystemPersister {
 			// Note that going by rust-lang/rust@d602a6b, on MacOS it is only safe to use
 			// rust stdlib 1.36 or higher.
 			let mut f = fs::File::create(&tmp_filename)?;
-			monitor.write(&mut f)?;
+			monitor.write_to_file(&mut f)?;
 			f.sync_all()?;
 		}
 		fs::rename(&tmp_filename, &filename)?;
@@ -182,7 +184,7 @@ mod tests {
 
 	struct TestWriteable{}
 	impl DiskWriteable for TestWriteable {
-		fn write(&self, writer: &mut fs::File) -> Result<(), Error> {
+		fn write_to_file(&self, writer: &mut fs::File) -> Result<(), Error> {
 			writer.write_all(&[42; 1])
 		}
 	}

lightning-persister/src/manager.rs

@@ -0,0 +1,219 @@
+use lightning::chain;
+use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
+use lightning::chain::keysinterface::InMemoryChannelKeys;
+use lightning::ln::channelmanager::{SimpleArcChannelManager};
+use lightning::util::logger::Logger;
+use lightning::util::ser::Writeable;
+use super::DiskWriteable;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::thread;
+
+#[cfg(not(target_os = "windows"))]
+use std::os::unix::io::AsRawFd;
+
+impl<M: chain::Watch<Keys=InMemoryChannelKeys>, T: BroadcasterInterface, F: FeeEstimator, L: Logger> DiskWriteable
+	for SimpleArcChannelManager<M, T, F, L> {
+	fn write_to_file(&self, writer: &mut fs::File) -> Result<(), std::io::Error> {
+		self.write(writer)
+	}
+}
+
+pub struct ManagerPersister {
+	#[cfg(test)]
+	path_to_manager: String,
+}
+
+impl ManagerPersister {
+	pub fn start<M: 'static + chain::Watch<Keys=InMemoryChannelKeys>, T: 'static + BroadcasterInterface, F: 'static + FeeEstimator, L: 'static + Logger>(filepath: String, filename: String, manager: SimpleArcChannelManager<M, T, F, L>) -> Self {
+		#[cfg(test)]
+		let saved_filepath = filepath.clone();
+
+		let mutcond = Arc::clone(&manager.persistence_lock);
+		thread::spawn(move || {
+			let &(ref mtx, ref cnd) = &*mutcond;
+			loop {
+				let mut guard = mtx.lock().unwrap();
+				while !*guard {
+					guard = cnd.wait(guard).unwrap();
+				}
+				*guard = false;
+				if let Err(e) = Self::write_manager(
+					filepath.clone(), Self::get_full_filepath(filepath.clone(), filename.clone()), &manager.clone()) {
+					println!("Errored persisting manager: {}", e);
+				};
+			}
+		});
+		Self {
+			#[cfg(test)]
+			path_to_manager: saved_filepath
+		}
+	}
+
+	fn get_full_filepath(filepath: String, filename: String) -> String {
+		let mut path = PathBuf::from(filepath);
+		path.push(filename);
+		path.to_str().unwrap().to_string()
+	}
+
+	fn write_manager(path: String, filename: String, manager: &dyn DiskWriteable) -> std::io::Result<()> {
+		fs::create_dir_all(path)?;
+		// Do a crazy dance with lots of fsync()s to be overly cautious here...
+		// We never want to end up in a state where we've lost the old data, or end up using the
+		// old data on power loss after we've returned.
+		// The way to atomically write a file on Unix platforms is:
+		// open(tmpname), write(tmpfile), fsync(tmpfile), close(tmpfile), rename(), fsync(dir)
+		// let filename = self.get_full_filepath();
+		let tmp_filename = format!("{}.tmp", filename.clone());
+
+		{
+			// Note that going by rust-lang/rust@d602a6b, on MacOS it is only safe to use
+			// rust stdlib 1.36 or higher.
+			let mut f = fs::File::create(&tmp_filename)?;
+			manager.write_to_file(&mut f)?;
+			f.sync_all()?;
+		}
+		fs::rename(&tmp_filename, &filename)?;
+		// Fsync the parent directory on Unix.
+		#[cfg(not(target_os = "windows"))]
+		{
+			let path = Path::new(&filename).parent().unwrap();
+			let dir_file = fs::OpenOptions::new().read(true).open(path)?;
+			unsafe { libc::fsync(dir_file.as_raw_fd()); }
+		}
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use bitcoin::blockdata::constants::genesis_block;
+	use bitcoin::blockdata::transaction::{Transaction, TxOut};
+	use bitcoin::network::constants::Network;
+	use lightning::chain::chainmonitor;
+	use lightning::chain::keysinterface::{InMemoryChannelKeys, KeysManager};
+	use lightning::chain::transaction::OutPoint;
+	use lightning::get_event_msg;
+	use lightning::ln::channelmanager::{ChannelManager, SimpleArcChannelManager};
+	use lightning::ln::features::{InitFeatures};
+	use lightning::ln::msgs::ChannelMessageHandler;
+	use lightning::util::config::UserConfig;
+	use lightning::util::events::{Event, EventsProvider, MessageSendEventsProvider, MessageSendEvent};
+	use lightning::util::ser::{Writeable};
+	use lightning::util::test_utils;
+	use super::ManagerPersister;
+	use crate::FilesystemPersister;
+	use std::fs;
+	use std::sync::{Arc, Mutex};
+	use std::time::Duration;
+
+	impl Drop for ManagerPersister {
+		fn drop(&mut self) {
+			// We test for invalid directory names, so it's OK if directory removal
+			// fails.
+			match fs::remove_dir_all(&self.path_to_manager) {
+				Err(e) => println!("Failed to remove test persister directory: {}", e),
+				_ => {}
+			}
+		}
+	}
+
+	type ChainMonitor = chainmonitor::ChainMonitor<InMemoryChannelKeys, Arc<test_utils::TestChainSource>, Arc<test_utils::TestBroadcaster>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>, Arc<FilesystemPersister>>;
+
+	struct Node {
+		node: SimpleArcChannelManager<ChainMonitor, test_utils::TestBroadcaster, test_utils::TestFeeEstimator, test_utils::TestLogger>,
+	}
+
+	fn create_nodes(num_nodes: usize) -> Vec<Node> {
+		let mut nodes = Vec::new();
+		for i in 0..num_nodes {
+			let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())});
+			let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
+			let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet));
+			let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
+			let monitor_persister = Arc::new(FilesystemPersister::new(format!("monitor_persister_{}", i)));
+			let seed = [i as u8; 32];
+			let network = Network::Testnet;
+			let now = Duration::from_secs(genesis_block(network).header.time as u64);
+			let keys_manager = Arc::new(KeysManager::new(&seed, network, now.as_secs(), now.subsec_nanos()));
+			let chain_monitor = Arc::new(chainmonitor::ChainMonitor::new(Some(chain_source.clone()), tx_broadcaster.clone(), logger.clone(), fee_estimator.clone(), monitor_persister));
+			let manager = Arc::new(ChannelManager::new(Network::Testnet, fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster, logger.clone(), keys_manager.clone(), UserConfig::default(), i));
+			let node = Node { node: manager };
+			nodes.push(node);
+		}
+		nodes
+	}
+
+	#[cfg(not(target_os = "windows"))]
+	#[test]
+	fn test_manager_persister() {
+		let nodes = create_nodes(2);
+
+		// Initiate the persisters to watch each node.
+		let _persister_0 = ManagerPersister::start("persister_0".to_string(), "manager".to_string(), nodes[0].node.clone());
+		let _persister_1 = ManagerPersister::start("persister_1".to_string(), "manager".to_string(), nodes[1].node.clone());
+
+		// Go through the channel creation process until each node should have something persisted.
+		let channel_value = 100000;
+		nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value, 100, 42, None).unwrap();
+		nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
+		nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()));
+
+		let events = nodes[0].node.get_and_clear_pending_events();
+		assert_eq!(events.len(), 1);
+		let (temporary_channel_id, tx, funding_output) = match events[0] {
+			Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, ref output_script, user_channel_id } => {
+				assert_eq!(*channel_value_satoshis, channel_value);
+				assert_eq!(user_channel_id, 42);
+
+				let tx = Transaction { version: 1 as i32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
+					value: *channel_value_satoshis, script_pubkey: output_script.clone(),
+				}]};
+				let funding_outpoint = OutPoint { txid: tx.txid(), index: 0 };
+				(*temporary_channel_id, tx, funding_outpoint)
+			},
+			_ => panic!("Unexpected event"),
+		};
+
+		nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
+		nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()));
+		nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()));
+
+		macro_rules! check_persisted_data {
+			($node: expr, $filepath: expr) => {
+				let bytes = loop {
+					match std::fs::read($filepath) {
+						Ok(bytes) => break bytes,
+						Err(_) => continue
+					}
+				};
+				let mut expected_bytes = Vec::new();
+				assert!($node.write(&mut expected_bytes).is_ok());
+				assert_eq!(bytes, expected_bytes);
+			}
+		}
+
+		// Check that the initial channel manager data is persisted as expected.
+		check_persisted_data!(nodes[0].node, "./persister_0/manager");
+		check_persisted_data!(nodes[1].node, "./persister_1/manager");
+
+		// Save the current bytes then trigger another update.
+		let current_bytes = std::fs::read("./persister_0/manager").unwrap();
+
+		// Force-close the channel.
+		nodes[0].node.force_close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id());
+
+		// Loop until what's written on disk changes.
+		loop {
+			match std::fs::read("./persister_0/manager") {
+				Ok(bytes) => {
+					if bytes == current_bytes { continue } else { break }
+				},
+				Err(_) => continue
+			}
+		};
+		// Make sure the update was persisted properly.
+		check_persisted_data!(nodes[0].node, "./persister_0/manager");
+	}
+}