Struct FudNode

pub struct FudNode {
    pub(crate) data: VerifiableNodeData,
    pub(crate) addresses: Vec<Url>,
}

Fields

data: VerifiableNodeData

addresses: Vec<Url>

Trait Implementations

impl AsyncDecodable for FudNode

where VerifiableNodeData: AsyncDecodable, Vec<Url>: AsyncDecodable,

fn decode_async<'life0, 'async_trait, D>( d: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where D: 'async_trait + AsyncRead + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait,

impl AsyncEncodable for FudNode

where VerifiableNodeData: AsyncEncodable, Vec<Url>: AsyncEncodable,

fn encode_async<'life0, 'life1, 'async_trait, S>( &'life0 self, s: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where S: 'async_trait + AsyncWrite + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously encode an object with a well-defined format. Should only ever error if the underlying AsyncWrite errors. Returns the number of bytes written on success.

impl Clone for FudNode

fn clone(&self) -> FudNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FudNode

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

Formats the value using the given formatter.

impl Decodable for FudNode

where VerifiableNodeData: Decodable, Vec<Url>: Decodable,

fn decode<D: Read>(d: &mut D) -> Result<Self, Error>

impl DhtHandler<FudNode> for Fud

fn dht(&self) -> Arc<Dht<FudNode>>

fn node<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = FudNode> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get our own node

fn ping<'life0, 'async_trait>( &'life0 self, channel: ChannelPtr, ) -> Pin<Box<dyn Future<Output = Result<FudNode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Send a DHT ping request

fn on_new_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 FudNode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Triggered when we find a new node

fn fetch_nodes<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, node: &'life1 FudNode, key: &'life2 Hash, ) -> Pin<Box<dyn Future<Output = Result<Vec<FudNode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send FIND NODES request to a peer to get nodes close to key

fn announce<'life0, 'life1, 'life2, 'async_trait, M>( &'life0 self, key: &'life1 Hash, message: &'life2 M, router: Arc<RwLock<HashMap<Hash, HashSet<DhtRouterItem<N>>>>>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, N: 'async_trait, M: 'async_trait + Message, Self: 'async_trait,

Announce message for a key, and add ourselves to router

fn bootstrap<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Lookup our own node id to bootstrap our DHT

fn add_node<'life0, 'async_trait>( &'life0 self, node: N, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, N: 'async_trait, Self: 'async_trait,

Add a node in the correct bucket

fn update_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 N, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

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

fn fetch_nodes_sp<'life0, 'life1, 'async_trait>( &'life0 self, semaphore: Arc<Semaphore>, node: N, key: &'life1 Hash, ) -> Pin<Box<dyn Future<Output = (N, Result<Vec<N>, Error>)> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, N: 'async_trait, Self: 'async_trait,

Wait to acquire a semaphore, then run self.fetch_nodes. This is meant to be used in lookup_nodes.

fn lookup_nodes<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 Hash, ) -> Pin<Box<dyn Future<Output = Result<Vec<N>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Find k nodes closest to a key

fn get_channel<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 N, topic: Option<Hash>, ) -> Pin<Box<dyn Future<Output = Result<Arc<Channel>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

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

fn cleanup_channel<'life0, 'async_trait>( &'life0 self, channel: Arc<Channel>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Decrement the channel usage count, if it becomes 0 then set the topic to None, so that this channel is available for another task

fn add_to_router<'life0, 'life1, 'async_trait>( &'life0 self, router: Arc<RwLock<HashMap<Hash, HashSet<DhtRouterItem<N>>>>>, key: &'life1 Hash, router_items: Vec<DhtRouterItem<N>>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, N: 'async_trait, Self: 'async_trait,

Add nodes as a provider for a key

impl DhtNode for FudNode

fn id(&self) -> Hash

fn addresses(&self) -> Vec<Url>

impl Encodable for FudNode

where VerifiableNodeData: Encodable, Vec<Url>: Encodable,

fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error>

Encode an object with a well-defined format. Should only ever error if the underlying Write errors. Returns the number of bytes written on success.

impl Hash for FudNode

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FudNode

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for FudNode