laantungir/fips
1
0
Fork 0
mirror of https://github.com/jmcorgan/fips.git synced 2026-08-09 00:04:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

proto: rename the mesh discovery subsystem module from discovery to lookup

Browse Source 
Rename src/proto/discovery to src/proto/lookup and bring the module's naming
onto the lookup stem, matching its concept: a mesh lookup of a node's
coordinates from its pubkey, sent into the mesh as a bloom-filter-guided
multicast request that returns a unicast response with the coordinates.

- the module directory and its declaration (proto::discovery -> proto::lookup)
- exported types: DiscoveryAction -> LookupAction, DiscoveryBackoff ->
  LookupBackoff, DiscoveryForwardRateLimiter -> LookupForwardRateLimiter,
  MAX_RECENT_DISCOVERY_REQUESTS -> MAX_RECENT_LOOKUP_REQUESTS, and the Discovery
  state struct -> Lookup
- internal terminology: doc comments, the "overlay-lookup" phrasing, the
  empty_discovery/suppressing_discovery test helpers, and the disc
  parameter/variable all take the lookup names
- the already-lookup-named wire types (LookupRequest/LookupResponse) are unchanged

Behavior-neutral: no wire bytes or decision logic change. Two references are
intentionally kept as "discovery": the still-named node::handlers::discovery
shell module and the node.discovery.* config keys, which belong to the broader
disambiguation of the shell, config, and metric surfaces still to come.
This commit is contained in:
Johnathan Corgan
2026-07-08 21:54:24 +00:00
parent 2b009196b5
commit e3e03f6a5d
15 changed files with 295 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/node/handlers/discovery.rs
+31 -31
View File
@@ -7,8 +7,8 @@
use crate::node::Node;
use crate::node::reject::DiscoveryReject;
use crate::proto::discovery::{
DiscoveryAction, LookupRequest, LookupResponse, MAX_RECENT_DISCOVERY_REQUESTS,
use crate::proto::lookup::{
LookupAction, LookupRequest, LookupResponse, MAX_RECENT_LOOKUP_REQUESTS,
};
use crate::transport::{TransportAddr, TransportId};
use crate::{NodeAddr, PeerIdentity};
@@ -26,7 +26,7 @@ struct NodeRoutingView<'a> {
node: &'a Node,
}
impl crate::proto::discovery::RoutingView for NodeRoutingView<'_> {
impl crate::proto::lookup::RoutingView for NodeRoutingView<'_> {
fn is_tree_peer(&self, addr: &NodeAddr) -> bool {
self.node.is_tree_peer(addr)
}
@@ -67,15 +67,15 @@ impl Node {
let now_ms = Self::now_ms();
let recent_expiry_ms = self.config().node.discovery.recent_expiry_secs * 1000;
let my_addr = *self.node_addr();
use crate::proto::discovery::RequestOutcome;
match crate::proto::discovery::classify_request(
use crate::proto::lookup::RequestOutcome;
match crate::proto::lookup::classify_request(
&mut self.discovery,
&request,
from,
&my_addr,
now_ms,
recent_expiry_ms,
MAX_RECENT_DISCOVERY_REQUESTS,
MAX_RECENT_LOOKUP_REQUESTS,
) {
RequestOutcome::Duplicate => {
self.metrics()
@@ -95,7 +95,7 @@ impl Node {
request_id = request.request_id,
from = %self.peer_display_name(from),
recent_requests = len,
max_recent_requests = MAX_RECENT_DISCOVERY_REQUESTS,
max_recent_requests = MAX_RECENT_LOOKUP_REQUESTS,
"Discovery request dedup cache full, dropping LookupRequest"
);
}
@@ -161,8 +161,8 @@ impl Node {
let now_ms = Self::now_ms();
// Check if we forwarded this request (transit node) or originated it
match crate::proto::discovery::classify_response(&mut self.discovery, response.request_id) {
crate::proto::discovery::ResponseRoute::AlreadyForwarded => {
match crate::proto::lookup::classify_response(&mut self.discovery, response.request_id) {
crate::proto::lookup::ResponseRoute::AlreadyForwarded => {
// Already forwarded a response for this request — drop to
// prevent response routing loops.
debug!(
@@ -171,7 +171,7 @@ impl Node {
"Response already forwarded for this request, dropping"
);
}
crate::proto::discovery::ResponseRoute::Transit { from_peer } => {
crate::proto::lookup::ResponseRoute::Transit { from_peer } => {
// Transit node: reverse-path forward
self.metrics().discovery.resp_forwarded.inc();
@@ -195,7 +195,7 @@ impl Node {
);
}
}
crate::proto::discovery::ResponseRoute::Originator => {
crate::proto::lookup::ResponseRoute::Originator => {
// We originated this request — verify proof before caching
let target = response.target;
let path_mtu = response.path_mtu;
@@ -251,7 +251,7 @@ impl Node {
// Apply the accept-side effects: the core clears the success
// state (backoff + pending lookup) and returns the
// cross-subsystem effects for us to drive.
let actions = crate::proto::discovery::on_response_accepted(
let actions = crate::proto::lookup::on_response_accepted(
&mut self.discovery,
&target,
response.target_coords,
@@ -266,10 +266,10 @@ impl Node {
/// Drive the cross-subsystem effects returned by the discovery core's
/// accept-side planning. Each arm reproduces the original inline effect
/// exactly (same metrics/logs/writes, same order).
async fn drive_response_actions(&mut self, actions: Vec<DiscoveryAction>) {
async fn drive_response_actions(&mut self, actions: Vec<LookupAction>) {
for action in actions {
match action {
DiscoveryAction::CacheCoords {
LookupAction::CacheCoords {
target,
coords,
now_ms,
@@ -278,7 +278,7 @@ impl Node {
self.coord_cache
.insert_with_path_mtu(target, coords, now_ms, path_mtu);
}
DiscoveryAction::WritePathMtu { target, path_mtu } => {
LookupAction::WritePathMtu { target, path_mtu } => {
// Mirror path_mtu into the FipsAddress-keyed read-only lookup
// map used by the TUN reader/writer at TCP MSS clamp time.
let fips_addr = crate::FipsAddress::from_node_addr(&target);
@@ -305,7 +305,7 @@ impl Node {
}
}
}
DiscoveryAction::ResetWarmupIfEstablished { target } => {
LookupAction::ResetWarmupIfEstablished { target } => {
// If an established session exists, reset the warmup counter.
let n = self.config().node.session.coords_warmup_packets;
if let Some(entry) = self.sessions.get_mut(&target)
@@ -319,7 +319,7 @@ impl Node {
);
}
}
DiscoveryAction::RetryQueuedPackets { target } => {
LookupAction::RetryQueuedPackets { target } => {
// If we have pending TUN packets for this target, retry session
// initiation. The coord_cache now has coords, so find_next_hop()
// should succeed.
@@ -332,7 +332,7 @@ impl Node {
self.retry_session_after_discovery(target).await;
}
}
DiscoveryAction::SendLink { peer, bytes } => {
LookupAction::SendLink { peer, bytes } => {
if let Err(e) = self.send_encrypted_link_message(&peer, &bytes).await {
debug!(
peer = %self.peer_display_name(&peer),
@@ -360,8 +360,8 @@ impl Node {
// Route toward origin. The reverse-path decision (the peer the request
// arrived from, recorded in recent_requests) is the sans-IO core's; the
// greedy tree-route fallback is a &mut coord-cache op kept in the shell.
use crate::proto::discovery::ResponseRouteDecision;
let next_hop_addr = match crate::proto::discovery::plan_response_route(
use crate::proto::lookup::ResponseRouteDecision;
let next_hop_addr = match crate::proto::lookup::plan_response_route(
&self.discovery,
request.request_id,
) {
@@ -423,18 +423,18 @@ impl Node {
// fan-out; the shell keeps all metrics/logging and drives the sends.
let outcome = {
let rv = NodeRoutingView { node: self };
crate::proto::discovery::plan_forward(&mut request, &rv)
crate::proto::lookup::plan_forward(&mut request, &rv)
};
match outcome {
crate::proto::discovery::ForwardOutcome::TtlExhausted => {}
crate::proto::discovery::ForwardOutcome::NoPeers => {
crate::proto::lookup::ForwardOutcome::TtlExhausted => {}
crate::proto::lookup::ForwardOutcome::NoPeers => {
self.metrics().discovery.req_no_tree_peer.inc();
trace!(
request_id = request.request_id,
"No eligible peers to forward LookupRequest"
);
}
crate::proto::discovery::ForwardOutcome::Forward {
crate::proto::lookup::ForwardOutcome::Forward {
actions,
used_fallback,
} => {
@@ -458,7 +458,7 @@ impl Node {
);
}
for action in actions {
if let DiscoveryAction::SendLink { peer, bytes } = action
if let LookupAction::SendLink { peer, bytes } = action
&& let Err(e) = self.send_encrypted_link_message(&peer, &bytes).await
{
debug!(
@@ -494,7 +494,7 @@ impl Node {
// the shell drives the sends and keeps all metrics/logging.
let actions = {
let rv = NodeRoutingView { node: self };
crate::proto::discovery::plan_initiate(&request, &rv)
crate::proto::lookup::plan_initiate(&request, &rv)
};
let peer_count = actions.len();
@@ -509,7 +509,7 @@ impl Node {
);
for action in actions {
if let DiscoveryAction::SendLink { peer, bytes } = action
if let LookupAction::SendLink { peer, bytes } = action
&& let Err(e) = self.send_encrypted_link_message(&peer, &bytes).await
{
debug!(
@@ -539,8 +539,8 @@ impl Node {
// overlapping the immutable peer-table read.
let reachable = self.peers.values().any(|peer| peer.may_reach(dest));
use crate::proto::discovery::InitiateDecision;
match crate::proto::discovery::initiate_gate(&mut self.discovery, dest, now_ms, reachable) {
use crate::proto::lookup::InitiateDecision;
match crate::proto::lookup::initiate_gate(&mut self.discovery, dest, now_ms, reachable) {
InitiateDecision::Deduplicated => {
self.metrics().discovery.req_deduplicated.inc();
debug!(
@@ -569,7 +569,7 @@ impl Node {
// If no tree peers had the target, fail immediately
if sent == 0 {
crate::proto::discovery::initiate_failed(&mut self.discovery, dest, now_ms);
crate::proto::lookup::initiate_failed(&mut self.discovery, dest, now_ms);
debug!(
target_node = %self.peer_display_name(dest),
"Discovery failed, no tree peers with bloom match"
@@ -592,7 +592,7 @@ impl Node {
pub(in crate::node) async fn check_pending_lookups(&mut self, now_ms: u64) {
let attempt_timeouts = self.config().node.discovery.attempt_timeouts_secs.clone();
let outcome =
crate::proto::discovery::poll_pending(&mut self.discovery, now_ms, &attempt_timeouts);
crate::proto::lookup::poll_pending(&mut self.discovery, now_ms, &attempt_timeouts);
for (target, attempt) in outcome.retries {
let ttl = self.config().node.discovery.ttl;
src/node/mod.rs
+7 -7
View File
@@ -43,9 +43,9 @@ use crate::cache::CoordCache;
use crate::node::session::SessionEntry;
use crate::peer::{ActivePeer, PeerConnection};
use crate::proto::bloom::{BloomFilter, BloomState};
use crate::proto::discovery::{Discovery, DiscoveryBackoff, DiscoveryForwardRateLimiter};
use crate::proto::fmp::Fmp;
use crate::proto::fsp::Fsp;
use crate::proto::lookup::{Lookup, LookupBackoff, LookupForwardRateLimiter};
use crate::proto::mmp::Mmp;
use crate::proto::routing::{self, Router, RoutingErrorRateLimiter};
use crate::proto::stp::TreeState;
@@ -337,7 +337,7 @@ pub struct Node {
// === Discovery ===
/// Discovery-subsystem state: recent-request dedup cache, in-flight
/// lookups, originator-side backoff, and transit-side forward limiter.
discovery: Discovery,
discovery: Lookup,
// === Counters ===
/// Next link ID to allocate.
@@ -678,9 +678,9 @@ impl Node {
coords_response_rate_limiter: RoutingErrorRateLimiter::with_interval_ms(
coords_response_interval_ms,
),
discovery: Discovery::new(
DiscoveryBackoff::with_params(backoff_base_secs, backoff_max_secs),
DiscoveryForwardRateLimiter::with_interval_ms(forward_min_interval_secs * 1000),
discovery: Lookup::new(
LookupBackoff::with_params(backoff_base_secs, backoff_max_secs),
LookupForwardRateLimiter::with_interval_ms(forward_min_interval_secs * 1000),
),
pending_connects: Vec::new(),
retry_pending: HashMap::new(),
@@ -843,7 +843,7 @@ impl Node {
coords_response_rate_limiter: RoutingErrorRateLimiter::with_interval_ms(
coords_response_interval_ms,
),
discovery: Discovery::new(DiscoveryBackoff::new(), DiscoveryForwardRateLimiter::new()),
discovery: Lookup::new(LookupBackoff::new(), LookupForwardRateLimiter::new()),
pending_connects: Vec::new(),
retry_pending: HashMap::new(),
nostr_discovery: None,
@@ -2541,7 +2541,7 @@ impl Node {
/// Iterate over pending discovery lookups for diagnostics.
pub fn pending_lookups_iter(
&self,
) -> impl Iterator<Item = (&NodeAddr, &crate::proto::discovery::PendingLookup)> {
) -> impl Iterator<Item = (&NodeAddr, &crate::proto::lookup::PendingLookup)> {
self.discovery.pending_lookups.iter()
}
src/node/tests/discovery.rs
+2 -2
View File
@@ -5,7 +5,7 @@
//! response routing.
use super::*;
use crate::proto::discovery::{LookupRequest, LookupResponse, RecentRequest};
use crate::proto::lookup::{LookupRequest, LookupResponse, RecentRequest};
use crate::proto::stp::TreeCoordinate;
use spanning_tree::{
cleanup_nodes, generate_random_edges, lock_large_network_test, process_available_packets,
@@ -1040,7 +1040,7 @@ async fn test_open_discovery_sweep_queues_eligible_skips_filtered() {
async fn test_check_pending_lookups_default_sequence_unreachable() {
use crate::peer::ActivePeer;
use crate::proto::bloom::BloomFilter;
use crate::proto::discovery::PendingLookup;
use crate::proto::lookup::PendingLookup;
use crate::transport::LinkId;
use std::sync::mpsc;