use std::collections::VecDeque;
use std::net::SocketAddr;
use tracing::trace;
use super::super::constants::K;
use super::super::node::DhtNode;
use super::super::node_id::NodeId;
use super::super::routing_table::RoutingTable;
use super::{DhtTask, LookupEntry};
const ALPHA: usize = 3;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum LookupKind {
Node,
Peer,
}
#[derive(Clone, Debug)]
pub struct LookupResult {
pub kind: LookupKind,
pub target: NodeId,
pub nodes: Vec<DhtNode>,
pub peers: Vec<SocketAddr>,
pub tokens: Vec<(SocketAddr, Vec<u8>)>,
}
pub struct LookupState {
pub(super) target: NodeId,
pub(super) kind: LookupKind,
pub(super) entries: VecDeque<LookupEntry>,
pub(super) in_flight: usize,
pub(super) discovered_nodes: Vec<DhtNode>,
pub(super) discovered_peers: Vec<SocketAddr>,
pub(super) tokens: Vec<(SocketAddr, Vec<u8>)>,
pub(super) done: bool,
}
impl LookupState {
pub fn new(target: NodeId, kind: LookupKind) -> Self {
Self {
target,
kind,
entries: VecDeque::new(),
in_flight: 0,
discovered_nodes: Vec::new(),
discovered_peers: Vec::new(),
tokens: Vec::new(),
done: false,
}
}
pub fn startup(&mut self, routing_table: &RoutingTable, local_id: &NodeId) {
let closest = routing_table.get_closest_k_nodes(&self.target);
for node in closest {
if node.id() == local_id {
continue;
}
self.entries.push_back(LookupEntry {
node: node.clone(),
used: false,
});
}
if self.entries.is_empty() {
trace!("No seed nodes for lookup, finishing immediately");
self.done = true;
}
}
pub fn next_query_batch(&self) -> Vec<(usize, &DhtNode)> {
let mut batch = Vec::with_capacity(ALPHA);
let remaining = ALPHA.saturating_sub(self.in_flight);
for (i, entry) in self.entries.iter().enumerate() {
if batch.len() >= remaining {
break;
}
if !entry.used {
batch.push((i, &entry.node));
}
}
batch
}
pub fn mark_sent(&mut self, indices: &[usize]) {
for &i in indices {
if let Some(entry) = self.entries.get_mut(i) {
entry.used = true;
self.in_flight += 1;
}
}
}
pub fn on_response(
&mut self,
sender_addr: SocketAddr,
nodes: Vec<DhtNode>,
peers: Vec<SocketAddr>,
token: Option<Vec<u8>>,
local_id: &NodeId,
) {
self.in_flight = self.in_flight.saturating_sub(1);
for entry in &mut self.entries {
if entry.node.addr() == sender_addr {
entry.node.mark_contacted();
}
}
if let Some(tok) = token {
self.tokens.push((sender_addr, tok));
}
self.discovered_peers.extend(peers);
for node in nodes {
if node.id() == local_id {
continue;
}
if self.discovered_nodes.iter().any(|n| n.id() == node.id()) {
continue;
}
if self.entries.iter().any(|e| e.node.id() == node.id()) {
continue;
}
self.discovered_nodes.push(node.clone());
let dist = node.id().distance_to(&self.target);
let pos = self.entries.iter().position(|e| {
let e_dist = e.node.id().distance_to(&self.target);
dist < e_dist
});
let entry = LookupEntry { node, used: false };
match pos {
Some(idx) => self.entries.insert(idx, entry),
None => self.entries.push_back(entry),
}
}
while self.entries.len() > K {
self.entries.pop_back();
}
let mut seen = std::collections::HashSet::new();
self.entries
.retain(|e| seen.insert(*e.node.id().as_bytes()));
self.check_finished();
}
pub fn on_timeout(&mut self, timed_out_addr: SocketAddr) {
self.in_flight = self.in_flight.saturating_sub(1);
self.entries.retain(|e| e.node.addr() != timed_out_addr);
self.check_finished();
}
fn check_finished(&mut self) {
let remaining = ALPHA.saturating_sub(self.in_flight);
let has_unused = self.entries.iter().any(|e| !e.used);
if remaining > 0 && has_unused {
return;
}
if self.in_flight == 0 {
trace!(
target = %self.target,
kind = ?self.kind,
"Lookup finished"
);
self.done = true;
}
}
pub fn is_done(&self) -> bool {
self.done
}
pub fn into_result(self) -> LookupResult {
let nodes: Vec<DhtNode> = self
.entries
.into_iter()
.map(|e| e.node)
.chain(self.discovered_nodes)
.take(K)
.collect();
LookupResult {
kind: self.kind,
target: self.target,
nodes,
peers: self.discovered_peers,
tokens: self.tokens,
}
}
pub fn target(&self) -> &NodeId {
&self.target
}
pub fn kind(&self) -> &LookupKind {
&self.kind
}
pub fn entries(&self) -> &VecDeque<LookupEntry> {
&self.entries
}
}
pub struct DhtLookupTask {
state: LookupState,
started: bool,
}
impl DhtLookupTask {
pub fn new(target: NodeId, kind: LookupKind) -> Self {
Self {
state: LookupState::new(target, kind),
started: false,
}
}
pub fn state_mut(&mut self) -> &mut LookupState {
&mut self.state
}
pub fn state(&self) -> &LookupState {
&self.state
}
}
impl DhtTask for DhtLookupTask {
fn startup(&mut self) {
self.started = true;
}
fn finished(&self) -> bool {
self.state.is_done()
}
}