Struct DhtHandler 

pub struct DhtHandler { /* private fields */ }

Serves cdn/dht/v1. Owns the routing table + the per-request rate limiter; accept() is reentrant — many concurrent streams from different peers all share the same Arc<DhtHandler>.

Routing-table updates take a short Mutex — the table is touched once per request to refresh the requester’s recency and once again to produce the closer_nodes snapshot. We use std::sync::Mutex rather than tokio::sync::Mutex since the critical section is microseconds long (no awaits) and the lock would just add scheduler overhead.

Implementations

impl DhtHandler

pub const ALPN: &'static [u8] = ALPN_DHT

The ALPN this handler answers on: cdn/dht/v1, the content-discovery protocol (ADR 022).

pub fn new( self_id: PublicKey, rate_limiter: Arc<DhtRateLimiter>, dispatch_limiter: Arc<ConnectionLimiter>, metrics: Arc<Metrics>, staker_set: Arc<dyn StakerSet>, records: Arc<Mutex<RecordStore>>, ) -> Self

Construct a handler. The routing table is empty at construction; the runtime’s DHT bootstrap fills it from the on-chain staker set, and the handler additionally updates the table from every incoming request’s authenticated NodeId once it knows the peer is rate-limit admitted.

pub const fn with_routing( self_id: PublicKey, routing: Arc<Mutex<RoutingTable>>, rate_limiter: Arc<DhtRateLimiter>, dispatch_limiter: Arc<ConnectionLimiter>, metrics: Arc<Metrics>, staker_set: Arc<dyn StakerSet>, records: Arc<Mutex<RecordStore>>, ) -> Self

Construct with a pre-built routing table. Used by tests and by the bootstrap path that wants to seed the table before the handler goes live.

pub fn routing_table(&self) -> Arc<Mutex<RoutingTable>>

Shared handle to the routing table — exposed so the runtime’s bootstrap and bucket-refresh tasks drive the same table without re-allocating the Arc<Mutex<RoutingTable>> from outside.

Trait Implementations

impl Debug for DhtHandler

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ProtocolHandler for DhtHandler

async fn accept(&self, connection: Connection) -> Result<(), AcceptError>

Handle an incoming connection.

fn on_accepting( &self, accepting: Accepting, ) -> impl Future<Output = Result<Connection, AcceptError>> + Send

Optional interception point to handle the Accepting state.

fn shutdown(&self) -> impl Future<Output = ()> + Send

Called when the router shuts down.