Merge pull request #1149 from jkczyz/2021-11-network-graph

Shared ownership of NetworkGraph

Author: TheBlueMatt

fuzz/src/full_stack.rs

@@ -161,7 +161,7 @@ type ChannelMan = ChannelManager<
 	EnforcingSigner,
 	Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
 	Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>, Arc<dyn Logger>>;
-type PeerMan<'a> = PeerManager<Peer<'a>, Arc<ChannelMan>, Arc<NetGraphMsgHandler<Arc<dyn chain::Access>, Arc<dyn Logger>>>, Arc<dyn Logger>, IgnoringMessageHandler>;
+type PeerMan<'a> = PeerManager<Peer<'a>, Arc<ChannelMan>, Arc<NetGraphMsgHandler<Arc<NetworkGraph>, Arc<dyn chain::Access>, Arc<dyn Logger>>>, Arc<dyn Logger>, IgnoringMessageHandler>;
 
 struct MoneyLossDetector<'a> {
 	manager: Arc<ChannelMan>,
@@ -380,8 +380,8 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 	};
 	let channelmanager = Arc::new(ChannelManager::new(fee_est.clone(), monitor.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config, params));
 	let our_id = PublicKey::from_secret_key(&Secp256k1::signing_only(), &keys_manager.get_node_secret());
-	let network_graph = NetworkGraph::new(genesis_block(network).block_hash());
-	let net_graph_msg_handler = Arc::new(NetGraphMsgHandler::new(network_graph, None, Arc::clone(&logger)));
+	let network_graph = Arc::new(NetworkGraph::new(genesis_block(network).block_hash()));
+	let net_graph_msg_handler = Arc::new(NetGraphMsgHandler::new(Arc::clone(&network_graph), None, Arc::clone(&logger)));
 	let scorer = Scorer::with_fixed_penalty(0);
 
 	let peers = RefCell::new([false; 256]);
@@ -444,7 +444,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 					final_value_msat,
 					final_cltv_expiry_delta: 42,
 				};
-				let route = match find_route(&our_id, &params, &net_graph_msg_handler.network_graph, None, Arc::clone(&logger), &scorer) {
+				let route = match find_route(&our_id, &params, &network_graph, None, Arc::clone(&logger), &scorer) {
 					Ok(route) => route,
 					Err(_) => return,
 				};
@@ -467,7 +467,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 					final_value_msat,
 					final_cltv_expiry_delta: 42,
 				};
-				let mut route = match find_route(&our_id, &params, &net_graph_msg_handler.network_graph, None, Arc::clone(&logger), &scorer) {
+				let mut route = match find_route(&our_id, &params, &network_graph, None, Arc::clone(&logger), &scorer) {
 					Ok(route) => route,
 					Err(_) => return,
 				};

lightning-background-processor/src/lib.rs

@@ -15,7 +15,7 @@ use lightning::chain::keysinterface::{Sign, KeysInterface};
 use lightning::ln::channelmanager::ChannelManager;
 use lightning::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler};
 use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor};
-use lightning::routing::network_graph::NetGraphMsgHandler;
+use lightning::routing::network_graph::{NetworkGraph, NetGraphMsgHandler};
 use lightning::util::events::{Event, EventHandler, EventsProvider};
 use lightning::util::logger::Logger;
 use std::sync::Arc;
@@ -103,7 +103,8 @@ ChannelManagerPersister<Signer, M, T, K, F, L> for Fun where
 /// Decorates an [`EventHandler`] with common functionality provided by standard [`EventHandler`]s.
 struct DecoratingEventHandler<
 	E: EventHandler,
-	N: Deref<Target = NetGraphMsgHandler<A, L>>,
+	N: Deref<Target = NetGraphMsgHandler<G, A, L>>,
+	G: Deref<Target = NetworkGraph>,
 	A: Deref,
 	L: Deref,
 >
@@ -114,10 +115,11 @@ where A::Target: chain::Access, L::Target: Logger {
 
 impl<
 	E: EventHandler,
-	N: Deref<Target = NetGraphMsgHandler<A, L>>,
+	N: Deref<Target = NetGraphMsgHandler<G, A, L>>,
+	G: Deref<Target = NetworkGraph>,
 	A: Deref,
 	L: Deref,
-> EventHandler for DecoratingEventHandler<E, N, A, L>
+> EventHandler for DecoratingEventHandler<E, N, G, A, L>
 where A::Target: chain::Access, L::Target: Logger {
 	fn handle_event(&self, event: &Event) {
 		if let Some(event_handler) = &self.net_graph_msg_handler {
@@ -168,6 +170,7 @@ impl BackgroundProcessor {
 		T: 'static + Deref + Send + Sync,
 		K: 'static + Deref + Send + Sync,
 		F: 'static + Deref + Send + Sync,
+		G: 'static + Deref<Target = NetworkGraph> + Send + Sync,
 		L: 'static + Deref + Send + Sync,
 		P: 'static + Deref + Send + Sync,
 		Descriptor: 'static + SocketDescriptor + Send + Sync,
@@ -177,7 +180,7 @@ impl BackgroundProcessor {
 		CMP: 'static + Send + ChannelManagerPersister<Signer, CW, T, K, F, L>,
 		M: 'static + Deref<Target = ChainMonitor<Signer, CF, T, F, L, P>> + Send + Sync,
 		CM: 'static + Deref<Target = ChannelManager<Signer, CW, T, K, F, L>> + Send + Sync,
-		NG: 'static + Deref<Target = NetGraphMsgHandler<CA, L>> + Send + Sync,
+		NG: 'static + Deref<Target = NetGraphMsgHandler<G, CA, L>> + Send + Sync,
 		UMH: 'static + Deref + Send + Sync,
 		PM: 'static + Deref<Target = PeerManager<Descriptor, CMH, RMH, L, UMH>> + Send + Sync,
 	>(
@@ -340,11 +343,12 @@ mod tests {
 
 	struct Node {
 		node: Arc<SimpleArcChannelManager<ChainMonitor, test_utils::TestBroadcaster, test_utils::TestFeeEstimator, test_utils::TestLogger>>,
-		net_graph_msg_handler: Option<Arc<NetGraphMsgHandler<Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>>>,
+		net_graph_msg_handler: Option<Arc<NetGraphMsgHandler<Arc<NetworkGraph>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>>>,
 		peer_manager: Arc<PeerManager<TestDescriptor, Arc<test_utils::TestChannelMessageHandler>, Arc<test_utils::TestRoutingMessageHandler>, Arc<test_utils::TestLogger>, IgnoringMessageHandler>>,
 		chain_monitor: Arc<ChainMonitor>,
 		persister: Arc<FilesystemPersister>,
 		tx_broadcaster: Arc<test_utils::TestBroadcaster>,
+		network_graph: Arc<NetworkGraph>,
 		logger: Arc<test_utils::TestLogger>,
 		best_block: BestBlock,
 	}
@@ -382,11 +386,11 @@ mod tests {
 			let best_block = BestBlock::from_genesis(network);
 			let params = ChainParameters { network, best_block };
 			let manager = Arc::new(ChannelManager::new(fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), keys_manager.clone(), UserConfig::default(), params));
-			let network_graph = NetworkGraph::new(genesis_block.header.block_hash());
-			let net_graph_msg_handler = Some(Arc::new(NetGraphMsgHandler::new(network_graph, Some(chain_source.clone()), logger.clone())));
+			let network_graph = Arc::new(NetworkGraph::new(genesis_block.header.block_hash()));
+			let net_graph_msg_handler = Some(Arc::new(NetGraphMsgHandler::new(network_graph.clone(), Some(chain_source.clone()), logger.clone())));
 			let msg_handler = MessageHandler { chan_handler: Arc::new(test_utils::TestChannelMessageHandler::new()), route_handler: Arc::new(test_utils::TestRoutingMessageHandler::new() )};
 			let peer_manager = Arc::new(PeerManager::new(msg_handler, keys_manager.get_node_secret(), &seed, logger.clone(), IgnoringMessageHandler{}));
-			let node = Node { node: manager, net_graph_msg_handler, peer_manager, chain_monitor, persister, tx_broadcaster, logger, best_block };
+			let node = Node { node: manager, net_graph_msg_handler, peer_manager, chain_monitor, persister, tx_broadcaster, network_graph, logger, best_block };
 			nodes.push(node);
 		}
 
@@ -630,8 +634,7 @@ mod tests {
 		// Initiate the background processors to watch each node.
 		let data_dir = nodes[0].persister.get_data_dir();
 		let persister = move |node: &ChannelManager<InMemorySigner, Arc<ChainMonitor>, Arc<test_utils::TestBroadcaster>, Arc<KeysManager>, Arc<test_utils::TestFeeEstimator>, Arc<test_utils::TestLogger>>| FilesystemPersister::persist_manager(data_dir.clone(), node);
-		let network_graph = Arc::new(NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash()));
-		let router = DefaultRouter::new(network_graph, Arc::clone(&nodes[0].logger));
+		let router = DefaultRouter::new(Arc::clone(&nodes[0].network_graph), Arc::clone(&nodes[0].logger));
 		let scorer = Arc::new(Mutex::new(Scorer::default()));
 		let invoice_payer = Arc::new(InvoicePayer::new(Arc::clone(&nodes[0].node), router, scorer, Arc::clone(&nodes[0].logger), |_: &_| {}, RetryAttempts(2)));
 		let event_handler = Arc::clone(&invoice_payer);

lightning-invoice/src/utils.rs

@@ -181,7 +181,7 @@ mod test {
 			final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
 		};
 		let first_hops = nodes[0].node.list_usable_channels();
-		let network_graph = &nodes[0].net_graph_msg_handler.network_graph;
+		let network_graph = node_cfgs[0].network_graph;
 		let logger = test_utils::TestLogger::new();
 		let scorer = Scorer::with_fixed_penalty(0);
 		let route = find_route(

lightning/src/ln/channelmanager.rs

@@ -6338,8 +6338,8 @@ mod tests {
 			final_cltv_expiry_delta: TEST_FINAL_CLTV,
 		};
 		let route = find_route(
-			&nodes[0].node.get_our_node_id(), &params,
-			&nodes[0].net_graph_msg_handler.network_graph, None, nodes[0].logger, &scorer
+			&nodes[0].node.get_our_node_id(), &params, nodes[0].network_graph, None,
+			nodes[0].logger, &scorer
 		).unwrap();
 		nodes[0].node.send_spontaneous_payment(&route, Some(payment_preimage)).unwrap();
 		check_added_monitors!(nodes[0], 1);
@@ -6369,8 +6369,8 @@ mod tests {
 		// To start (2), send a keysend payment but don't claim it.
 		let payment_preimage = PaymentPreimage([42; 32]);
 		let route = find_route(
-			&nodes[0].node.get_our_node_id(), &params,
-			&nodes[0].net_graph_msg_handler.network_graph, None, nodes[0].logger, &scorer
+			&nodes[0].node.get_our_node_id(), &params, nodes[0].network_graph, None,
+			nodes[0].logger, &scorer
 		).unwrap();
 		let (payment_hash, _) = nodes[0].node.send_spontaneous_payment(&route, Some(payment_preimage)).unwrap();
 		check_added_monitors!(nodes[0], 1);
@@ -6428,7 +6428,7 @@ mod tests {
 			final_value_msat: 10000,
 			final_cltv_expiry_delta: 40,
 		};
-		let network_graph = &nodes[0].net_graph_msg_handler.network_graph;
+		let network_graph = nodes[0].network_graph;
 		let first_hops = nodes[0].node.list_usable_channels();
 		let scorer = Scorer::with_fixed_penalty(0);
 		let route = find_route(
@@ -6471,7 +6471,7 @@ mod tests {
 			final_value_msat: 10000,
 			final_cltv_expiry_delta: 40,
 		};
-		let network_graph = &nodes[0].net_graph_msg_handler.network_graph;
+		let network_graph = nodes[0].network_graph;
 		let first_hops = nodes[0].node.list_usable_channels();
 		let scorer = Scorer::with_fixed_penalty(0);
 		let route = find_route(

lightning/src/ln/functional_test_utils.rs

@@ -190,6 +190,7 @@ pub struct TestChanMonCfg {
 	pub persister: test_utils::TestPersister,
 	pub logger: test_utils::TestLogger,
 	pub keys_manager: test_utils::TestKeysInterface,
+	pub network_graph: NetworkGraph,
 }
 
 pub struct NodeCfg<'a> {
@@ -199,6 +200,7 @@ pub struct NodeCfg<'a> {
 	pub chain_monitor: test_utils::TestChainMonitor<'a>,
 	pub keys_manager: &'a test_utils::TestKeysInterface,
 	pub logger: &'a test_utils::TestLogger,
+	pub network_graph: &'a NetworkGraph,
 	pub node_seed: [u8; 32],
 	pub features: InitFeatures,
 }
@@ -209,7 +211,8 @@ pub struct Node<'a, 'b: 'a, 'c: 'b> {
 	pub chain_monitor: &'b test_utils::TestChainMonitor<'c>,
 	pub keys_manager: &'b test_utils::TestKeysInterface,
 	pub node: &'a ChannelManager<EnforcingSigner, &'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestLogger>,
-	pub net_graph_msg_handler: NetGraphMsgHandler<&'c test_utils::TestChainSource, &'c test_utils::TestLogger>,
+	pub network_graph: &'c NetworkGraph,
+	pub net_graph_msg_handler: NetGraphMsgHandler<&'c NetworkGraph, &'c test_utils::TestChainSource, &'c test_utils::TestLogger>,
 	pub node_seed: [u8; 32],
 	pub network_payment_count: Rc<RefCell<u8>>,
 	pub network_chan_count: Rc<RefCell<u32>>,
@@ -240,12 +243,11 @@ 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());
-				let network_graph_ser = &self.net_graph_msg_handler.network_graph;
-				network_graph_ser.write(&mut w).unwrap();
+				self.network_graph.write(&mut w).unwrap();
 				let network_graph_deser = <NetworkGraph>::read(&mut io::Cursor::new(&w.0)).unwrap();
-				assert!(network_graph_deser == self.net_graph_msg_handler.network_graph);
+				assert!(network_graph_deser == *self.network_graph);
 				let net_graph_msg_handler = NetGraphMsgHandler::new(
-					network_graph_deser, Some(self.chain_source), self.logger
+					&network_graph_deser, Some(self.chain_source), self.logger
 				);
 				let mut chan_progress = 0;
 				loop {
@@ -1014,10 +1016,9 @@ macro_rules! get_route_and_payment_hash {
 		let payee = $crate::routing::router::Payee::new($recv_node.node.get_our_node_id())
 			.with_features($crate::ln::features::InvoiceFeatures::known())
 			.with_route_hints($last_hops);
-		let net_graph_msg_handler = &$send_node.net_graph_msg_handler;
 		let scorer = ::routing::scorer::Scorer::with_fixed_penalty(0);
 		let route = ::routing::router::get_route(
-			&$send_node.node.get_our_node_id(), &payee, &net_graph_msg_handler.network_graph,
+			&$send_node.node.get_our_node_id(), &payee, $send_node.network_graph,
 			Some(&$send_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
 			$recv_value, $cltv, $send_node.logger, &scorer
 		).unwrap();
@@ -1352,10 +1353,9 @@ pub const TEST_FINAL_CLTV: u32 = 70;
 pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret) {
 	let payee = Payee::new(expected_route.last().unwrap().node.get_our_node_id())
 		.with_features(InvoiceFeatures::known());
-	let net_graph_msg_handler = &origin_node.net_graph_msg_handler;
 	let scorer = Scorer::with_fixed_penalty(0);
 	let route = get_route(
-		&origin_node.node.get_our_node_id(), &payee, &net_graph_msg_handler.network_graph,
+		&origin_node.node.get_our_node_id(), &payee, &origin_node.network_graph,
 		Some(&origin_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
 		recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer).unwrap();
 	assert_eq!(route.paths.len(), 1);
@@ -1371,9 +1371,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 payee = Payee::new(expected_route.last().unwrap().node.get_our_node_id())
 		.with_features(InvoiceFeatures::known());
-	let net_graph_msg_handler = &origin_node.net_graph_msg_handler;
 	let scorer = Scorer::with_fixed_penalty(0);
-	let route = get_route(&origin_node.node.get_our_node_id(), &payee, &net_graph_msg_handler.network_graph, None, recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer).unwrap();
+	let route = get_route(&origin_node.node.get_our_node_id(), &payee, origin_node.network_graph, None, recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer).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()) {
@@ -1499,8 +1498,9 @@ pub fn create_chanmon_cfgs(node_count: usize) -> Vec<TestChanMonCfg> {
 		let persister = test_utils::TestPersister::new();
 		let seed = [i as u8; 32];
 		let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
+		let network_graph = NetworkGraph::new(chain_source.genesis_hash);
 
-		chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator, chain_source, logger, persister, keys_manager });
+		chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator, chain_source, logger, persister, keys_manager, network_graph });
 	}
 
 	chan_mon_cfgs
@@ -1521,6 +1521,7 @@ pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMon
 			keys_manager: &chanmon_cfgs[i].keys_manager,
 			node_seed: seed,
 			features: InitFeatures::known(),
+			network_graph: &chanmon_cfgs[i].network_graph,
 		});
 	}
 
@@ -1566,15 +1567,15 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
 	let connect_style = Rc::new(RefCell::new(ConnectStyle::FullBlockViaListen));
 
 	for i in 0..node_count {
-		let network_graph = NetworkGraph::new(cfgs[i].chain_source.genesis_hash);
-		let net_graph_msg_handler = NetGraphMsgHandler::new(network_graph, None, cfgs[i].logger);
-		nodes.push(Node{ chain_source: cfgs[i].chain_source,
-		                 tx_broadcaster: cfgs[i].tx_broadcaster, chain_monitor: &cfgs[i].chain_monitor,
-		                 keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], net_graph_msg_handler,
-		                 node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
-		                 network_payment_count: payment_count.clone(), logger: cfgs[i].logger,
-		                 blocks: Arc::clone(&cfgs[i].tx_broadcaster.blocks),
-		                 connect_style: Rc::clone(&connect_style),
+		let net_graph_msg_handler = NetGraphMsgHandler::new(cfgs[i].network_graph, None, cfgs[i].logger);
+		nodes.push(Node{
+			chain_source: cfgs[i].chain_source, tx_broadcaster: cfgs[i].tx_broadcaster,
+			chain_monitor: &cfgs[i].chain_monitor, keys_manager: &cfgs[i].keys_manager,
+			node: &chan_mgrs[i], network_graph: &cfgs[i].network_graph, net_graph_msg_handler,
+			node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
+			network_payment_count: payment_count.clone(), logger: cfgs[i].logger,
+			blocks: Arc::clone(&cfgs[i].tx_broadcaster.blocks),
+			connect_style: Rc::clone(&connect_style),
 		})
 	}