Enum rings_core::dht::PeerRingAction

pub enum PeerRingAction {
    None,
    SomeVNode(VirtualNode),
    Some(Did),
    RemoteAction(Did, RemoteAction),
    MultiActions(Vec<PeerRingAction>),
}

Result of PeerRing algorithm

Variants

None

Do noting

SomeVNode(VirtualNode)

Found some VNode

Some(Did)

Found some node

RemoteAction(Did, RemoteAction)

Trigger remote action

MultiActions(Vec<PeerRingAction>)

Trigger Multiple Actions at sametime

Implementations

impl PeerRingAction

pub fn is_none(&self) -> bool

action is Self::None

pub fn is_some(&self) -> bool

Action is Self::Some

pub fn is_remote(&self) -> bool

Action is Self::RemoteAction

pub fn is_multi(&self) -> bool

Action is Self::MultiActions

Trait Implementations

impl Chord<PeerRingAction> for PeerRing

fn join(&self, id: Did) -> Result<PeerRingAction>

join a PeerRing ring containing node id .

fn find_successor(&self, id: Did) -> Result<PeerRingAction>

Fig.5 n.find_successor(id)

impl ChordStabilize<PeerRingAction> for PeerRing

fn notify(&self, id: Did) -> Result<Option<Did>>

n’ thinks it might be our predecessor.

fn fix_fingers(&self) -> Result<PeerRingAction>

called periodically. refreshes finger table entries. next stores the index of the next finger to fix.

fn check_predecessor(&self) -> Result<PeerRingAction>

called periodically. checks whether predecessor has failed.

fn closest_preceding_node(&self, id: Did) -> Result<Did>

Fig.5. n.cloest_preceding_node(id) for i = m downto1 if (finger[i] <- (n, id)) return finger[i] return n

impl ChordStorage<PeerRingAction> for PeerRing

fn lookup<'life0, 'life1, 'async_trait>(
    &'life0 self,
    vid: &'life1 Did
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

lookup always check data via finger table

fn cache(&self, vnode: VirtualNode)

When a vnode data is fetched from remote, it should be cache at local

fn fetch_cache(&self, id: &Did) -> Option<VirtualNode>

When a VNode data is fetched from remote, it should be cache at local

fn store<'life0, 'async_trait>(
    &'life0 self,
    peer: VirtualNode
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

If address of VNode is in range(self, successor), it should store locally, otherwise, it should on remote successor

fn store_vec<'life0, 'async_trait>(
    &'life0 self,
    vps: Vec<VirtualNode>
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

store a vec of data

fn sync_with_successor<'life0, 'async_trait>(
    &'life0 self,
    new_successor: Did
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

This function should call when successor is updated

impl Clone for PeerRingAction

fn clone(&self) -> PeerRingAction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PeerRingAction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PeerRingAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<PeerRingAction> for PeerRingAction

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for PeerRingAction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl SubRingManager<PeerRingAction> for PeerRing

fn join_subring<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 Did,
    rid: &'life2 Did
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

get a subring for update join a node to subring via given name When Node A join Channel C which’s vnode is stored on Node B A send JoinSubRing to Address C, Node B got the Message And Update the Chord Finger Table, then, Node B Response it’s finger table to A And Noti closest preceding node that A is Joined

fn cloest_preceding_node_for_subring<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 Did,
    rid: &'life2 Did
) -> Pin<Box<dyn Future<Output = Option<Result<Did>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

search a cloest preceding node

fn get_subring<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 Did
) -> Pin<Box<dyn Future<Output = Result<SubRing>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

get subring from storage by id

fn store_subring<'life0, 'life1, 'async_trait>(
    &'life0 self,
    subring: &'life1 SubRing
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

store a subring to storage

fn get_subring_by_name<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<SubRing>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

get subring from storage by name

impl StructuralPartialEq for PeerRingAction