Rename NetworkMap in NetworkGraph

Author: naumenkogs

lightning/src/routing/network_graph.rs

@@ -28,7 +28,7 @@ use std;
 pub struct NetGraphMsgHandler {
 	secp_ctx: Secp256k1<secp256k1::VerifyOnly>,
 	/// Representation of the payment channel network
-	pub network_map: RwLock<NetworkMap>,
+	pub network_graph: RwLock<NetworkGraph>,
 	chain_monitor: Arc<ChainWatchInterface>,
 	full_syncs_requested: AtomicUsize,
 	logger: Arc<Logger>,
@@ -50,7 +50,7 @@ impl NetGraphMsgHandler {
 		});
 		NetGraphMsgHandler {
 			secp_ctx: Secp256k1::verification_only(),
-			network_map: RwLock::new(NetworkMap {
+			network_graph: RwLock::new(NetworkGraph {
 				channels: BTreeMap::new(),
 				nodes: nodes,
 			}),
@@ -62,7 +62,7 @@ impl NetGraphMsgHandler {
 
 	/// Get network addresses by node id
 	pub fn get_addresses(&self, pubkey: &PublicKey) -> Option<Vec<NetAddress>> {
-		let network = self.network_map.read().unwrap();
+		let network = self.network_graph.read().unwrap();
 		network.get_nodes().get(pubkey).map(|n| n.addresses.clone())
 	}
 
@@ -71,7 +71,7 @@ impl NetGraphMsgHandler {
 			($node_id: expr) => {
 				if let BtreeEntry::Occupied(mut entry) = nodes.entry($node_id) {
 					entry.get_mut().channels.retain(|chan_id| {
-						short_channel_id != *NetworkMap::get_short_id(chan_id)
+						short_channel_id != *NetworkGraph::get_short_id(chan_id)
 					});
 					if entry.get().channels.is_empty() {
 						entry.remove_entry();
@@ -98,7 +98,7 @@ impl NetGraphMsgHandler {
 	/// Dumps the entire network view of this NetGraphMsgHandler to the logger provided in the constructor at
 	/// level Trace
 	pub fn trace_state(&self) {
-		log_trace!(self, "{}", self.network_map.read().unwrap());
+		log_trace!(self, "{}", self.network_graph.read().unwrap());
 	}
 
 }
@@ -112,7 +112,7 @@ impl Writeable for NetGraphMsgHandler {
 		writer.write_all(&[SERIALIZATION_VERSION; 1])?;
 		writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?;
 
-		let network = self.network_map.read().unwrap();
+		let network = self.network_graph.read().unwrap();
 		network.write(writer)?;
 		Ok(())
 	}
@@ -139,10 +139,10 @@ impl ReadableArgs<NetGraphMsgHandlerReadArgs> for NetGraphMsgHandler {
 		if min_ver > SERIALIZATION_VERSION {
 			return Err(DecodeError::UnknownVersion);
 		}
-		let network_map = Readable::read(reader)?;
+		let network_graph = Readable::read(reader)?;
 		Ok(NetGraphMsgHandler {
 			secp_ctx: Secp256k1::verification_only(),
-			network_map: RwLock::new(network_map),
+			network_graph: RwLock::new(network_graph),
 			chain_monitor: args.chain_monitor,
 			full_syncs_requested: AtomicUsize::new(0),
 			logger: args.logger.clone(),
@@ -347,13 +347,13 @@ impl Readable for NodeInfo {
 
 /// Represents the network as nodes and channels between them
 #[derive(PartialEq)]
-pub struct NetworkMap {
+pub struct NetworkGraph {
 	channels: BTreeMap<u64, ChannelInfo>,
 	/// A set of known Lightning nodes and their properties
 	nodes: BTreeMap<PublicKey, NodeInfo>,
 }
 
-impl NetworkMap {
+impl NetworkGraph {
 	/// Returns a list of known valid channels
 	pub fn get_channels<'a>(&'a self) -> &'a BTreeMap<u64, ChannelInfo> { &self.channels }
 	/// Returns a mutable reference to an existing channel
@@ -372,7 +372,7 @@ impl NetworkMap {
 	}
 }
 
-impl Writeable for NetworkMap {
+impl Writeable for NetworkGraph {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 		(self.channels.len() as u64).write(writer)?;
 		for (ref chan_id, ref chan_info) in self.channels.iter() {
@@ -388,8 +388,8 @@ impl Writeable for NetworkMap {
 	}
 }
 
-impl Readable for NetworkMap {
-	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<NetworkMap, DecodeError> {
+impl Readable for NetworkGraph {
+	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<NetworkGraph, DecodeError> {
 		let channels_count: u64 = Readable::read(reader)?;
 		let mut channels = BTreeMap::new();
 		for _ in 0..channels_count {
@@ -404,14 +404,14 @@ impl Readable for NetworkMap {
 			let node_info = Readable::read(reader)?;
 			nodes.insert(node_id, node_info);
 		}
-		Ok(NetworkMap {
+		Ok(NetworkGraph {
 			channels,
 			nodes,
 		})
 	}
 }
 
-impl std::fmt::Display for NetworkMap {
+impl std::fmt::Display for NetworkGraph {
 	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
 		write!(f, "Network map\n[Channels]\n")?;
 		for (key, val) in self.channels.iter() {
@@ -425,7 +425,7 @@ impl std::fmt::Display for NetworkMap {
 	}
 }
 
-impl NetworkMap {
+impl NetworkGraph {
 	#[inline]
 	/// Key used to link channel on the Bitcoin chain to other entities
 	pub fn get_key(short_channel_id: u64, _: Sha256dHash) -> u64 {
@@ -445,7 +445,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 		let msg_hash = hash_to_message!(&Sha256dHash::hash(&msg.contents.encode()[..])[..]);
 		secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.signature, &msg.contents.node_id);
 
-		let mut network = self.network_map.write().unwrap();
+		let mut network = self.network_graph.write().unwrap();
 		match network.get_node_mut(&msg.contents.node_id) {
 			None => Err(LightningError{err: "No existing channels for node_announcement", action: ErrorAction::IgnoreError}),
 			Some(node) => {
@@ -506,7 +506,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 			},
 		};
 
-		let mut network_lock = self.network_map.write().unwrap();
+		let mut network_lock = self.network_graph.write().unwrap();
 		let network = &mut *network_lock;
 
 		let should_relay = msg.contents.excess_data.is_empty();
@@ -540,7 +540,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 				announcement_message: if should_relay { Some(msg.clone()) } else { None },
 			};
 
-		match network.channels.entry(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
+		match network.channels.entry(NetworkGraph::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
 			BtreeEntry::Occupied(mut entry) => {
 				//TODO: because asking the blockchain if short_channel_id is valid is only optional
 				//in the blockchain API, we need to handle it smartly here, though it's unclear
@@ -569,11 +569,11 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 			( $node_id: expr ) => {
 				match network.nodes.entry($node_id) {
 					BtreeEntry::Occupied(node_entry) => {
-						node_entry.into_mut().channels.push(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash));
+						node_entry.into_mut().channels.push(NetworkGraph::get_key(msg.contents.short_channel_id, msg.contents.chain_hash));
 					},
 					BtreeEntry::Vacant(node_entry) => {
 						node_entry.insert(NodeInfo {
-							channels: vec!(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)),
+							channels: vec!(NetworkGraph::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)),
 							lowest_inbound_channel_fees: None,
 							features: NodeFeatures::empty(),
 							last_update: None,
@@ -600,7 +600,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 				let _ = self.handle_channel_update(msg);
 			},
 			&msgs::HTLCFailChannelUpdate::ChannelClosed { ref short_channel_id, ref is_permanent } => {
-				let mut network = self.network_map.write().unwrap();
+				let mut network = self.network_graph.write().unwrap();
 				if *is_permanent {
 					if let Some(chan) = network.channels.remove(short_channel_id) {
 						Self::remove_channel_in_nodes(&mut network.nodes, &chan, *short_channel_id);
@@ -623,12 +623,12 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 	}
 
 	fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<bool, LightningError> {
-		let mut network = self.network_map.write().unwrap();
+		let mut network = self.network_graph.write().unwrap();
 		let dest_node_id;
 		let chan_enabled = msg.contents.flags & (1 << 1) != (1 << 1);
 		let chan_was_enabled;
 
-		match network.get_channel_mut(&NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
+		match network.get_channel_mut(&NetworkGraph::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
 			None => return Err(LightningError{err: "Couldn't find channel for update", action: ErrorAction::IgnoreError}),
 			Some(channel) => {
 				macro_rules! maybe_update_channel_info {
@@ -709,7 +709,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 
 	fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(msgs::ChannelAnnouncement, Option<msgs::ChannelUpdate>, Option<msgs::ChannelUpdate>)> {
 		let mut result = Vec::with_capacity(batch_amount as usize);
-		let network = self.network_map.read().unwrap();
+		let network = self.network_graph.read().unwrap();
 		let mut iter = network.channels.range(starting_point..);
 		while result.len() < batch_amount as usize {
 			if let Some((_, ref chan)) = iter.next() {
@@ -730,7 +730,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 
 	fn get_next_node_announcements(&self, starting_point: Option<&PublicKey>, batch_amount: u8) -> Vec<msgs::NodeAnnouncement> {
 		let mut result = Vec::with_capacity(batch_amount as usize);
-		let network = self.network_map.read().unwrap();
+		let network = self.network_graph.read().unwrap();
 		let mut iter = if let Some(pubkey) = starting_point {
 				let mut iter = network.nodes.range((*pubkey)..);
 				iter.next();
@@ -767,7 +767,7 @@ impl RoutingMessageHandler for NetGraphMsgHandler {
 mod tests {
 	use chain::chaininterface;
 	use ln::features::{ChannelFeatures, NodeFeatures};
-	use routing::network_graph::{NetGraphMsgHandler, NetworkMap, DirectionalChannelInfo, ChannelInfo, NodeInfo, RoutingFees};
+	use routing::network_graph::{NetGraphMsgHandler, NetworkGraph, DirectionalChannelInfo, ChannelInfo, NodeInfo, RoutingFees};
 	use ln::msgs::{RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
 	   UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate, HTLCFailChannelUpdate};
 	use util::test_utils;
@@ -952,7 +952,7 @@ mod tests {
 			excess_data: Vec::new(),
 		};
 
-		let channel_key = NetworkMap::get_key(unsigned_announcement.short_channel_id,
+		let channel_key = NetworkGraph::get_key(unsigned_announcement.short_channel_id,
 						    unsigned_announcement.chain_hash);
 
 		let mut msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
@@ -972,7 +972,7 @@ mod tests {
 			_ => panic!()
 		};
 		{
-			let network = net_graph_msg_handler.network_map.write().unwrap();
+			let network = net_graph_msg_handler.network_graph.write().unwrap();
 			match network.channels.get(&channel_key) {
 				None => panic!(),
 				Some(_) => ()
@@ -1009,7 +1009,7 @@ mod tests {
 		// Now test if the transaction is found in the UTXO set and the script is correct.
 		unsigned_announcement.short_channel_id += 1;
 		*chain_monitor.utxo_ret.lock().unwrap() = Ok((good_script.clone(), 0));
-		let channel_key = NetworkMap::get_key(unsigned_announcement.short_channel_id,
+		let channel_key = NetworkGraph::get_key(unsigned_announcement.short_channel_id,
 						   unsigned_announcement.chain_hash);
 
 		msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
@@ -1025,7 +1025,7 @@ mod tests {
 			_ => panic!()
 		};
 		{
-			let network = net_graph_msg_handler.network_map.write().unwrap();
+			let network = net_graph_msg_handler.network_graph.write().unwrap();
 			match network.channels.get(&channel_key) {
 				None => panic!(),
 				Some(_) => ()
@@ -1056,7 +1056,7 @@ mod tests {
 			_ => panic!()
 		};
 		{
-			let mut network = net_graph_msg_handler.network_map.write().unwrap();
+			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
 			match network.channels.entry(channel_key) {
 				BtreeEntry::Occupied(channel_entry) => {
 					assert_eq!(channel_entry.get().features, ChannelFeatures::empty());
@@ -1122,7 +1122,7 @@ mod tests {
 		let zero_hash = Sha256dHash::hash(&[0; 32]);
 		let short_channel_id = 0;
 		let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
-		let channel_key = NetworkMap::get_key(short_channel_id, chain_hash);
+		let channel_key = NetworkGraph::get_key(short_channel_id, chain_hash);
 
 
 		{
@@ -1176,7 +1176,7 @@ mod tests {
 		};
 
 		{
-			let network = net_graph_msg_handler.network_map.write().unwrap();
+			let network = net_graph_msg_handler.network_graph.write().unwrap();
 			match network.channels.get(&channel_key) {
 				None => panic!(),
 				Some(channel_info) => {
@@ -1253,11 +1253,11 @@ mod tests {
 
 		let short_channel_id = 0;
 		let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
-		let channel_key = NetworkMap::get_key(short_channel_id, chain_hash);
+		let channel_key = NetworkGraph::get_key(short_channel_id, chain_hash);
 
 		{
 			// There is only local node in the table at the beginning.
-			let network = net_graph_msg_handler.network_map.read().unwrap();
+			let network = net_graph_msg_handler.network_graph.read().unwrap();
 			assert_eq!(network.nodes.len(), 1);
 			assert_eq!(network.nodes.contains_key(&our_id), true);
 		}
@@ -1299,7 +1299,7 @@ mod tests {
 
 		{
 			// Non-permanent closing just disables a channel
-			let network = net_graph_msg_handler.network_map.write().unwrap();
+			let network = net_graph_msg_handler.network_graph.write().unwrap();
 			match network.channels.get(&channel_key) {
 				None => panic!(),
 				Some(channel_info) => {
@@ -1318,7 +1318,7 @@ mod tests {
 
 		{
 			// Permanent closing deletes a channel
-			let network = net_graph_msg_handler.network_map.read().unwrap();
+			let network = net_graph_msg_handler.network_graph.read().unwrap();
 			assert_eq!(network.channels.len(), 0);
 			// Nodes are also deleted because there are no associated channels anymore
 			// Only the local node remains in the table.
@@ -1341,7 +1341,7 @@ mod tests {
 
 		let short_channel_id = 1;
 		let chain_hash = genesis_block(Network::Testnet).header.bitcoin_hash();
-		let channel_key = NetworkMap::get_key(short_channel_id, chain_hash);
+		let channel_key = NetworkGraph::get_key(short_channel_id, chain_hash);
 
 		// Channels were not announced yet.
 		let channels_with_announcements = net_graph_msg_handler.get_next_channel_announcements(0, 1);
@@ -1580,12 +1580,12 @@ mod tests {
 	}
 
 	#[test]
-	fn network_map_serialization() {
+	fn network_graph_serialization() {
 		let (secp_ctx, our_id, net_graph_msg_handler) = create_net_graph_msg_handler();
 		let node1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
 		let node1 = PublicKey::from_secret_key(&secp_ctx, node1_privkey);
 
-		let mut network = net_graph_msg_handler.network_map.write().unwrap();
+		let mut network = net_graph_msg_handler.network_graph.write().unwrap();
 		let zero_hash = Sha256dHash::hash(&[0; 32]);
 
 
@@ -1594,7 +1594,7 @@ mod tests {
 			proportional_millionths: 0,
 		};
 		network.add_node(node1.clone(), NodeInfo {
-			channels: vec!(NetworkMap::get_key(1, zero_hash.clone()), NetworkMap::get_key(3, zero_hash.clone())),
+			channels: vec!(NetworkGraph::get_key(1, zero_hash.clone()), NetworkGraph::get_key(3, zero_hash.clone())),
 			lowest_inbound_channel_fees: Some(node_routing_fees),
 			features: NodeFeatures::supported(),
 			last_update: Some(1),
@@ -1603,7 +1603,7 @@ mod tests {
 			addresses: Vec::new(),
 			announcement_message: None,
 		});
-		network.add_channel(NetworkMap::get_key(1, zero_hash.clone()), ChannelInfo {
+		network.add_channel(NetworkGraph::get_key(1, zero_hash.clone()), ChannelInfo {
 			features: ChannelFeatures::supported(),
 			one_to_two: DirectionalChannelInfo {
 				src_node_id: our_id.clone(),
@@ -1635,6 +1635,6 @@ mod tests {
 		assert!(!network.channels.is_empty());
 		assert!(!network.nodes.is_empty());
 		network.write(&mut w).unwrap();
-		assert!(<NetworkMap>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap() == *network);
+		assert!(<NetworkGraph>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap() == *network);
 	}
 }