Remove NetGraphMsgHandler serialization

Author: naumenkogs

lightning/src/ln/functional_test_utils.rs

@@ -7,7 +7,7 @@ use chain::keysinterface::KeysInterface;
 use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure};
 use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
 use routing::router::{Route, get_route};
-use routing::network_graph::{NetGraphMsgHandler, NetGraphMsgHandlerReadArgs};
+use routing::network_graph::{NetGraphMsgHandler};
 use ln::features::InitFeatures;
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
@@ -99,36 +99,6 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			assert!(self.node.get_and_clear_pending_events().is_empty());
 			assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty());
 
-			// Check that if we serialize the Router, we can deserialize it again.
-			{
-				let mut w = test_utils::TestVecWriter(Vec::new());
-				self.net_graph_msg_handler.write(&mut w).unwrap();
-				let net_graph_msg_handler = NetGraphMsgHandler::read(&mut ::std::io::Cursor::new(&w.0), NetGraphMsgHandlerReadArgs {
-					chain_monitor: Arc::clone(&self.chain_monitor) as Arc<chaininterface::ChainWatchInterface>,
-					logger: Arc::clone(&self.logger) as Arc<Logger>
-				}).unwrap();
-				let mut chan_progress = 0;
-				loop {
-					let orig_announcements = self.net_graph_msg_handler.get_next_channel_announcements(chan_progress, 255);
-					let deserialized_announcements = net_graph_msg_handler.get_next_channel_announcements(chan_progress, 255);
-					assert!(orig_announcements == deserialized_announcements);
-					chan_progress = match orig_announcements.last() {
-						Some(announcement) => announcement.0.contents.short_channel_id + 1,
-						None => break,
-					};
-				}
-				let mut node_progress = None;
-				loop {
-					let orig_announcements = self.net_graph_msg_handler.get_next_node_announcements(node_progress.as_ref(), 255);
-					let deserialized_announcements = net_graph_msg_handler.get_next_node_announcements(node_progress.as_ref(), 255);
-					assert!(orig_announcements == deserialized_announcements);
-					node_progress = match orig_announcements.last() {
-						Some(announcement) => Some(announcement.contents.node_id),
-						None => break,
-					};
-				}
-			}
-
 			// Check that if we serialize and then deserialize all our channel monitors we get the
 			// same set of outputs to watch for on chain as we have now. Note that if we write
 			// tests that fully close channels and remove the monitors at some point this may break.

lightning/src/routing/network_graph.rs

@@ -198,53 +198,6 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 	}
 }
 
-
-const SERIALIZATION_VERSION: u8 = 1;
-const MIN_SERIALIZATION_VERSION: u8 = 1;
-
-impl Writeable for NetGraphMsgHandler {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
-		writer.write_all(&[SERIALIZATION_VERSION; 1])?;
-		writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?;
-
-		let network = self.network_graph.read().unwrap();
-		network.write(writer)?;
-		Ok(())
-	}
-}
-
-/// Arguments for the creation of a NetGraphMsgHandler that are not deserialized.
-/// At a high-level, the process for deserializing a NetGraphMsgHandler and resuming normal operation is:
-/// 1) Deserialize the NetGraphMsgHandler by filling in this struct and calling <NetGraphMsgHandler>::read(reaser, args).
-/// 2) Register the new NetGraphMsgHandler with your ChainWatchInterface
-pub struct NetGraphMsgHandlerReadArgs {
-	/// The ChainWatchInterface for use in the NetGraphMsgHandler in the future.
-	///
-	/// No calls to the ChainWatchInterface will be made during deserialization.
-	pub chain_monitor: Arc<ChainWatchInterface>,
-	/// The Logger for use in the ChannelManager and which may be used to log information during
-	/// deserialization.
-	pub logger: Arc<Logger>,
-}
-
-impl ReadableArgs<NetGraphMsgHandlerReadArgs> for NetGraphMsgHandler {
-	fn read<R: ::std::io::Read>(reader: &mut R, args: NetGraphMsgHandlerReadArgs) -> Result<NetGraphMsgHandler, DecodeError> {
-		let _ver: u8 = Readable::read(reader)?;
-		let min_ver: u8 = Readable::read(reader)?;
-		if min_ver > SERIALIZATION_VERSION {
-			return Err(DecodeError::UnknownVersion);
-		}
-		let network_graph = Readable::read(reader)?;
-		Ok(NetGraphMsgHandler {
-			secp_ctx: Secp256k1::verification_only(),
-			network_graph: RwLock::new(network_graph),
-			chain_monitor: args.chain_monitor,
-			full_syncs_requested: AtomicUsize::new(0),
-			logger: args.logger.clone(),
-		})
-	}
-}
-
 #[derive(PartialEq, Debug)]
 /// Details regarding one direction of a channel
 pub struct DirectionalChannelInfo {