Create a module for receiving updates about network graph

Separate the logic handling messages regarding nodes and channels
from route construction.

Author: naumenkogs

lightning/src/lib.rs

@@ -9,7 +9,7 @@
 //! generated/etc. This makes it a good candidate for tight integration into an existing wallet
 //! instead of having a rather-separate lightning appendage to a wallet.
 
-#![cfg_attr(not(feature = "fuzztarget"), deny(missing_docs))]
+// #![cfg_attr(not(feature = "fuzztarget"), deny(missing_docs))]
 #![forbid(unsafe_code)]
 
 // In general, rust is absolutely horrid at supporting users doing things like,

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -6,7 +6,8 @@ use chain::transaction::OutPoint;
 use chain::keysinterface::KeysInterface;
 use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure};
 use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
-use ln::router::{Route, Router, RouterReadArgs};
+use ln::router::{Route, Router};
+use ln::network_graph_monitor::{NetworkGraphMonitor, NetworkGraphMonitorReadArgs};
 use ln::features::InitFeatures;
 use ln::msgs;
 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
@@ -83,6 +84,7 @@ pub struct Node<'a, 'b: 'a, 'c: 'b> {
 	pub keys_manager: &'b test_utils::TestKeysInterface,
 	pub node: &'a ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>,
 	pub router: Router,
+	pub network_graph_monitor: NetworkGraphMonitor,
 	pub node_seed: [u8; 32],
 	pub network_payment_count: Rc<RefCell<u8>>,
 	pub network_chan_count: Rc<RefCell<u32>>,
@@ -100,15 +102,15 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			// Check that if we serialize the Router, we can deserialize it again.
 			{
 				let mut w = test_utils::TestVecWriter(Vec::new());
-				self.router.write(&mut w).unwrap();
-				let deserialized_router = Router::read(&mut ::std::io::Cursor::new(&w.0), RouterReadArgs {
+				self.network_graph_monitor.write(&mut w).unwrap();
+				let network_graph_monitor = NetworkGraphMonitor::read(&mut ::std::io::Cursor::new(&w.0), NetworkGraphMonitorReadArgs {
 					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.router.get_next_channel_announcements(chan_progress, 255);
-					let deserialized_announcements = deserialized_router.get_next_channel_announcements(chan_progress, 255);
+					let orig_announcements = self.network_graph_monitor.get_next_channel_announcements(chan_progress, 255);
+					let deserialized_announcements = network_graph_monitor.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,
@@ -117,8 +119,8 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 				}
 				let mut node_progress = None;
 				loop {
-					let orig_announcements = self.router.get_next_node_announcements(node_progress.as_ref(), 255);
-					let deserialized_announcements = deserialized_router.get_next_node_announcements(node_progress.as_ref(), 255);
+					let orig_announcements = self.network_graph_monitor.get_next_node_announcements(node_progress.as_ref(), 255);
+					let deserialized_announcements = network_graph_monitor.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),
@@ -456,11 +458,11 @@ pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a
 	};
 
 	for node in nodes {
-		assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap());
-		node.router.handle_channel_update(&chan_announcement.1).unwrap();
-		node.router.handle_channel_update(&chan_announcement.2).unwrap();
-		node.router.handle_node_announcement(&a_node_announcement).unwrap();
-		node.router.handle_node_announcement(&b_node_announcement).unwrap();
+		assert!(node.network_graph_monitor.handle_channel_announcement(&chan_announcement.0).unwrap());
+		node.network_graph_monitor.handle_channel_update(&chan_announcement.1).unwrap();
+		node.network_graph_monitor.handle_channel_update(&chan_announcement.2).unwrap();
+		node.network_graph_monitor.handle_node_announcement(&a_node_announcement).unwrap();
+		node.network_graph_monitor.handle_node_announcement(&b_node_announcement).unwrap();
 	}
 	(chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
 }
@@ -934,7 +936,8 @@ pub fn claim_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route:
 pub const TEST_FINAL_CLTV: u32 = 32;
 
 pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
-	let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
+	let network = &origin_node.network_graph_monitor.network_map.read().unwrap();
+	let route = origin_node.router.get_route(network, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
@@ -945,7 +948,8 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route:
 }
 
 pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64)  {
-	let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
+	let network = &origin_node.network_graph_monitor.network_map.read().unwrap();
+	let route = origin_node.router.get_route(network, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
@@ -1087,11 +1091,12 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
 		let block_notifier = chaininterface::BlockNotifier::new(cfgs[i].chain_monitor.clone());
 		block_notifier.register_listener(&cfgs[i].chan_monitor.simple_monitor as &chaininterface::ChainListener);
 		block_notifier.register_listener(&chan_mgrs[i] as &chaininterface::ChainListener);
-		let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &cfgs[i].keys_manager.get_node_secret()), cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
+		let network_graph_monitor = NetworkGraphMonitor::new(PublicKey::from_secret_key(&secp_ctx, &cfgs[i].keys_manager.get_node_secret()), cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
+		let router = Router::new(cfgs[i].logger.clone() as Arc<Logger>);
 		nodes.push(Node{ chain_monitor: cfgs[i].chain_monitor.clone(), block_notifier,
 										 tx_broadcaster: cfgs[i].tx_broadcaster, chan_monitor: &cfgs[i].chan_monitor,
-										 keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], router,
-										 node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
+										 keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], network_graph_monitor,
+										 router, node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
 										 network_payment_count: payment_count.clone(), logger: cfgs[i].logger.clone(),
 		})
 	}
@@ -1222,8 +1227,8 @@ pub fn get_announce_close_broadcast_events<'a, 'b, 'c>(nodes: &Vec<Node<'a, 'b,
 	};
 
 	for node in nodes {
-		node.router.handle_channel_update(&as_update).unwrap();
-		node.router.handle_channel_update(&bs_update).unwrap();
+		node.network_graph_monitor.handle_channel_update(&as_update).unwrap();
+		node.network_graph_monitor.handle_channel_update(&bs_update).unwrap();
 	}
 }