Add log_networkmap macros and others for routing bug track

Author: Antoine Riard

src/ln/router.rs

@@ -35,30 +35,31 @@ pub struct Route {
 	pub hops: Vec<RouteHop>,
 }
 
-struct DirectionalChannelInfo {
-	src_node_id: PublicKey,
-	last_update: u32,
-	enabled: bool,
-	cltv_expiry_delta: u16,
-	htlc_minimum_msat: u64,
-	fee_base_msat: u32,
-	fee_proportional_millionths: u32,
+//Here, DirectionalChannelInfo, ChannelInfo, NodeInfo and NetworkMap are pub(crate) only for log_* macros access
+pub(crate) struct DirectionalChannelInfo {
+	pub(crate) src_node_id: PublicKey,
+	pub(crate) last_update: u32,
+	pub(crate) enabled: bool,
+	pub(crate) cltv_expiry_delta: u16,
+	pub(crate) htlc_minimum_msat: u64,
+	pub(crate) fee_base_msat: u32,
+	pub(crate) fee_proportional_millionths: u32,
 }
 
-struct ChannelInfo {
-	features: GlobalFeatures,
-	one_to_two: DirectionalChannelInfo,
-	two_to_one: DirectionalChannelInfo,
+pub(crate) struct ChannelInfo {
+	pub(crate) features: GlobalFeatures,
+	pub(crate) one_to_two: DirectionalChannelInfo,
+	pub(crate) two_to_one: DirectionalChannelInfo,
 }
 
-struct NodeInfo {
+pub(crate) struct NodeInfo {
 	#[cfg(feature = "non_bitcoin_chain_hash_routing")]
 	channels: Vec<(u64, Sha256dHash)>,
 	#[cfg(not(feature = "non_bitcoin_chain_hash_routing"))]
-	channels: Vec<u64>,
+	pub(crate) channels: Vec<u64>,
 
-	lowest_inbound_channel_fee_base_msat: u32,
-	lowest_inbound_channel_fee_proportional_millionths: u32,
+	pub(crate) lowest_inbound_channel_fee_base_msat: u32,
+	pub(crate) lowest_inbound_channel_fee_proportional_millionths: u32,
 
 	features: GlobalFeatures,
 	last_update: u32,
@@ -67,14 +68,14 @@ struct NodeInfo {
 	addresses: Vec<NetAddress>,
 }
 
-struct NetworkMap {
+pub(crate) struct NetworkMap {
 	#[cfg(feature = "non_bitcoin_chain_hash_routing")]
 	channels: HashMap<(u64, Sha256dHash), ChannelInfo>,
 	#[cfg(not(feature = "non_bitcoin_chain_hash_routing"))]
-	channels: HashMap<u64, ChannelInfo>,
+	pub(crate) channels: HashMap<u64, ChannelInfo>,
 
-	our_node_id: PublicKey,
-	nodes: HashMap<PublicKey, NodeInfo>,
+	pub(crate) our_node_id: PublicKey,
+	pub(crate) nodes: HashMap<PublicKey, NodeInfo>,
 }
 
 impl NetworkMap {

src/util/macro_logger.rs

@@ -3,7 +3,7 @@ use chain::transaction::OutPoint;
 use bitcoin::util::hash::Sha256dHash;
 use secp256k1::key::PublicKey;
 
-use ln::router::Route;
+use ln::router::{Route, NetworkMap, ChannelInfo, NodeInfo, DirectionalChannelInfo};
 
 use std;
 
@@ -52,6 +52,7 @@ macro_rules! log_funding_channel_id {
 	}
 }
 
+#[allow(dead_code)]
 pub(crate) struct DebugRoute<'a>(pub &'a Route);
 impl<'a> std::fmt::Display for DebugRoute<'a> {
 	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
@@ -61,11 +62,86 @@ impl<'a> std::fmt::Display for DebugRoute<'a> {
 		Ok(())
 	}
 }
+#[allow(unused_macros)]
 macro_rules! log_route {
 	($obj: expr) => {
 		::util::macro_logger::DebugRoute(&$obj)
 	}
 }
+#[allow(dead_code)]
+pub(crate) struct DebugDirectionalChannelInfo<'a>(pub &'a DirectionalChannelInfo);
+impl<'a> std::fmt::Display for DebugDirectionalChannelInfo<'a> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+		write!(f, " node id {} last_update {} enabled {} cltv_expiry_delta {} htlc_minimum_msat {} fee_base_msat {} fee_proportional_millionths {}\n", log_pubkey!(self.0.src_node_id), self.0.last_update, self.0.enabled, self.0.cltv_expiry_delta, self.0.htlc_minimum_msat, self.0.fee_base_msat, self.0.fee_proportional_millionths)?;
+		Ok(())
+	}
+}
+#[allow(unused_macros)]
+macro_rules! log_directionalchannelinfo {
+	($obj: expr) => {
+		::util::macro_logger::DebugDirectionalChannelInfo(&$obj)
+	}
+}
+
+#[allow(dead_code)]
+pub(crate) struct DebugChannelInfo<'a>(pub &'a ChannelInfo);
+impl<'a> std::fmt::Display for DebugChannelInfo<'a> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+		//TODO: GlobalFeatures
+		write!(f, " one_to_two {}", log_directionalchannelinfo!(self.0.one_to_two))?;
+		write!(f, " two_to_one {}", log_directionalchannelinfo!(self.0.two_to_one))?;
+		Ok(())
+	}
+}
+#[allow(unused_macros)]
+macro_rules! log_channelinfo {
+	($obj: expr) => {
+		::util::macro_logger::DebugChannelInfo(&$obj)
+	}
+}
+
+#[allow(dead_code)]
+pub(crate) struct DebugNodeInfo<'a>(pub &'a NodeInfo);
+impl<'a> std::fmt::Display for DebugNodeInfo<'a> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+		write!(f, " Channels\n")?;
+		for c in self.0.channels.iter() {
+			write!(f, " {}\n", c)?;
+		}
+		write!(f, " lowest_inbound_channel_fee_base_msat {}\n", self.0.lowest_inbound_channel_fee_base_msat)?;
+		write!(f, " lowest_inbound_channel_fee_proportional_millionths {}\n", self.0.lowest_inbound_channel_fee_proportional_millionths)?;
+		//TODO: GlobalFeatures, last_update, rgb, alias, addresses
+		Ok(())
+	}
+}
+#[allow(unused_macros)]
+macro_rules! log_nodeinfo {
+	($obj: expr) => {
+		::util::macro_logger::DebugNodeInfo(&$obj)
+	}
+}
+
+#[allow(dead_code)]
+pub(crate) struct DebugNetworkMap<'a>(pub &'a NetworkMap);
+impl<'a> std::fmt::Display for DebugNetworkMap<'a> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+		write!(f, "Node id {} network map\n[Channels]\n", log_pubkey!(self.0.our_node_id))?;
+		for (key, val) in self.0.channels.iter() {
+			write!(f, " {} :\n {}\n", key, log_channelinfo!(val))?;
+		}
+		write!(f, "[Nodes]\n")?;
+		for (key, val) in self.0.nodes.iter() {
+			write!(f, " {} :\n {}\n", log_pubkey!(key), log_nodeinfo!(val))?;
+		}
+		Ok(())
+	}
+}
+#[allow(unused_macros)]
+macro_rules! log_networkmap {
+	($obj: expr) => {
+		::util::macro_logger::DebugNetworkMap(&$obj)
+	}
+}
 
 macro_rules! log_internal {
 	($self: ident, $lvl:expr, $($arg:tt)+) => (