unify keepalive

1 files changed, 23 insertions, 15 deletions

diff --git a/src/swarm/peer/inbound.rs b/src/swarm/peer/inbound.rs
index e81c71d..040cafb 100644
--- a/src/swarm/peer/inbound.rs
+++ b/src/swarm/peer/inbound.rs
@@ -119,13 +119,11 @@ pub(crate) async fn handle_message(
             crate::swarm::source::synced_from(state, &peer);
             handle_sync(state, &peer, envelope).await?;
         }
+        transport::ParsedMessage::Blob(blob) => {
+            crate::swarm::blob::handle(state, &peer, blob).await;
+        }
         transport::ParsedMessage::Ping(remote) => {
-            if reactivated || peer_swarm(state, &peer).await.is_none() {
-                ensure_handshake(state, &peer).await;
-            }
-            note_keepalive(state, &peer, &remote).await;
-            let local = local_keepalive(state, &peer).await;
-            heal_if_diverged(state, &peer, &local, &remote).await;
+            let local = on_keepalive(state, &peer, &remote, reactivated).await;
             if let Err(error) = state
                 .transport
                 .send_message(&peer, &ParsedMessage::Pong(local))
@@ -134,19 +132,29 @@ pub(crate) async fn handle_message(
                 debug!(peer = %peer, error = %format!("{error:#}"), "PONG failed");
             }
         }
-        transport::ParsedMessage::Blob(blob) => {
-            crate::swarm::blob::handle(state, &peer, blob).await;
-        }
         transport::ParsedMessage::Pong(remote) => {
+            // It answers our PING: a round-trip sample.
             state.lock_rtt().pong_received(&peer, Instant::now());
-            if reactivated || peer_swarm(state, &peer).await.is_none() {
-                ensure_handshake(state, &peer).await;
-            }
-            note_keepalive(state, &peer, &remote).await;
-            let local = local_keepalive(state, &peer).await;
-            heal_if_diverged(state, &peer, &local, &remote).await;
+            on_keepalive(state, &peer, &remote, reactivated).await;
         }
     }
 
     Ok(())
 }
+
+/// What a PING and a PONG have in common: a handshake if needed, the peer's keepalive
+/// noted, and the heal if our documents differ. Returns our keepalive for the peer.
+async fn on_keepalive(
+    state: &AppState,
+    peer: &str,
+    remote: &transport::Keepalive,
+    reactivated: bool,
+) -> transport::Keepalive {
+    if reactivated || peer_swarm(state, peer).await.is_none() {
+        ensure_handshake(state, peer).await;
+    }
+    note_keepalive(state, peer, remote).await;
+    let local = local_keepalive(state, peer).await;
+    heal_if_diverged(state, peer, &local, remote).await;
+    local
+}