log_debug information about network graph updates from payments

[rust-lightning] / lightning / src / routing / network_graph.rs

diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs
index c52f55a9104f1d2611f03466eb814f8beb5dc4da..2c55d0a1d525c7f16450983698f120109a0843fc 100644 (file)
--- a/lightning/src/routing/network_graph.rs
+++ b/lightning/src/routing/network_graph.rs
@@ -32,12 +32,12 @@ use util::logger::Logger;
 use util::events::{MessageSendEvent, MessageSendEventsProvider};
 use util::scid_utils::{block_from_scid, scid_from_parts, MAX_SCID_BLOCK};
 
+use prelude::*;
+use alloc::collections::{BTreeMap, btree_map::Entry as BtreeEntry};
 use core::{cmp, fmt};
 use std::sync::{RwLock, RwLockReadGuard};
 use core::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Mutex;
-use std::collections::BTreeMap;
-use std::collections::btree_map::Entry as BtreeEntry;
 use core::ops::Deref;
 use bitcoin::hashes::hex::ToHex;
 
@@ -169,12 +169,16 @@ impl<C: Deref , L: Deref > RoutingMessageHandler for NetGraphMsgHandler<C, L> wh
        fn handle_htlc_fail_channel_update(&self, update: &msgs::HTLCFailChannelUpdate) {
                match update {
                        &msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg } => {
+                               let chan_enabled = msg.contents.flags & (1 << 1) != (1 << 1);
+                               log_debug!(self.logger, "Updating channel with channel_update from a payment failure. Channel {} is {}abled.", msg.contents.short_channel_id, if chan_enabled { "en" } else { "dis" });
                                let _ = self.network_graph.write().unwrap().update_channel(msg, &self.secp_ctx);
                        },
                        &msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id, is_permanent } => {
+                               log_debug!(self.logger, "{} channel graph entry for {} due to a payment failure.", if is_permanent { "Removing" } else { "Disabling" }, short_channel_id);
                                self.network_graph.write().unwrap().close_channel_from_update(short_channel_id, is_permanent);
                        },
                        &msgs::HTLCFailChannelUpdate::NodeFailure { ref node_id, is_permanent } => {
+                               log_debug!(self.logger, "{} node graph entry for {} due to a payment failure.", if is_permanent { "Removing" } else { "Disabling" }, node_id);
                                self.network_graph.write().unwrap().fail_node(node_id, is_permanent);
                        },
                }
@@ -1067,6 +1071,7 @@ mod tests {
        use bitcoin::secp256k1::key::{PublicKey, SecretKey};
        use bitcoin::secp256k1::{All, Secp256k1};
 
+       use prelude::*;
        use std::sync::Arc;
 
        fn create_net_graph_msg_handler() -> (Secp256k1<All>, NetGraphMsgHandler<Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>) {
@@ -2423,3 +2428,30 @@ mod tests {
                assert!(result.is_err());
        }
 }
+
+#[cfg(all(test, feature = "unstable"))]
+mod benches {
+       use super::*;
+
+       use test::Bencher;
+       use std::io::Read;
+
+       #[bench]
+       fn read_network_graph(bench: &mut Bencher) {
+               let mut d = ::routing::router::test_utils::get_route_file().unwrap();
+               let mut v = Vec::new();
+               d.read_to_end(&mut v).unwrap();
+               bench.iter(|| {
+                       let _ = NetworkGraph::read(&mut std::io::Cursor::new(&v)).unwrap();
+               });
+       }
+
+       #[bench]
+       fn write_network_graph(bench: &mut Bencher) {
+               let mut d = ::routing::router::test_utils::get_route_file().unwrap();
+               let net_graph = NetworkGraph::read(&mut d).unwrap();
+               bench.iter(|| {
+                       let _ = net_graph.encode();
+               });
+       }
+}