rename PING/PONG to STATUS/STATUS_REPLY

4 files changed, 41 insertions, 39 deletions

diff --git a/src/swarm/peer/inbound.rs b/src/swarm/peer/inbound.rs
index b04aad9..4c7e7a8 100644
--- a/src/swarm/peer/inbound.rs
+++ b/src/swarm/peer/inbound.rs
@@ -11,7 +11,7 @@ use super::epoch::observe_peer_epoch;
 use super::handshake::{
     discover_peers, ensure_handshake, establish_peer, peer_swarm, remember_peer, send_hello_reply,
 };
-use super::keepalive::{heal_if_diverged, local_keepalive, note_keepalive};
+use super::keepalive::{heal_if_diverged, local_status, note_status};
 use super::lanes::SyncLanes;
 use crate::state::AppState;
 use crate::swarm::sync::SyncEvent;
@@ -143,20 +143,22 @@ pub(crate) async fn handle_message(
         transport::ParsedMessage::Blob(blob) => {
             crate::swarm::blob::handle(state, &peer, blob).await;
         }
-        transport::ParsedMessage::Ping(remote) => {
-            let local = on_keepalive(state, &peer, &remote, reactivated).await;
+        transport::ParsedMessage::Status(remote) => {
+            let local = on_status(state, &peer, &remote, reactivated).await;
             if let Err(error) = state
                 .transport
-                .send_message(&peer, &ParsedMessage::Pong(local))
+                .send_message(&peer, &ParsedMessage::StatusReply(local))
                 .await
             {
-                debug!(peer = %peer, error = %format!("{error:#}"), "PONG failed");
+                debug!(peer = %peer, error = %format!("{error:#}"), "STATUS_REPLY failed");
             }
         }
-        transport::ParsedMessage::Pong(remote) => {
-            // It answers our PING: a round-trip sample.
-            state.lock_rtt().pong_received(&peer, Instant::now());
-            on_keepalive(state, &peer, &remote, reactivated).await;
+        transport::ParsedMessage::StatusReply(remote) => {
+            // It answers our STATUS: a round-trip sample.
+            state
+                .lock_rtt()
+                .status_reply_received(&peer, Instant::now());
+            on_status(state, &peer, &remote, reactivated).await;
         }
         transport::ParsedMessage::Who(_) | transport::ParsedMessage::Me(_) => {}
     }
@@ -164,19 +166,19 @@ pub(crate) async fn handle_message(
     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(
+/// What a STATUS and a STATUS_REPLY have in common: a handshake if needed, the peer's status
+/// noted, and the heal if our documents differ. Returns our status for the peer.
+async fn on_status(
     state: &AppState,
     peer: &str,
-    remote: &transport::Keepalive,
+    remote: &transport::Status,
     reactivated: bool,
-) -> transport::Keepalive {
+) -> transport::Status {
     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;
+    note_status(state, peer, remote).await;
+    let local = local_status(state, peer).await;
     heal_if_diverged(state, peer, &local, remote).await;
     local
 }
diff --git a/src/swarm/peer/keepalive.rs b/src/swarm/peer/keepalive.rs
index ce2951b..810c377 100644
--- a/src/swarm/peer/keepalive.rs
+++ b/src/swarm/peer/keepalive.rs
@@ -1,4 +1,4 @@
-//! Keepalives (PING / PONG) and the self-healing re-handshake when they show our
+//! Keepalives (STATUS / STATUS_REPLY) and the self-healing re-handshake when they show our
 //! documents differ while sync is idle.
 
 use std::sync::atomic::Ordering;
@@ -14,37 +14,37 @@ use crate::swarm::sync::SyncEvent;
 use crate::swarm::topology;
 use crate::transport::{self, ParsedMessage};
 
-/// Sends `peer` a PING with our keepalive, noting the time for its round trip.
-pub(crate) async fn send_ping(state: &AppState, peer: &str) -> Result<()> {
-    let keepalive = local_keepalive(state, peer).await;
-    state.lock_rtt().ping_sent(peer, Instant::now());
+/// Sends `peer` a STATUS with our status, noting the time for its round trip.
+pub(crate) async fn send_status(state: &AppState, peer: &str) -> Result<()> {
+    let status = local_status(state, peer).await;
+    state.lock_rtt().status_sent(peer, Instant::now());
     state
         .transport
-        .send_message(peer, &ParsedMessage::Ping(keepalive))
+        .send_message(peer, &ParsedMessage::Status(status))
         .await
 }
 
-/// How long shutting down waits for the last PINGs (`farewell`).
+/// How long shutting down waits for the last STATUSes (`farewell`).
 const FAREWELL_TIMEOUT: Duration = Duration::from_secs(2);
 
-/// At shutdown: one last PING to each neighbour, saying we aren't ready. A neighbour
+/// At shutdown: one last STATUS to each neighbour, saying we aren't ready. A neighbour
 /// catching up from us picks another source now, instead of once we go dormant. Bounded
 /// in time: our transport may be gone already.
 pub(crate) async fn farewell(state: &AppState) {
     state.stopping.store(true, Ordering::Release);
-    let mut pings = tokio::task::JoinSet::new();
+    let mut statuses = tokio::task::JoinSet::new();
     for (peer, _) in state.peers_snapshot().await {
         if topology::is_neighbour(state, &peer) {
             let state = state.clone();
-            pings.spawn(async move { send_ping(&state, &peer).await });
+            statuses.spawn(async move { send_status(&state, &peer).await });
         }
     }
-    let all_sent = async { while pings.join_next().await.is_some() {} };
+    let all_sent = async { while statuses.join_next().await.is_some() {} };
     let _ = tokio::time::timeout(FAREWELL_TIMEOUT, all_sent).await;
 }
 
-/// Our keepalive for `peer`.
-pub(crate) async fn local_keepalive(state: &AppState, peer: &str) -> transport::Keepalive {
+/// Our status for `peer`.
+pub(crate) async fn local_status(state: &AppState, peer: &str) -> transport::Status {
     // Heads and epoch are published together (`Replica::stamps`), so they always match,
     // and reading them doesn't wait for a sync message being applied.
     let (heads, epoch, epoch_seq) = {
@@ -64,7 +64,7 @@ pub(crate) async fn local_keepalive(state: &AppState, peer: &str) -> transport::
         }
         None => false,
     };
-    transport::Keepalive {
+    transport::Status {
         heads,
         epoch,
         epoch_seq,
@@ -73,8 +73,8 @@ pub(crate) async fn local_keepalive(state: &AppState, peer: &str) -> transport::
     }
 }
 
-/// What a peer's keepalive says about it.
-pub(super) async fn note_keepalive(state: &AppState, peer: &str, remote: &transport::Keepalive) {
+/// What a peer's status says about it.
+pub(super) async fn note_status(state: &AppState, peer: &str, remote: &transport::Status) {
     if let Some(peer_state) = state.get_peer_state(peer).await {
         let mut peer_state = peer_state.lock().await;
         let became_ready = remote.ready && peer_state.reports_ready != Some(true);
@@ -103,8 +103,8 @@ pub(super) async fn note_keepalive(state: &AppState, peer: &str, remote: &transp
 pub(super) async fn heal_if_diverged(
     state: &AppState,
     peer: &str,
-    local: &transport::Keepalive,
-    remote: &transport::Keepalive,
+    local: &transport::Status,
+    remote: &transport::Status,
 ) {
     // Heads of documents from different epochs are never equal and never converge.
     // And a peer that isn't our neighbour isn't ours to keep in step.
diff --git a/src/swarm/peer/mod.rs b/src/swarm/peer/mod.rs
index 0249f3b..415cddf 100644
--- a/src/swarm/peer/mod.rs
+++ b/src/swarm/peer/mod.rs
@@ -2,7 +2,7 @@
 //! swarm-wide forget records, and dispatch of inbound messages.
 //!
 //! * `handshake`: discovering peers, HELLO / HELLO_REPLY, membership.
-//! * `keepalive`: PING / PONG and the self-healing re-handshake.
+//! * `keepalive`: STATUS / STATUS_REPLY and the self-healing re-handshake.
 //! * `epoch`: the epochs peers advertise.
 //! * `admit`: admission with a swarm key.
 //! * `forget`: swarm-wide forget records.
@@ -24,6 +24,6 @@ pub(crate) use handshake::{
     apply_neighbour_change, peer_swarm, rehandshake, remember_peer, send_hello_once,
 };
 pub(crate) use inbound::handle_message;
-pub(crate) use keepalive::{farewell, send_ping};
+pub(crate) use keepalive::{farewell, send_status};
 pub(crate) use lanes::SyncLanes;
 pub(crate) use worker::run_peer_worker;
diff --git a/src/swarm/peer/worker.rs b/src/swarm/peer/worker.rs
index 057e4bd..c68e2ea 100644
--- a/src/swarm/peer/worker.rs
+++ b/src/swarm/peer/worker.rs
@@ -10,7 +10,7 @@ use tracing::{debug, info, warn};
 
 use super::forget::{AppliedForgets, apply_forget_records, forget_strangers};
 use super::handshake::retry_hello_if_due;
-use super::keepalive::send_ping;
+use super::keepalive::send_status;
 use crate::locks::MutexExt;
 use crate::state::AppState;
 use crate::swarm::sync::SyncEvent;
@@ -83,9 +83,9 @@ pub(crate) async fn run_peer_worker(state: AppState) {
             let probe_due =
                 !ping_due && crate::swarm::source::probe_due(&state, peer, Instant::now());
             if (ping_due || probe_due)
-                && let Err(error) = send_ping(&state, peer).await
+                && let Err(error) = send_status(&state, peer).await
             {
-                debug!(peer = %peer, error = %format!("{error:#}"), "Keepalive PING failed");
+                debug!(peer = %peer, error = %format!("{error:#}"), "Keepalive STATUS failed");
             }
 
             if let Err(error) = retry_hello_if_due(&state, peer).await {