From 4c95be0000110eac0064e51411904ee928e835c1 Mon Sep 17 00:00:00 2001 From: Johnathan Corgan Date: Sat, 11 Jul 2026 23:01:48 +0000 Subject: [PATCH] transport/ble: rename discovery module to neighbor Mirror the ethernet neighbor rename in the BLE transport: the internal peer-detection buffer becomes NeighborBuffer (from DiscoveryBuffer) and the module is renamed discovery -> neighbor. The BlueR/bluez API terms (DiscoveryFilter, set_discovery_filter) and the BLE advertise/scan mechanism vocabulary are unchanged, as is BleConfig. Behavior-neutral. --- src/transport/ble/mod.rs | 38 +++++++++---------- .../ble/{discovery.rs => neighbor.rs} | 28 +++++++------- 2 files changed, 33 insertions(+), 33 deletions(-) rename src/transport/ble/{discovery.rs => neighbor.rs} (82%) diff --git a/src/transport/ble/mod.rs b/src/transport/ble/mod.rs index 9561dae..098868f 100644 --- a/src/transport/ble/mod.rs +++ b/src/transport/ble/mod.rs @@ -7,7 +7,7 @@ //! //! ## Architecture //! -//! Transport logic (pool, discovery, lifecycle) is separated from the +//! Transport logic (pool, neighbor, lifecycle) is separated from the //! BlueZ/bluer stack via the `BleIo` trait. `BluerIo` provides the real //! implementation (behind `cfg(bluer_available)`); `MockBleIo` provides //! an in-memory test double for CI without hardware. @@ -19,8 +19,8 @@ //! static (configured) peers get priority over discovered peers. pub mod addr; -pub mod discovery; pub mod io; +pub mod neighbor; pub mod pool; pub mod stats; @@ -31,8 +31,8 @@ use super::{ use crate::config::BleConfig; use crate::identity::NodeAddr; use addr::BleAddr; -use discovery::DiscoveryBuffer; use io::{BleIo, BleScanner, BleStream}; +use neighbor::NeighborBuffer; use pool::{BleConnection, ConnectionPool}; use stats::BleStats; @@ -88,8 +88,8 @@ pub struct BleTransport { accept_task: Option>, /// Combined scan + probe loop task handle. scan_probe_task: Option>, - /// Discovery buffer for discovered peers. - discovery_buffer: Arc, + /// Neighbor buffer for discovered peers. + neighbor_buffer: Arc, /// Transport statistics. stats: Arc, /// Our public key for pre-handshake identity exchange. @@ -127,7 +127,7 @@ impl BleTransport { packet_tx, accept_task: None, scan_probe_task: None, - discovery_buffer: Arc::new(DiscoveryBuffer::new(transport_id)), + neighbor_buffer: Arc::new(NeighborBuffer::new(transport_id)), stats: Arc::new(BleStats::new()), local_pubkey: None, } @@ -192,7 +192,7 @@ impl BleTransport { stats, max_conns, self.local_pubkey, - Arc::clone(&self.discovery_buffer), + Arc::clone(&self.neighbor_buffer), local_node_addr, ))); debug!(adapter = %adapter, psm = psm, "BLE accept loop started"); @@ -223,7 +223,7 @@ impl BleTransport { scanner, Arc::clone(&self.io), Arc::clone(&self.pool), - Arc::clone(&self.discovery_buffer), + Arc::clone(&self.neighbor_buffer), Arc::clone(&self.stats), self.local_pubkey, self.config.psm(), @@ -369,7 +369,7 @@ impl BleTransport { match pubkey_exchange(&stream, our_pubkey).await { Ok(peer_pubkey) => { debug!(addr = %addr, "BLE outbound pubkey exchange complete"); - self.discovery_buffer + self.neighbor_buffer .add_peer_with_pubkey(&ble_addr, peer_pubkey); } Err(e) => { @@ -470,7 +470,7 @@ impl BleTransport { let timeout_ms = self.config.connect_timeout_ms(); let addr_clone = addr.clone(); let local_pubkey = self.local_pubkey; - let discovery_buffer = Arc::clone(&self.discovery_buffer); + let neighbor_buffer = Arc::clone(&self.neighbor_buffer); let task = tokio::spawn(async move { let result = tokio::time::timeout( @@ -489,7 +489,7 @@ impl BleTransport { match pubkey_exchange(&stream, our_pubkey).await { Ok(peer_pubkey) => { debug!(addr = %addr_clone, "BLE outbound pubkey exchange complete"); - discovery_buffer.add_peer_with_pubkey(&ble_addr, peer_pubkey); + neighbor_buffer.add_peer_with_pubkey(&ble_addr, peer_pubkey); } Err(e) => { warn!( @@ -639,7 +639,7 @@ impl Transport for BleTransport { } fn discover(&self) -> Result, TransportError> { - Ok(self.discovery_buffer.take()) + Ok(self.neighbor_buffer.take()) } fn auto_connect(&self) -> bool { @@ -728,7 +728,7 @@ async fn accept_loop( stats: Arc, _max_conns: usize, local_pubkey: Option<[u8; 32]>, - discovery_buffer: Arc, + neighbor_buffer: Arc, local_node_addr: Option, ) where A: io::BleAcceptor, @@ -757,7 +757,7 @@ async fn accept_loop( match pubkey_exchange(&stream, our_pubkey).await { Ok(peer_pubkey) => { debug!(addr = %ta, "BLE inbound pubkey exchange complete"); - discovery_buffer.add_peer_with_pubkey(&addr, peer_pubkey); + neighbor_buffer.add_peer_with_pubkey(&addr, peer_pubkey); // Cross-probe tie-breaker: smaller NodeAddr's // outbound wins. If we're smaller, our outbound @@ -872,7 +872,7 @@ async fn receive_loop( /// Each scan result is probed immediately unless the address is in cooldown /// (recently probed) or already connected. On successful probe, the /// connection is promoted directly into the pool (no second L2CAP connect -/// needed) and the peer is reported to the discovery buffer for the node +/// needed) and the peer is reported to the neighbor buffer for the node /// layer to auto-connect. /// /// Cooldown prevents rapid re-probing of the same address: after any probe @@ -883,7 +883,7 @@ async fn scan_probe_loop( mut scanner: I::Scanner, io: Arc, pool: Arc>>>, - buffer: Arc, + buffer: Arc, stats: Arc, local_pubkey: Option<[u8; 32]>, psm: u16, @@ -1136,8 +1136,8 @@ mod tests { // Let the expired entries get processed tokio::task::yield_now().await; - // Without pubkey set, scan results go to discovery buffer as bare MACs - let peers = transport.discovery_buffer.take(); + // Without pubkey set, scan results go to neighbor buffer as bare MACs + let peers = transport.neighbor_buffer.take(); assert_eq!(peers.len(), 2); } @@ -1156,7 +1156,7 @@ mod tests { tokio::time::advance(std::time::Duration::from_secs(6)).await; tokio::task::yield_now().await; - let peers = transport.discovery_buffer.take(); + let peers = transport.neighbor_buffer.take(); assert_eq!(peers.len(), 1); } diff --git a/src/transport/ble/discovery.rs b/src/transport/ble/neighbor.rs similarity index 82% rename from src/transport/ble/discovery.rs rename to src/transport/ble/neighbor.rs index 8db9736..e0b588c 100644 --- a/src/transport/ble/discovery.rs +++ b/src/transport/ble/neighbor.rs @@ -1,4 +1,4 @@ -//! BLE discovery via advertising and scanning. +//! BLE neighbor detection via advertising and scanning. //! //! BLE advertisements carry a 128-bit FIPS service UUID for identification. //! Post-forklift, advertisements are UUID-only (no identity material); @@ -12,15 +12,15 @@ use super::addr::BleAddr; /// Buffer for discovered BLE peers, drained by `discover()`. /// -/// Follows the same pattern as Ethernet's `DiscoveryBuffer`: peers are -/// added from the scan loop and drained by the node's discovery polling. -pub struct DiscoveryBuffer { +/// Follows the same pattern as Ethernet's `NeighborBuffer`: peers are +/// added from the scan loop and drained by the node's neighbor polling. +pub struct NeighborBuffer { transport_id: TransportId, peers: Mutex>, } -impl DiscoveryBuffer { - /// Create a new empty discovery buffer. +impl NeighborBuffer { + /// Create a new empty neighbor buffer. pub fn new(transport_id: TransportId) -> Self { Self { transport_id, @@ -79,8 +79,8 @@ mod tests { } #[test] - fn test_discovery_buffer_add_take() { - let buffer = DiscoveryBuffer::new(TransportId::new(1)); + fn test_neighbor_buffer_add_take() { + let buffer = NeighborBuffer::new(TransportId::new(1)); buffer.add_peer(&test_addr(1)); let peers = buffer.take(); @@ -92,8 +92,8 @@ mod tests { } #[test] - fn test_discovery_buffer_dedup() { - let buffer = DiscoveryBuffer::new(TransportId::new(1)); + fn test_neighbor_buffer_dedup() { + let buffer = NeighborBuffer::new(TransportId::new(1)); buffer.add_peer(&test_addr(1)); buffer.add_peer(&test_addr(1)); // same address again @@ -102,8 +102,8 @@ mod tests { } #[test] - fn test_discovery_buffer_multiple_peers() { - let buffer = DiscoveryBuffer::new(TransportId::new(1)); + fn test_neighbor_buffer_multiple_peers() { + let buffer = NeighborBuffer::new(TransportId::new(1)); buffer.add_peer(&test_addr(1)); buffer.add_peer(&test_addr(2)); buffer.add_peer(&test_addr(3)); @@ -113,8 +113,8 @@ mod tests { } #[test] - fn test_discovery_buffer_transport_addr_format() { - let buffer = DiscoveryBuffer::new(TransportId::new(1)); + fn test_neighbor_buffer_transport_addr_format() { + let buffer = NeighborBuffer::new(TransportId::new(1)); buffer.add_peer(&test_addr(0x42)); let peers = buffer.take();