node: Logging improvements & other small things

radicle-cli/src/node.rs

@@ -27,7 +27,7 @@ pub struct SyncSettings {
 }
 
 impl SyncSettings {
-    /// Create a [`RepoSync`] from a list of seeds.
+    /// Create a [`SyncSettings`] from a list of seeds.
     pub fn from_seeds(seeds: impl IntoIterator<Item = NodeId>) -> Self {
         let seeds = BTreeSet::from_iter(seeds);
         Self {
@@ -37,7 +37,7 @@ impl SyncSettings {
         }
     }
 
-    /// Create a [`RepoSync`] from a replica count.
+    /// Create a [`SyncSettings`] from a replica count.
     pub fn from_replicas(replicas: usize) -> Self {
         Self {
             replicas,

radicle-node/src/service.rs

@@ -1863,11 +1863,11 @@ where
         let peers = self.sessions.connected().map(|(_, p)| p);
         let (ann, refs) = self.refs_announcement_for(rid, remotes)?;
 
-        debug!(target: "service", "Announcing refs for {rid} to peers..");
-
         // Update our local sync status. This is useful for determining if refs were updated while
         // the node was stopped.
         if let Some(refs) = refs.iter().find(|r| r.remote == ann.node) {
+            info!(target: "service", "Announcing local refs for {rid} to peers ({})..", refs.at);
+
             if let Err(e) = self
                 .db
                 .seeds_mut()

radicle-node/src/tests.rs

@@ -783,6 +783,7 @@ fn test_refs_announcement_followed() {
     // Generate some refs for Bob under their own node_id.
     let sigrefs = bob.signed_refs_at(arbitrary::gen::<Refs>(8), arbitrary::oid());
     let node_id = bob.id;
+    bob.init();
     bob.storage_mut()
         .repo_mut(&rid)
         .remotes

radicle-node/src/wire/protocol.rs

@@ -381,8 +381,14 @@ where
             FetchResult::Initiator { rid, result } => {
                 self.service.fetched(rid, *nid, result);
             }
-            FetchResult::Responder { .. } => {
-                // We don't do anything with upload results for now.
+            FetchResult::Responder { rid, result } => {
+                if let Some(rid) = rid {
+                    if let Some(err) = result.err() {
+                        log::info!(target: "wire", "Peer {nid} failed to fetch {rid} from us: {err}");
+                    } else {
+                        log::info!(target: "wire", "Peer {nid} fetched {rid} from us successfully");
+                    }
+                }
             }
         }
 

radicle-node/src/worker.rs

@@ -136,6 +136,8 @@ pub enum FetchResult {
         result: Result<fetch::FetchResult, FetchError>,
     },
     Responder {
+        /// Repo requested.
+        rid: Option<RepoId>,
         /// Upload result.
         result: Result<(), UploadError>,
     },
@@ -249,6 +251,7 @@ impl Worker {
                     Ok(header) => header,
                     Err(e) => {
                         return FetchResult::Responder {
+                            rid: None,
                             result: Err(e.into()),
                         }
                     }
@@ -256,7 +259,10 @@ 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) };
+                    return FetchResult::Responder {
+                        rid: Some(header.repo),
+                        result: Err(e),
+                    };
                 }
 
                 let result =
@@ -265,7 +271,10 @@ impl Worker {
                         .map_err(|e| e.into());
                 log::debug!(target: "worker", "Upload process on stream {stream} exited with result {result:?}");
 
-                FetchResult::Responder { result }
+                FetchResult::Responder {
+                    rid: Some(header.repo),
+                    result,
+                }
             }
         }
     }