1 files changed, 30 insertions, 33 deletions

diff --git a/src/swarm/peer.rs b/src/swarm/peer.rs
index 6184427..53a4731 100644
--- a/src/swarm/peer.rs
+++ b/src/swarm/peer.rs
@@ -1,5 +1,5 @@
 //! Peers: handshake (HELLO / HELLO_REPLY), liveness and keepalives, self-healing,
-//! cluster-wide forget records, and dispatch of inbound messages.
+//! swarm-wide forget records, and dispatch of inbound messages.
 
 use std::sync::Arc;
 use std::time::Duration;
@@ -70,7 +70,7 @@ async fn apply_forget_records(state: &AppState) {
         if alive {
             cancel.push(pk);
         } else if state.peer_states.write().await.remove(&pk).is_some() {
-            info!(peer = %pk, "Forgetting peer per cluster-wide record");
+            info!(peer = %pk, "Forgetting peer per swarm-wide record");
         }
     }
 
@@ -84,7 +84,7 @@ async fn apply_forget_records(state: &AppState) {
         .mutate_doc(move |doc| {
             for pk in &cancel {
                 match store::delete_path(&mut *doc, &forgotten_path(pk), false) {
-                    Ok(()) => info!(peer = %pk, "Peer is alive; cancelling cluster-wide forget"),
+                    Ok(()) => info!(peer = %pk, "Peer is alive; cancelling swarm-wide forget"),
                     Err(StoreError::NotFound) => {}
                     Err(error) => {
                         warn!(peer = %pk, error = %error, "Failed to cancel forget record")
@@ -267,10 +267,10 @@ async fn ensure_handshake(state: &AppState, peer: &str) {
     }
 }
 
-/// Sends a HELLO_REPLY if one is owed and our cluster ID is known.
+/// Sends a HELLO_REPLY if one is owed and our swarm ID is known.
 /// Otherwise it stays owed and the peer worker tries again.
 async fn send_owed_hello_reply(state: &AppState, peer: &str) {
-    if state.cluster_id().await.is_none() {
+    if state.swarm_id().await.is_none() {
         return;
     }
 
@@ -297,10 +297,10 @@ async fn flush_owed_hello_replies(state: &AppState) {
 }
 
 async fn send_hello_reply(state: &AppState, peer: &str) -> Result<()> {
-    let cluster_id = state
-        .cluster_id()
+    let swarm_id = state
+        .swarm_id()
         .await
-        .ok_or_else(|| anyhow!("Cannot send HELLO_REPLY without an established cluster ID"))?;
+        .ok_or_else(|| anyhow!("Cannot send HELLO_REPLY without an established swarm ID"))?;
 
     let candidates: Vec<(String, Arc<Mutex<PeerState>>)> = state
         .peer_states
@@ -322,7 +322,7 @@ async fn send_hello_reply(state: &AppState, peer: &str) -> Result<()> {
     }
 
     let reply = transport::HelloReply {
-        cluster_id,
+        swarm_id,
         peers,
         epoch: state.local_epoch(),
     };
@@ -441,16 +441,16 @@ pub(crate) async fn run_peer_worker(state: AppState) {
 async fn establish_peer(
     state: &AppState,
     peer: &str,
-    cluster_id: String,
+    swarm_id: String,
 ) -> Result<Vec<transport::SyncEnvelope>> {
-    let expected_cluster = state.cluster_id().await;
+    let expected_swarm = state.swarm_id().await;
 
-    if let Some(expected) = &expected_cluster {
-        if expected != &cluster_id {
+    if let Some(expected) = &expected_swarm {
+        if expected != &swarm_id {
             bail!(
-                "Incompatible cluster at {peer}: expected {}, received {}",
+                "Incompatible swarm at {peer}: expected {}, received {}",
                 expected,
-                cluster_id
+                swarm_id
             );
         }
     }
@@ -458,27 +458,24 @@ async fn establish_peer(
     let peer_state_mutex = state.get_or_create_peer_state(peer).await;
     let mut peer_state = peer_state_mutex.lock().await;
 
-    if let PeerMembership::Member {
-        cluster_id: existing,
-    } = &peer_state.membership
-    {
-        if existing != &cluster_id {
+    if let PeerMembership::Member { swarm_id: existing } = &peer_state.membership {
+        if existing != &swarm_id {
             bail!(
-                "Peer {peer} changed cluster identity from {} to {}",
+                "Peer {peer} changed swarm identity from {} to {}",
                 existing,
-                cluster_id
+                swarm_id
             );
         }
     }
 
     // Lock order: peer mutex -> lifecycle.
-    if expected_cluster.is_none() {
-        state.set_expected_cluster_id(cluster_id.clone()).await?;
+    if expected_swarm.is_none() {
+        state.set_expected_swarm_id(swarm_id.clone()).await?;
     }
 
     if matches!(peer_state.membership, PeerMembership::Unknown) {
         peer_state.membership = PeerMembership::Member {
-            cluster_id: cluster_id.clone(),
+            swarm_id: swarm_id.clone(),
         };
     }
 
@@ -492,17 +489,17 @@ async fn establish_peer(
 
     let pending = std::mem::take(&mut peer_state.pending_inbound_sync);
 
-    info!(peer = %peer, cluster_id = %cluster_id, pending_messages = pending.len(), "Peer membership established");
+    info!(peer = %peer, swarm_id = %swarm_id, pending_messages = pending.len(), "Peer membership established");
     Ok(pending)
 }
 
 #[instrument(skip(state), fields(peer = %peer))]
-pub(crate) async fn peer_cluster(state: &AppState, peer: &str) -> Option<String> {
+pub(crate) async fn peer_swarm(state: &AppState, peer: &str) -> Option<String> {
     let peer_state_mutex = state.get_peer_state(peer).await?;
     let peer_state = peer_state_mutex.lock().await;
     match &peer_state.membership {
         PeerMembership::Unknown => None,
-        PeerMembership::Member { cluster_id } => Some(cluster_id.clone()),
+        PeerMembership::Member { swarm_id } => Some(swarm_id.clone()),
     }
 }
 
@@ -607,7 +604,7 @@ pub(crate) async fn handle_message(
                 peer_state.reply_owed = true;
             }
 
-            // Sends now if we know our cluster ID; otherwise stays owed.
+            // Sends now if we know our swarm ID; otherwise stays owed.
             send_owed_hello_reply(state, &peer).await;
 
             // Our own HELLO goes out regardless of whether the reply could be sent.
@@ -621,11 +618,11 @@ pub(crate) async fn handle_message(
                 .send(SyncEvent::PeerNeedsSync(peer.clone()));
         }
         transport::ParsedMessage::HelloReply(reply) => {
-            let pending = establish_peer(state, &peer, reply.cluster_id.clone()).await?;
+            let pending = establish_peer(state, &peer, reply.swarm_id.clone()).await?;
 
             discover_peers(state, &peer, &reply.peers).await;
 
-            // Our cluster ID may have just become known: pay any replies we owe.
+            // Our swarm ID may have just become known: pay any replies we owe.
             flush_owed_hello_replies(state).await;
 
             if !pending.is_empty() {
@@ -657,7 +654,7 @@ pub(crate) async fn handle_message(
             handle_sync(state, &peer, envelope).await?;
         }
         transport::ParsedMessage::Ping(remote) => {
-            if reactivated || peer_cluster(state, &peer).await.is_none() {
+            if reactivated || peer_swarm(state, &peer).await.is_none() {
                 ensure_handshake(state, &peer).await;
             }
             let local = local_keepalive(state).await;
@@ -671,7 +668,7 @@ pub(crate) async fn handle_message(
             }
         }
         transport::ParsedMessage::Pong(remote) => {
-            if reactivated || peer_cluster(state, &peer).await.is_none() {
+            if reactivated || peer_swarm(state, &peer).await.is_none() {
                 ensure_handshake(state, &peer).await;
             }
             let local = local_keepalive(state).await;