From b0ca5dc7dd16a892205673a5da5e4ee33e652fb6 Mon Sep 17 00:00:00 2001 From: x Date: Thu, 31 Aug 2023 10:22:52 +0200 Subject: [PATCH] net/channel: improve Debug, and use {:?} in all trace/debug messages instead of self.address() --- src/net/channel.rs | 52 +++++++++++++++++++++++----------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/src/net/channel.rs b/src/net/channel.rs index 2663d9157..bed2a62a2 100644 --- a/src/net/channel.rs +++ b/src/net/channel.rs @@ -16,7 +16,7 @@ * along with this program. If not, see . */ -use std::sync::Arc; +use std::{fmt, sync::Arc}; use darkfi_serial::{async_trait, serialize, SerialDecodable, SerialEncodable}; use log::{debug, error, info}; @@ -79,12 +79,6 @@ pub struct Channel { pub info: ChannelInfo, } -impl std::fmt::Debug for Channel { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.address()) - } -} - impl Channel { /// Sets up a new channel. Creates a reader and writer [`PtStream`] and /// summons the message subscriber subsystem. Performs a network handshake @@ -124,7 +118,7 @@ impl Channel { /// Starts the channel. Runs a receive loop to start receiving messages /// or handles a network failure. pub fn start(self: Arc, executor: Arc>) { - debug!(target: "net::channel::start()", "START => address={}", self.address()); + debug!(target: "net::channel::start()", "START {:?}", self); let self_ = self.clone(); self.receive_task.clone().start( @@ -134,14 +128,14 @@ impl Channel { executor, ); - debug!(target: "net::channel::start()", "END => address={}", self.address()); + debug!(target: "net::channel::start()", "END {:?}", self); } /// Stops the channel. Steps through each component of the channel connection /// and sends a stop signal. Notifies all subscribers that the channel has /// been closed. pub async fn stop(&self) { - debug!(target: "net::channel::stop()", "START => address={}", self.address()); + debug!(target: "net::channel::stop()", "START {:?}", self); if !*self.stopped.lock().await { *self.stopped.lock().await = true; @@ -151,13 +145,13 @@ impl Channel { self.message_subsystem.trigger_error(Error::ChannelStopped).await; } - debug!(target: "net::channel::stop()", "END => address={}", self.address()); + debug!(target: "net::channel::stop()", "END {:?}", self); } /// Creates a subscription to a stopped signal. /// If the channel is stopped then this will return a ChannelStopped error. pub async fn subscribe_stop(&self) -> Result> { - debug!(target: "net::channel::subscribe_stop()", "START => address={}", self.address()); + debug!(target: "net::channel::subscribe_stop()", "START {:?}", self); if *self.stopped.lock().await { return Err(Error::ChannelStopped) @@ -165,7 +159,7 @@ impl Channel { let sub = self.stop_subscriber.clone().subscribe().await; - debug!(target: "net::channel::subscribe_stop()", "END => address={}", self.address()); + debug!(target: "net::channel::subscribe_stop()", "END {:?}", self); Ok(sub) } @@ -175,7 +169,7 @@ impl Channel { /// Returns an error if something goes wrong. pub async fn send(&self, message: &M) -> Result<()> { debug!( - target: "net::channel::send()", "[START] command={} => address={}", + target: "net::channel::send()", "[START] command={} {:?}", M::NAME, self.address(), ); @@ -186,16 +180,16 @@ impl Channel { // Catch failure and stop channel, return a net error if let Err(e) = self.send_message(message).await { error!( - target: "net::channel::send()", "[P2P] Channel send error for [{}]: {}", - self.address(), e + target: "net::channel::send()", "[P2P] Channel send error for [{:?}]: {}", + self, e ); self.stop().await; return Err(Error::ChannelStopped) } debug!( - target: "net::channel::send()", "[END] command={} => address={}", - M::NAME,self.address(), + target: "net::channel::send()", "[END] command={} {:?}", + M::NAME, self ); Ok(()) @@ -223,15 +217,15 @@ impl Channel { /// Subscribe to a message on the message subsystem. pub async fn subscribe_msg(&self) -> Result> { debug!( - target: "net::channel::subscribe_msg()", "[START] command={} => address={}", - M::NAME, self.address(), + target: "net::channel::subscribe_msg()", "[START] command={} {:?}", + M::NAME, self ); let sub = self.message_subsystem.subscribe::().await; debug!( - target: "net::channel::subscribe_msg()", "[END] command={} => address={}", - M::NAME, self.address(), + target: "net::channel::subscribe_msg()", "[END] command={} {:?}", + M::NAME, self ); sub @@ -240,7 +234,7 @@ impl Channel { /// Handle network errors. Panic if error passes silently, otherwise /// broadcast the error. async fn handle_stop(self: Arc, result: Result<()>) { - debug!(target: "net::channel::handle_stop()", "[START] address={}", self.address()); + debug!(target: "net::channel::handle_stop()", "[START] {:?}", self); match result { Ok(()) => panic!("Channel task should never complete without error status"), @@ -248,12 +242,12 @@ impl Channel { Err(e) => self.message_subsystem.trigger_error(e).await, } - debug!(target: "net::channel::handle_stop()", "[END] address={}", self.address()); + debug!(target: "net::channel::handle_stop()", "[END] {:?}", self); } /// Run the receive loop. Start receiving messages or handle network failure. async fn main_receive_loop(self: Arc) -> Result<()> { - debug!(target: "net::channel::main_receive_loop()", "[START] address={}", self.address()); + debug!(target: "net::channel::main_receive_loop()", "[START] {:?}", self); // Acquire reader lock let reader = &mut *self.reader.lock().await; @@ -279,7 +273,7 @@ impl Channel { debug!( target: "net::channel::main_receive_loop()", - "Stopping channel {}", self.address(), + "Stopping channel {:?}", self ); self.stop().await; return Err(Error::ChannelStopped) @@ -327,3 +321,9 @@ impl Channel { } } } + +impl fmt::Debug for Channel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "", self.info.addr, self.info.id) + } +}