Struct Dht 

pub struct Dht<H: DhtHandler> {

    pub handler: RwLock<Weak<H>>,
    pub bootstrapped: Arc<RwLock<bool>>,
    pub buckets: Arc<RwLock<Vec<DhtBucket<H::Node>>>>,
    pub hash_table: DhtHashTable<H::Value>,
    pub n_buckets: usize,
    pub channel_cache: Arc<RwLock<HashMap<u32, ChannelCacheItem<H::Node>>>>,
    pub host_cache: Arc<RwLock<HashMap<Url, HostCacheItem>>>,
    ping_locks: Arc<Mutex<HashMap<u32, Arc<Mutex<Option<Result<H::Node>>>>>>>,
    pub add_node_tx: Sender<(H::Node, ChannelPtr)>,
    pub add_node_rx: Receiver<(H::Node, ChannelPtr)>,
    pub settings: DhtSettings,
    pub event_publisher: PublisherPtr<DhtEvent<H::Node, H::Value>>,
    pub p2p: P2pPtr,
    pub connector: Connector,
    pub executor: ExecutorPtr,
}

Fields

handler: RwLock<Weak<H>>

DhtHandler that implements application-specific behaviors over a Dht

bootstrapped: Arc<RwLock<bool>>

Are we bootstrapped?

buckets: Arc<RwLock<Vec<DhtBucket<H::Node>>>>

Vec of buckets

hash_table: DhtHashTable<H::Value>

Our local hash table, storing a part of the full DHT keys/values

n_buckets: usize

Number of buckets

channel_cache: Arc<RwLock<HashMap<u32, ChannelCacheItem<H::Node>>>>

Channel ID -> ChannelCacheItem

host_cache: Arc<RwLock<HashMap<Url, HostCacheItem>>>

Host address -> ChannelCacheItem

ping_locks: Arc<Mutex<HashMap<u32, Arc<Mutex<Option<Result<H::Node>>>>>>>

Locks that prevent pinging the same channel multiple times at once.

add_node_tx: Sender<(H::Node, ChannelPtr)>

Add node sender

add_node_rx: Receiver<(H::Node, ChannelPtr)>

Add node receiver

settings: DhtSettings

DHT settings

event_publisher: PublisherPtr<DhtEvent<H::Node, H::Value>>

DHT event publisher

p2p: P2pPtr

P2P network pointer

connector: Connector

Connector to create manual connections

executor: ExecutorPtr

Global multithreaded executor reference

Implementations

impl<H: DhtHandler> Dht<H>

pub async fn new(settings: &DhtSettings, p2p: P2pPtr, ex: ExecutorPtr) -> Self

pub async fn handler(&self) -> Arc<H>

pub async fn is_bootstrapped(&self) -> bool

pub async fn set_bootstrapped(&self, value: bool)

pub async fn subscribe(&self) -> Subscription<DhtEvent<H::Node, H::Value>>

pub fn distance(&self, key_1: &Hash, key_2: &Hash) -> [u8; 32]

Get the distance between key_1 and key_2

pub fn sort_by_distance(&self, nodes: &mut [H::Node], key: &Hash)

Sort nodes by distance from key

pub async fn get_bucket_index(&self, self_node_id: &Hash, key: &Hash) -> usize

key -> bucket index

pub async fn find_neighbors(&self, key: &Hash, n: usize) -> Vec<H::Node>

Get n closest known nodes to a key TODO: Can be optimized

pub async fn get_node_from_channel(&self, channel_id: u32) -> Option<H::Node>

Channel ID -> DhtNode

pub async fn reset(&self)

Reset the DHT state (nodes and hash table)

pub async fn announce<M: Message>( &self, key: &Hash, value: &H::Value, message: &M, ) -> Result<()>

Add value to our hash table and send message for a key to the closest nodes found

pub async fn bootstrap(&self)

Lookup our own node id

async fn on_new_node(&self, node: &H::Node, channel: ChannelPtr)

pub async fn update_node(&self, node: &H::Node, channel: ChannelPtr)

Move a node to the tail in its bucket, to show that it is the most recently seen in the bucket. If the node is not in a bucket it will be added using add_node.

pub async fn remove_node(&self, node_id: &Hash)

Remove a node from the buckets.

pub async fn ping(&self, channel: ChannelPtr) -> Result<H::Node>

Send a DHT ping to channel using the handler’s ping method. Prevents sending multiple pings at once to the same channel.

async fn lookup( &self, key: Hash, lookup_type: DhtLookupType, ) -> (Vec<H::Node>, Vec<H::Value>)

Lookup algorithm for both nodes lookup and value lookup.

pub async fn lookup_nodes(&self, key: &Hash) -> Vec<H::Node>

Find k nodes closest to a key

pub async fn lookup_value(&self, key: &Hash) -> (Vec<H::Node>, Vec<H::Value>)

Find value for key

pub async fn update_channel(&self, channel_id: u32)

Update a channel’s last_used field in the channel cache.

pub async fn get_channel(&self, node: &H::Node) -> Result<(ChannelPtr, H::Node)>

Get a channel (existing or create a new one) to node. Don’t forget to call cleanup_channel() once you are done with it.

pub async fn create_channel(&self, addr: &Url) -> Result<(ChannelPtr, H::Node)>

Create a channel in the direct session, ping the peer, add the DHT node to our buckets and the channel to our channel cache.

pub async fn create_channel_to_node( &self, node: &H::Node, ) -> Result<(ChannelPtr, H::Node)>

pub async fn add_channel_to_cache(&self, channel_id: u32, node: &H::Node)

Insert a channel to the DHT’s channel cache. If the channel is already in the cache, last_used is updated.

pub async fn wait_fully_pinged(&self, channel_id: u32) -> Result<()>

Wait until we received a DHT ping and sent a DHT ping on a channel.

pub async fn cleanup_channel(&self, channel: ChannelPtr)

Call crate::net::session::DirectSession::cleanup_channel() and cleanup the DHT caches.