Add channelmanager::Persist trait

And implement it for the FilesystemPersister.

Author: valentinewallace

lightning-persister/src/lib.rs

@@ -5,14 +5,20 @@ extern crate bitcoin;
 extern crate libc;
 
 use bitcoin::hashes::hex::ToHex;
+use crate::utils::DiskWriteable;
+use lightning::chain;
+use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use lightning::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateErr};
 use lightning::chain::channelmonitor;
-use lightning::chain::keysinterface::ChannelKeys;
+use lightning::chain::keysinterface::{ChannelKeys, KeysInterface};
 use lightning::chain::transaction::OutPoint;
+use lightning::ln::channelmanager;
+use lightning::ln::channelmanager::ChannelManager;
+use lightning::util::logger::Logger;
 use lightning::util::ser::{Writeable, Readable};
 use std::fs;
 use std::io::Error;
-use crate::utils::DiskWriteable;
+use std::sync::Arc;
 
 #[cfg(test)]
 use {
@@ -44,6 +50,12 @@ impl<ChanSigner: ChannelKeys + Writeable> DiskWriteable for ChannelMonitor<ChanS
 	}
 }
 
+impl<ChanSigner: ChannelKeys + Writeable, M: chain::Watch<Keys=ChanSigner>, T: BroadcasterInterface, K: KeysInterface<ChanKeySigner=ChanSigner>, F: FeeEstimator, L: Logger> DiskWriteable for Arc<ChannelManager<ChanSigner, Arc<M>, Arc<T>, Arc<K>, Arc<F>, Arc<L>>> {
+	fn write_to_file(&self, writer: &mut fs::File) -> Result<(), std::io::Error> {
+		self.write(writer)
+	}
+}
+
 impl FilesystemPersister {
 	/// Initialize a new FilesystemPersister and set the path to the individual channels'
 	/// files.
@@ -102,6 +114,12 @@ impl<ChanSigner: ChannelKeys + Readable + Writeable + Send + Sync> channelmonito
 	}
 }
 
+impl<ChanSigner: 'static + ChannelKeys + Writeable, M: 'static + chain::Watch<Keys=ChanSigner>, T: 'static + BroadcasterInterface, K: 'static + KeysInterface<ChanKeySigner=ChanSigner>, F: 'static + FeeEstimator, L: 'static + Logger> channelmanager::Persist<ChanSigner, M, T, K, F, L> for FilesystemPersister {
+	fn persist_manager(&self, data: Arc<ChannelManager<ChanSigner, Arc<M>, Arc<T>, Arc<K>, Arc<F>, Arc<L>>>) -> Result<(), std::io::Error> {
+		utils::write_to_file(self.path_to_channel_data.clone(), "manager".to_string(), &data)
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	extern crate lightning;

lightning/src/ln/channelmanager.rs

@@ -3536,6 +3536,23 @@ impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K:
 	}
 }
 
+/// `Persist` defines behavior for persisting the ChannelManager: this could mean writing once to
+/// disk, and/or uploading to one or more backup services. This persistence should probably happen
+/// in a background thread for running an efficient node, rather than in real time as updates occur.
+/// See [`ChannelManager::persistence_lock`] for more details.
+/// Note that restoring an outdated ChannelManager from disk runs the risk of force-closing
+/// channels.
+///
+///[`ChannelManager::persistence_lock`]: struct.ChannelManager.html#structfield.persistence_lock
+pub trait Persist<ChanSigner: 'static + ChannelKeys + Writeable, M: 'static + chain::Watch<Keys=ChanSigner>, T: 'static + BroadcasterInterface, K: 'static + KeysInterface<ChanKeySigner=ChanSigner>, F: 'static + FeeEstimator, L: 'static + Logger>: Send + Sync {
+	/// Persist a `ChannelManager`. [`ChannelManager::persistence_lock`] will signal you when this
+	/// method should be invoked. See [`ChannelManager::write`] for writing out a `ChannelManager`.
+	///
+	///[`ChannelManager::persistence_lock`]: struct.ChannelManager.html#structfield.persistence_lock
+	///[`ChannelManager::write`]: struct.ChannelManager.html#method.write
+	fn persist_manager(&self, data: Arc<ChannelManager<ChanSigner, Arc<M>, Arc<T>, Arc<K>, Arc<F>, Arc<L>>>) -> Result<(), std::io::Error>;
+}
+
 const SERIALIZATION_VERSION: u8 = 1;
 const MIN_SERIALIZATION_VERSION: u8 = 1;