fdf693c Various improvements to log statements — heartwood

modified radicle-cob/src/change_graph.rs

@@ -37,14 +37,15 @@ impl ChangeGraph {

     where
         S: change::Storage<ObjectId = Oid, Parent = Oid, Signatures = ExtendedSignature>,
     {
         log::info!("loading object '{}' '{}'", typename, oid);
         log::debug!(target: "cob", "Loading object of type {typename} at {oid}");
         let mut builder = GraphBuilder::default();
         let mut edges_to_process: Vec<(Oid, Oid)> = Vec::new();
         // Populate the initial set of edges_to_process from the refs we have
         for reference in tip_refs {
             log::trace!("loading object from reference '{}'", reference.name);
             log::trace!(target: "cob", "Loading object from reference '{}'", reference.name);
             match storage.load(reference.target.id) {
                 Ok(change) => {
                     let new_edges = builder

@@ -54,10 +55,10 @@ impl ChangeGraph {

                 }
                 Err(e) => {
                     log::warn!(
                         "unable to load change from reference '{}->{}', error '{}'",
                         target: "cob",
                         "Unable to load change from reference {}->{}: {e}",
                         reference.name,
                         reference.target.id,
                         e
                     );
                 }
             }

@@ -66,7 +67,8 @@ impl ChangeGraph {

         // Process edges until we have no more to process
         while let Some((parent_commit_id, child_commit_id)) = edges_to_process.pop() {
             log::trace!(
                 "loading change parent='{}', child='{}'",
                 target: "cob",
                 "Loading change parent='{}', child='{}'",
                 parent_commit_id,
                 child_commit_id
             );

@@ -78,9 +80,9 @@ impl ChangeGraph {

                 }
                 Err(e) => {
                     log::warn!(
                         "unable to load changetree from commit '{}', error '{}'",
                         target: "cob",
                         "Unable to load change tree from commit {}: {e}",
                         parent_commit_id,
                         e
                     );
                 }
             }

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

@@ -378,9 +378,9 @@ where

     }
     fn worker_result(&mut self, task: TaskResult) {
         log::debug!(
         log::trace!(
             target: "wire",
             "Received fetch result from worker: stream={} remote={} result={:?}",
             "Received fetch result from worker for stream {}, remote {}: {:?}",
             task.stream, task.remote, task.result
         );

@@ -560,10 +560,10 @@ where

                                 data: FrameData::Control(frame::Control::Open { stream }),
                                 ..
                             })) => {
                                 log::debug!(target: "wire", "Received stream open for id={stream} from {nid}");
                                 log::debug!(target: "wire", "Received `open` command for stream {stream} from {nid}");
                                 let Some(channels) = streams.register(stream) else {
                                     log::warn!(target: "wire", "Peer attempted to open already-open stream id={stream}");
                                     log::warn!(target: "wire", "Peer attempted to open already-open stream stream {stream}");
                                     continue;
                                 };

@@ -581,20 +581,20 @@ where

                                 ..
                             })) => {
                                 if let Some(channels) = streams.get(&stream) {
                                     log::debug!(target: "wire", "Received end-of-file on id={stream} from {nid}");
                                     log::debug!(target: "wire", "Received `end-of-file` on stream {stream} from {nid}");
                                     if channels.send(ChannelEvent::Eof).is_err() {
                                         log::error!(target: "wire", "Worker is disconnected; cannot send `EOF`");
                                     }
                                 } else {
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream id={stream}");
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");
                                 }
                             }
                             Ok(Some(Frame {
                                 data: FrameData::Control(frame::Control::Close { stream }),
                                 ..
                             })) => {
                                 log::debug!(target: "wire", "Received stream close command for id={stream} from {nid}");
                                 log::debug!(target: "wire", "Received `close` command for stream {stream} from {nid}");
                                 if let Some(chans) = streams.unregister(&stream) {
                                     chans.close().ok();

@@ -616,7 +616,7 @@ where

                                         log::error!(target: "wire", "Worker is disconnected; cannot send data");
                                     }
                                 } else {
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream id={stream}");
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");
                                 }
                             }
                             Ok(None) => {

@@ -842,7 +842,7 @@ where

                         };
                     let (stream, channels) = streams.open();
                     log::debug!(target: "wire", "Opened new stream with id={stream} for rid={rid} remote={remote}");
                     log::debug!(target: "wire", "Opened new stream with id {stream} for {rid} and remote {remote}");
                     let link = *link;
                     let task = Task {

modified radicle-node/src/worker.rs

@@ -226,15 +226,14 @@ impl Worker {

                 // TODO: nowhere to use this currently
                 timeout: _timeout,
             } => {
                 log::debug!(target: "worker", "Worker processing outgoing fetch for {}", rid);
                 log::debug!(target: "worker", "Worker processing outgoing fetch for {rid}");
                 let result = self.fetch(rid, remote, refs_at, channels);
                 FetchResult::Initiator { rid, result }
             }
             FetchRequest::Responder { remote } => {
                 log::debug!(target: "worker", "Worker processing incoming fetch for {remote}..");
                 log::debug!(target: "worker", "Worker processing incoming fetch for {remote} on stream {stream}..");
                 let (mut stream_r, stream_w) = channels.split();
                 let header = match upload_pack::pktline::git_request(&mut stream_r) {
                     Ok(header) => header,
                     Err(e) => {

@@ -243,6 +242,7 @@ impl Worker {

                         }
                     }
                 };
                 log::debug!(target: "worker", "Spawning upload-pack process for {} on stream {stream}..", header.repo);
                 if let Err(e) = self.is_authorized(remote, header.repo) {
                     return FetchResult::Responder { result: Err(e) };

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

@@ -82,7 +82,7 @@ where

             match io::copy(&mut stdout, &mut send) {
                 Ok(_) => {}
                 Err(e) => {
                     log::error!(target: "worker", "Worker channel disconnected; aborting: {e}");
                     log::error!(target: "worker", "Worker channel disconnected for {}; aborting: {e}", header.repo);
                 }
             }
         });

@@ -94,16 +94,16 @@ where

                     Ok(0) => break,
                     Ok(n) => {
                         if let Err(e) = stdin.write_all(&buffer[..n]) {
                             log::warn!(target: "worker", "upload-pack stdin write error: {e}");
                             log::warn!(target: "worker", "Error writing to upload-pack stdin: {e}");
                             break;
                         }
                     }
                     Err(e) if e.kind() == io::ErrorKind::UnexpectedEof => {
                         log::debug!(target: "worker", "exiting upload-pack receive thread");
                         log::debug!(target: "worker", "Exiting upload-pack reader thread for {}", header.repo);
                         break;
                     }
                     Err(e) => {
                         log::error!(target: "worker", "upload-pack channel read error: {e}");
                         log::error!(target: "worker", "Error on upload-pack channel read for {}: {e}", header.repo);
                         break;
                     }
                 }