3bf19ef node: downgrade `error!` logs — heartwood

modified crates/radicle-node/src/control.rs

@@ -50,7 +50,7 @@ where

                 thread::spawn(&nid, "control", move || {
                     if let Err((e, mut stream)) = command(stream, handle) {
                         log::error!(target: "control", "Command returned error: {e}");
                         log::debug!(target: "control", "Command returned error: {e}");
                         CommandResult::error(e).to_writer(&mut stream).ok();

@@ -59,7 +59,7 @@ where

                     }
                 });
             }
             Err(e) => log::error!(target: "control", "Failed to accept incoming connection: {e}"),
             Err(e) => log::warn!(target: "control", "Failed to accept incoming connection: {e}"),
         }
     }
     log::debug!(target: "control", "Exiting control loop..");

modified crates/radicle-node/src/reactor.rs

@@ -399,7 +399,7 @@ impl<H: ReactionHandler> Runtime<H> {

             }
             if let Err(err) = res {
                 log::error!(target: "reactor", "Error during polling: {err}");
                 log::warn!(target: "reactor", "Failure during polling: {err}");
                 self.service.handle_error(Error::Poll(err));
             }

@@ -497,7 +497,7 @@ impl<H: ReactionHandler> Runtime<H> {

             // Deadlock may happen here if the service will generate events over and over
             // in the handle_* calls we may never get out of this loop
             if let Err(err) = self.handle_action(action, instant) {
                 log::error!(target: "reactor", "Error: {err}");
                 log::warn!(target: "reactor", "Failure: {err}");
                 self.service.handle_error(err);
             }
         }

@@ -558,7 +558,7 @@ impl<H: ReactionHandler> Runtime<H> {

                         }
                     }
                 } else {
                     log::error!(target: "reactor", token=token.0; "No transport with token {token:?} is known!");
                     log::debug!(target: "reactor", token=token.0; "No transport with token {token:?} is known!");
                 }
             }
             Action::SetTimer(duration) => {

modified crates/radicle-node/src/reactor/transport.rs

@@ -265,7 +265,7 @@ impl<S: Session> Transport<S> {

                         Ok(0)
                     },
                     _ => {
                         log::error!(target: "transport", "Resource {} failed write operation with message '{err}'", self.display());
                         log::warn!(target: "transport", "Resource {} failed write operation with message '{err}'", self.display());
                         Err(err)
                     },
                 }

modified crates/radicle-node/src/wire.rs

@@ -361,7 +361,7 @@ where

             }
             Entry::Occupied(mut e) => match e.get_mut() {
                 Peer::Disconnecting { nid, link, .. } => {
                     log::error!(target: "wire", token=token.0; "Peer is already disconnecting");
                     log::debug!(target: "wire", token=token.0; "Peer is already disconnecting");
                     nid.map(|n| (n, *link))
                 }

@@ -527,7 +527,7 @@ where

             Ok((connection, peer)) => {
                 let remote = NetAddr::from(peer);
                 let InetHost::Ip(ip) = remote.host else {
                     log::error!(target: "wire", "Unexpected host type for inbound connection {remote}; dropping..");
                     log::debug!(target: "wire", "Unexpected host type for inbound connection {remote}; dropping..");
                     drop(connection);
                     return;

@@ -551,7 +551,7 @@ where

                 let transport = match Transport::with_session(session, Link::Inbound) {
                     Ok(transport) => transport,
                     Err(err) => {
                         log::error!(target: "wire", "Failed to create transport for accepted connection: {err}");
                         log::warn!(target: "wire", "Failed to create transport for accepted connection: {err}");
                         return;
                     }
                 };

@@ -592,7 +592,7 @@ where

                 let nid: NodeId = state.remote_static_key.unwrap();
                 // Make sure we don't try to connect to ourselves by mistake.
                 if &nid == self.signer.public_key() {
                     log::error!(target: "wire", "Self-connection detected, disconnecting..");
                     log::warn!(target: "wire", "Self-connection detected, disconnecting..");
                     self.disconnect(token, DisconnectReason::SelfConnection);
                     return;

@@ -606,7 +606,7 @@ where

                     assert_eq!(nid, peer.nid);
                     (peer.addr, Link::Outbound)
                 } else {
                     log::error!(target: "wire", token=token.0; "Session for {nid} not found");
                     log::debug!(target: "wire", token=token.0; "Session for {nid} not found");
                     return;
                 };
                 log::debug!(

@@ -701,8 +701,8 @@ where

                     metrics.received_bytes += data.len();
                     if inbox.input(&data).is_err() {
                         log::error!(target: "wire", "Maximum inbox size ({MAX_INBOX_SIZE}) reached for peer {nid}");
                         log::error!(target: "wire", "Unable to process messages fast enough for peer {nid}; disconnecting..");
                         log::warn!(target: "wire", "Maximum inbox size ({MAX_INBOX_SIZE}) reached for peer {nid}");
                         log::warn!(target: "wire", "Unable to process messages fast enough for peer {nid}; disconnecting..");
                         self.disconnect(
                             token,
                             DisconnectReason::Session(session::Error::Misbehavior),

@@ -739,7 +739,7 @@ where

                                     channels,
                                 };
                                 if let Err(e) = self.worker.try_send(task) {
                                     log::error!(
                                     log::warn!(
                                         target: "wire",
                                         "Worker pool failed to accept incoming fetch request: {e}"
                                     );

@@ -753,7 +753,7 @@ where

                                     log::debug!(target: "wire", "Received `end-of-file` on stream {stream} from {nid}");
                                     if s.channels.send(ChannelEvent::Eof).is_err() {
                                         log::error!(target: "wire", "Worker is disconnected; cannot send `EOF`");
                                         log::debug!(target: "wire", "Worker is disconnected; cannot send `EOF`");
                                     }
                                 } else {
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");

@@ -790,7 +790,7 @@ where

                                     metrics.received_git_bytes += data.len();
                                     if s.channels.send(ChannelEvent::Data(data)).is_err() {
                                         log::error!(target: "wire", "Worker is disconnected; cannot send data");
                                         log::warn!(target: "wire", "Worker is disconnected; cannot send data");
                                     }
                                 } else {
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");

@@ -801,7 +801,7 @@ where

                                 break;
                             }
                             Err(e) => {
                                 log::error!(target: "wire", "Invalid gossip message from {nid}: {e}");
                                 log::warn!(target: "wire", "Invalid gossip message from {nid}: {e}");
                                 if !inbox.is_empty() {
                                     log::debug!(target: "wire", "Dropping read buffer for {nid} with {} bytes", inbox.len());

@@ -874,7 +874,7 @@ where

     }
     fn handover_listener(&mut self, token: Token, _listener: Self::Listener) {
         log::error!(target: "wire", token=token.0; "Listener handover is not supported");
         log::warn!(target: "wire", token=token.0; "Listener handover is not supported");
     }
     fn handover_transport(&mut self, token: Token, transport: Self::Transport) {

@@ -932,7 +932,7 @@ where

                             continue;
                         }
                         None => {
                             log::error!(target: "wire", "Dropping {} message(s) to {node_id}: unknown peer", msgs.len());
                             log::debug!(target: "wire", "Dropping {} message(s) to {node_id}: unknown peer", msgs.len());
                             continue;
                         }
                     };

@@ -952,7 +952,7 @@ where

                 }
                 Io::Connect(node_id, addr) => {
                     if self.peers.connected().any(|(_, id)| id == &node_id) {
                         log::error!(
                         log::debug!(
                             target: "wire",
                             "Attempt to connect to already connected peer {node_id}"
                         );

@@ -1028,7 +1028,7 @@ where

                         // is in the service's i/o buffer. Since the service may not purge the
                         // buffer on disconnect, we should just ignore i/o actions that don't
                         // have a connected peer.
                         log::error!(target: "wire", "Peer {remote} is not connected: dropping fetch");
                         log::debug!(target: "wire", "Peer {remote} is not connected: dropping fetch");
                         continue;
                     };
                     let (stream, channels) =

@@ -1054,7 +1054,7 @@ where

                         );
                     }
                     if let Err(e) = self.worker.try_send(task) {
                         log::error!(
                         log::warn!(
                             target: "wire",
                             "Worker pool failed to accept outgoing fetch request: {e}"
                         );

@@ -1231,7 +1231,7 @@ mod logger {

             | NotConnected => {
                 log::info!(target: "wire", "Could not establish connection to {addr}: {err}")
             }
             _ => log::error!(target: "wire", "Error establishing connection to {addr}: {err}"),
             _ => log::warn!(target: "wire", "Failed to establish connection to {addr}: {err}"),
         }
     }
 }

modified crates/radicle-node/src/worker/fetch.rs

@@ -106,7 +106,7 @@ impl Handle {

                 validations,
             } => {
                 for fail in validations.iter() {
                     log::error!(target: "worker", "Validation error: {fail}");
                     log::warn!(target: "worker", "Validation error: {fail}");
                 }
                 Err(error::Fetch::Validation {
                     threshold,

@@ -207,7 +207,7 @@ fn notify(

         if let RefUpdate::Skipped { .. } = update {
             // Don't notify about skipped refs.
         } else if let Err(e) = store.insert(rid, update, now) {
             log::error!(
             log::debug!(
                 target: "worker",
                 "Failed to update notification store for {rid}: {e}"
             );

@@ -227,7 +227,7 @@ where

         let name = r.name();
         let (namespace, qualified) = match radicle::git::parse_ref_namespaced(name) {
             Err(e) => {
                 log::error!(target: "worker", "Git reference is invalid: {name:?}: {e}");
                 log::debug!(target: "worker", "Git reference is invalid: {name:?}: {e}");
                 log::debug!(target: "worker", "Skipping refs caching for fetch of {repo}");
                 break;
             }

@@ -247,7 +247,7 @@ where

         };
         if let Err(e) = result {
             log::error!(target: "worker", "Error updating git refs cache for {name:?}: {e}");
             log::debug!(target: "worker", "Failed to update git refs cache for {name:?}: {e}");
             log::debug!(target: "worker", "Skipping refs caching for fetch of {repo}");
             break;
         }

@@ -326,7 +326,7 @@ where

         }
         Err(e) => {
             // Object was found, but failed to load. Fall-through.
             log::error!(target: "fetch", "Error loading COB {tid} from storage: {e}");
             log::debug!(target: "fetch", "Failed to load COB {tid} from storage: {e}");
         }
     }
     // The object has either been removed entirely from the repository,

modified crates/radicle-node/src/worker/upload_pack.rs

@@ -137,7 +137,7 @@ where

                         }
                     }
                     Err(e) => {
                         log::error!(target: "worker", "Error on upload-pack channel read for {}: {e}", header.repo);
                         log::debug!(target: "worker", "Failure on upload-pack channel read for {}: {e}", header.repo);
                         emitter.emit(events::UploadPack::error(header.repo, remote, e).into());
                         break;
                     }