#![allow(dead_code)]
pub mod kad;
pub mod kbucket;
pub mod protocol;
pub mod record;
mod addresses;
pub mod cli;
mod control;
mod query;
mod task_limit;
pub use control::Control;
mod dht_proto {
include!(concat!(env!("OUT_DIR"), "/dht.pb.rs"));
}
pub use record::{store, ProviderRecord, Record};
use std::error::Error;
use std::fmt;
use std::num::NonZeroUsize;
use futures::channel::{mpsc, oneshot};
use libp2prs_core::PeerId;
use libp2prs_swarm::SwarmError;
pub const K_VALUE: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(20) };
pub const ALPHA_VALUE: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
pub const BETA_VALUE: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
#[derive(Debug)]
pub enum KadError {
MaxRecords,
ValueTooLarge,
NoKnownPeers,
NotFound,
Upgrade,
Bootstrap,
Internal,
Timeout,
Decode,
UnexpectedMessage(&'static str),
InvalidSource(PeerId),
Unsupported(&'static str),
Io(std::io::Error),
Swarm(SwarmError),
Closing(u32),
}
impl fmt::Display for KadError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
KadError::MaxRecords => write!(f, "Storage is at capaticy"),
KadError::NoKnownPeers => write!(f, "No any peers in routing table"),
KadError::NotFound => write!(f, "Not found"),
KadError::Timeout => write!(f, "Iterative query timeout"),
KadError::Swarm(e) => write!(f, "Underlying Swarm error {}", e),
_ => write!(f, "Kad error"),
}
}
}
impl Error for KadError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
KadError::MaxRecords => None,
KadError::Io(err) => Some(err),
_ => None,
}
}
}
impl From<mpsc::SendError> for KadError {
fn from(_: mpsc::SendError) -> Self {
KadError::Internal
}
}
impl From<std::io::Error> for KadError {
fn from(err: std::io::Error) -> Self {
KadError::Io(err)
}
}
impl From<SwarmError> for KadError {
fn from(err: SwarmError) -> Self {
KadError::Swarm(err)
}
}
impl From<oneshot::Canceled> for KadError {
fn from(_: oneshot::Canceled) -> Self {
KadError::Internal
}
}