From 2aed994877abfc77c60645d9346e7fe485fc6fd9 Mon Sep 17 00:00:00 2001 From: x Date: Mon, 2 Jan 2023 15:54:11 +0100 Subject: [PATCH] manually fix some of the net messages to remove target from the actual log string --- src/net/protocol/protocol_address.rs | 35 +++++++++++++++++++-------- src/net/protocol/protocol_ping.rs | 27 +++++++++++++-------- src/net/protocol/protocol_seed.rs | 7 ++---- src/net/protocol/protocol_version.rs | 36 ++++++++++++++++++---------- 4 files changed, 67 insertions(+), 38 deletions(-) diff --git a/src/net/protocol/protocol_address.rs b/src/net/protocol/protocol_address.rs index bd4acc1a7..e56e62cba 100644 --- a/src/net/protocol/protocol_address.rs +++ b/src/net/protocol/protocol_address.rs @@ -89,10 +89,14 @@ impl ProtocolAddress { /// address messages on the address subsciption. Adds the recieved /// addresses to the list of hosts. async fn handle_receive_addrs(self: Arc) -> Result<()> { - debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::handle_receive_addrs() [START]"); + debug!(target: "net::protocol_address::handle_receive_addrs()", "START"); loop { let addrs_msg = self.addrs_sub.receive().await?; - debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::handle_receive_addrs() received {} addrs", addrs_msg.addrs.len()); + debug!( + target: "net::protocol_address::handle_receive_addrs()", + "received {} addrs", + addrs_msg.addrs.len() + ); self.hosts.store(addrs_msg.addrs.clone()).await; } } @@ -101,10 +105,14 @@ impl ProtocolAddress { /// external address messages on the address subsciption. Adds the recieved /// external addresses to the list of hosts. async fn handle_receive_ext_addrs(self: Arc) -> Result<()> { - debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "ProtocolAddress::handle_receive_ext_addrs() [START]"); + debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "START"); loop { let ext_addrs_msg = self.ext_addrs_sub.receive().await?; - debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "ProtocolAddress::handle_receive_ext_addrs() received {} addrs", ext_addrs_msg.ext_addrs.len()); + debug!( + target: "net::protocol_address::handle_receive_ext_addrs()", + "ProtocolAddress::handle_receive_ext_addrs() received {} addrs", + ext_addrs_msg.ext_addrs.len() + ); self.hosts.store_ext(self.channel.address(), ext_addrs_msg.ext_addrs.clone()).await; } } @@ -113,17 +121,24 @@ impl ProtocolAddress { /// get-address messages on the get-address subsciption. Then replies /// with an address message. async fn handle_receive_get_addrs(self: Arc) -> Result<()> { - debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() [START]"); + debug!(target: "net::protocol_address::handle_receive_get_addrs()", "START"); loop { let _get_addrs = self.get_addrs_sub.receive().await?; - debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() received GetAddrs message"); + debug!( + target: "net::protocol_address::handle_receive_get_addrs()", + "Received GetAddrs message" + ); // Loads the list of hosts. let mut addrs = self.hosts.load_all().await; // Shuffling list of hosts addrs.shuffle(&mut rand::thread_rng()); - debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() sending {} addrs", addrs.len()); + debug!( + target: "net::protocol_address::handle_receive_get_addrs()", + "Sending {} addrs", + addrs.len() + ); // Creates an address messages containing host address. let addrs_msg = message::AddrsMessage { addrs }; // Sends the address message across the channel. @@ -132,7 +147,7 @@ impl ProtocolAddress { } async fn send_my_addrs(self: Arc) -> Result<()> { - debug!(target: "net::protocol_address::send_my_addrs()", "ProtocolAddress::send_addrs() [START]"); + debug!(target: "net::protocol_address::send_my_addrs()", "START"); loop { let ext_addrs = self.settings.external_addr.clone(); let ext_addr_msg = message::ExtAddrsMessage { ext_addrs }; @@ -157,7 +172,7 @@ impl ProtocolBase for ProtocolAddress { self.jobsman.clone().spawn(self.clone().send_my_addrs(), executor.clone()).await; } - debug!(target: "net::protocol_address::start()", "ProtocolAddress::start() [START]"); + debug!(target: "net::protocol_address::start()", "START"); self.jobsman.clone().start(executor.clone()); self.jobsman.clone().spawn(self.clone().handle_receive_addrs(), executor.clone()).await; self.jobsman.clone().spawn(self.clone().handle_receive_ext_addrs(), executor.clone()).await; @@ -166,7 +181,7 @@ impl ProtocolBase for ProtocolAddress { // Send get_address message. let get_addrs = message::GetAddrsMessage {}; let _ = self.channel.clone().send(get_addrs).await; - debug!(target: "net::protocol_address::start()", "ProtocolAddress::start() [END]"); + debug!(target: "net::protocol_address::start()", "END"); Ok(()) } diff --git a/src/net/protocol/protocol_ping.rs b/src/net/protocol/protocol_ping.rs index 3ce136483..1d3a95ff0 100644 --- a/src/net/protocol/protocol_ping.rs +++ b/src/net/protocol/protocol_ping.rs @@ -72,7 +72,7 @@ impl ProtocolPing { /// sends a ping message with a random nonce. Loop starts a timer, waits /// for the pong reply and insures the nonce is the same. async fn run_ping_pong(self: Arc) -> Result<()> { - debug!(target: "net::protocol_ping::run_ping_pong()", "ProtocolPing::run_ping_pong() [START]"); + debug!(target: "net::protocol_ping::run_ping_pong()", "START"); loop { // Wait channel_heartbeat amount of time. sleep(self.settings.channel_heartbeat_seconds.into()).await; @@ -83,7 +83,7 @@ impl ProtocolPing { // Send ping message. let ping = message::PingMessage { nonce }; self.channel.clone().send(ping).await?; - debug!(target: "net::protocol_ping::run_ping_pong()", "ProtocolPing::run_ping_pong() send Ping message"); + debug!(target: "net::protocol_ping::run_ping_pong()", "Send Ping message"); // Start the timer for ping timer. let start = Instant::now(); @@ -91,29 +91,36 @@ impl ProtocolPing { let pong_msg = self.pong_sub.receive().await?; if pong_msg.nonce != nonce { // TODO: this is too extreme - error!(target: "net::protocol_ping::run_ping_pong()", "Wrong nonce for ping reply. Disconnecting from channel."); + error!( + target: "net::protocol_ping::run_ping_pong()", + "Wrong nonce for ping reply. Disconnecting from channel." + ); self.channel.stop().await; return Err(Error::ChannelStopped) } let duration = start.elapsed().as_millis(); - debug!(target: "net::protocol_ping::run_ping_pong()", "Received Pong message {}ms from [{:?}]", - duration, self.channel.address()); + debug!( + target: "net::protocol_ping::run_ping_pong()", + "Received Pong message {}ms from [{:?}]", + duration, + self.channel.address() + ); } } /// Waits for ping, then replies with pong. Copies ping's nonce into the /// pong reply. async fn reply_to_ping(self: Arc) -> Result<()> { - debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() [START]"); + debug!(target: "net::protocol_ping::reply_to_ping()", "START"); loop { // Wait for ping, reply with pong that has a matching nonce. let ping = self.ping_sub.receive().await?; - debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() received Ping message"); + debug!(target: "net::protocol_ping::reply_to_ping()", "Received Ping message"); // Send pong message. let pong = message::PongMessage { nonce: ping.nonce }; self.channel.clone().send(pong).await?; - debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() sent Pong reply"); + debug!(target: "net::protocol_ping::reply_to_ping()", "Sent Pong reply"); } } @@ -129,11 +136,11 @@ impl ProtocolBase for ProtocolPing { /// protocol task manager, then queues the reply. Sends out a ping and /// waits for pong reply. Waits for ping and replies with a pong. async fn start(self: Arc, executor: Arc>) -> Result<()> { - debug!(target: "net::protocol_ping::start()", "ProtocolPing::start() [START]"); + debug!(target: "net::protocol_ping::start()", "START"); self.jobsman.clone().start(executor.clone()); self.jobsman.clone().spawn(self.clone().run_ping_pong(), executor.clone()).await; self.jobsman.clone().spawn(self.reply_to_ping(), executor).await; - debug!(target: "net::protocol_ping::start()", "ProtocolPing::start() [END]"); + debug!(target: "net::protocol_ping::start()", "END"); Ok(()) } diff --git a/src/net/protocol/protocol_seed.rs b/src/net/protocol/protocol_seed.rs index de1870d88..089db89a1 100644 --- a/src/net/protocol/protocol_seed.rs +++ b/src/net/protocol/protocol_seed.rs @@ -65,7 +65,7 @@ impl ProtocolSeed { } let ext_addrs = self.settings.external_addr.clone(); - debug!(target: "net::protocol_seed::send_self_address()", "ProtocolSeed::send_self_address() ext_addrs={:?}", ext_addrs); + debug!(target: "net::protocol_seed::send_self_address()", "ext_addrs={:?}", ext_addrs); let ext_addr_msg = message::ExtAddrsMessage { ext_addrs }; self.channel.clone().send(ext_addr_msg).await } @@ -88,10 +88,7 @@ impl ProtocolBase for ProtocolSeed { // Receive addresses. let addrs_msg = self.addr_sub.receive().await?; - debug!( - target: "net::protocol_seed::start()", - "ProtocolSeed::start() received {} addrs", - addrs_msg.addrs.len() + debug!(target: "net::protocol_seed::start()", "Received {} addrs", addrs_msg.addrs.len() ); self.hosts.store(addrs_msg.addrs.clone()).await; diff --git a/src/net/protocol/protocol_version.rs b/src/net/protocol/protocol_version.rs index b223bebb2..d87f096b9 100644 --- a/src/net/protocol/protocol_version.rs +++ b/src/net/protocol/protocol_version.rs @@ -64,7 +64,7 @@ impl ProtocolVersion { /// and wait for version acknowledgement. Wait for version info and send /// version acknowledgement. pub async fn run(self: Arc, executor: Arc>) -> Result<()> { - debug!(target: "net::protocol_version::run()", "ProtocolVersion::run() [START]"); + debug!(target: "net::protocol_version::run()", "START"); // Start timer // Send version, wait for verack // Wait for version, send verack @@ -79,13 +79,13 @@ impl ProtocolVersion { return Err(Error::ChannelTimeout) } - debug!(target: "net::protocol_version::run()", "ProtocolVersion::run() [END]"); + debug!(target: "net::protocol_version::run()", "END"); Ok(()) } /// Send and recieve version information. async fn exchange_versions(self: Arc, executor: Arc>) -> Result<()> { - debug!(target: "net::protocol_version::exchange_versions()", "ProtocolVersion::exchange_versions() [START]"); + debug!(target: "net::protocol_version::exchange_versions()", "START"); let send = executor.spawn(self.clone().send_version()); let recv = executor.spawn(self.recv_version()); @@ -93,14 +93,14 @@ impl ProtocolVersion { send.await?; recv.await?; - debug!(target: "net::protocol_version::exchange_versions()", "ProtocolVersion::exchange_versions() [END]"); + debug!(target: "net::protocol_version::exchange_versions()", "END"); Ok(()) } /// Send version info and wait for version acknowledgement /// and ensures the app version is the same, if configured. async fn send_version(self: Arc) -> Result<()> { - debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [START]"); + debug!(target: "net::protocol_version::send_version()", "START"); let version = message::VersionMessage { node_id: self.settings.node_id.clone() }; @@ -114,14 +114,21 @@ impl ProtocolVersion { if !self.settings.seeds.contains(&self.channel.address()) { match &self.settings.app_version { Some(app_version) => { - debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [App version: {}]", app_version); - debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [Recieved version: {}]", verack_msg.app); + debug!( + target: "net::protocol_version::send_version()", + "App version: {}, received version: {}", + app_version, + verack_msg.app + ); // Version format: MAJOR.MINOR.PATCH let app_versions: Vec<&str> = app_version.split('.').collect(); let verack_msg_versions: Vec<&str> = verack_msg.app.split('.').collect(); // Check for malformed versions if app_versions.len() != 3 || verack_msg_versions.len() != 3 { - error!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [Malformed version detected. Disconnecting from channel.]"); + error!( + target: "net::protocol_version::send_version()", + "Malformed version detected. Disconnecting from channel." + ); self.hosts.remove(&self.channel.address()).await; self.channel.stop().await; return Err(Error::ChannelStopped) @@ -132,7 +139,7 @@ impl ProtocolVersion { { error!( target: "net::protocol_version::send_version()", - "ProtocolVersion::send_version() [Wrong app version from ({}). Disconnecting from channel.]", + "Wrong app version from ({}). Disconnecting from channel.", self.channel.address() ); self.hosts.remove(&self.channel.address()).await; @@ -141,19 +148,22 @@ impl ProtocolVersion { } } None => { - debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [App version not set, ignorring received]") + debug!( + target: "net::protocol_version::send_version()", + "App version not set, ignoring received" + ) } } } - debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [END]"); + debug!(target: "net::protocol_version::send_version()", "END"); Ok(()) } /// Recieve version info, check the message is okay and send version /// acknowledgement with app version attached. async fn recv_version(self: Arc) -> Result<()> { - debug!(target: "net::protocol_version::recv_version()", "ProtocolVersion::recv_version() [START]"); + debug!(target: "net::protocol_version::recv_version()", "START"); // Receive version message let version = self.version_sub.receive().await?; self.channel.set_remote_node_id(version.node_id.clone()).await; @@ -163,7 +173,7 @@ impl ProtocolVersion { message::VerackMessage { app: self.settings.app_version.clone().unwrap_or_default() }; self.channel.clone().send(verack).await?; - debug!(target: "net::protocol_version::recv_version()", "ProtocolVersion::recv_version() [END]"); + debug!(target: "net::protocol_version::recv_version()", "END"); Ok(()) } }