Enum rings_core::dht::PeerRingAction

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

PeerRing use this to describe the result of Chord algorithm. Sometimes it’s a direct result, sometimes it’s an action that is continued externally.

Variants

None

No result, the whole manipulation is done internally.

SomeVNode(VirtualNode)

Found some VirtualNode.

Some(Did)

Found some node.

RemoteAction(Did, RemoteAction)

Trigger a remote action.

MultiActions(Vec<PeerRingAction>)

Trigger multiple remote actions.

Implementations

impl PeerRingAction

pub fn is_none(&self) -> bool

Returns true if the action is a PeerRingAction::None value.

pub fn is_some(&self) -> bool

Returns true if the action is a PeerRingAction::Some value.

pub fn is_some_vnode(&self) -> bool

Returns true if the action is a PeerRingAction::SomeVNode value.

pub fn is_remote(&self) -> bool

Returns true if the action is a PeerRingAction::RemoteAction value.

pub fn is_multi(&self) -> bool

Returns true if the action is a PeerRingAction::MultiActions value.

Trait Implementations

impl Chord<PeerRingAction> for PeerRing

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

Join a ring containing a node identified by did. This method is usually invoked to maintain successor sequence and finger table after connect to another node.

This method will return a RemoteAction::FindSuccessorForConnect to the caller. The caller will send it to the node identified by did, and let the node find the successor of current node and make current node connect to that successor.

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

Find the successor of a Did. May return a remote action for the successor is recorded in another node.

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

Handle notification from a node that thinks a did is the predecessor of current node. The did in parameters is the Did of that predecessor. If that node is closer to current node or current node has no predecessor, set it to the did. This method will return current predecessor after setting.

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

Fix finger table by finding the successor for each finger. According to the paper, this method should be called periodically. According to the paper, only one finger should be fixed at a time.

impl<const REDUNDANT: u16> ChordStorage<PeerRingAction, REDUNDANT> for PeerRing

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

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

Look up a VirtualNode by its Did. Always finds resource by finger table, ignoring the local cache. If the vid is between current node and its successor, its resource should be stored in current node.

fn vnode_operate<'life0, 'async_trait>( &'life0 self, op: VNodeOperation ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Handle VNodeOperation if the target vnode between current node and the successor of current node, otherwise find the responsible node and return as Action.

impl ChordStorageCache<PeerRingAction> for PeerRing

fn local_cache_put<'life0, 'async_trait>( &'life0 self, vnode: VirtualNode ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Cache fetched vnode locally.

fn local_cache_get<'life0, 'async_trait>( &'life0 self, vid: Did ) -> Pin<Box<dyn Future<Output = Result<Option<VirtualNode>>> + Send + 'async_trait>>

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

Get vnode from local cache.

impl ChordStorageSync<PeerRingAction> for PeerRing

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

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

When the successor of a node is updated, it needs to check if there are VirtualNodes that are no longer between current node and new_successor, and sync them to the new successor.

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 CorrectChord<PeerRingAction> for PeerRing

fn update_successor<'life0, 'async_trait>( &'life0 self, did: impl 'async_trait + LiveDid ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

When Chord have a new successor, ask the new successor for successor list

fn join_then_sync<'life0, 'async_trait>( &'life0 self, did: impl 'async_trait + LiveDid ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Join Operation in the paper. Zave’s work differs from the original Chord paper in that it requires a newly joined node to synchronize its successors from remote nodes.

fn rectify(&self, pred: Did) -> Result<()>

TODO: Please check this function and make sure it is correct. TODO: Please comment this with clear description. Rectify Operation in the paper.

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

Pre-Stabilize Operation: Before stabilizing, the node should query its first successor for TopoInfo. If there are no successors, return PeerRingAction::None.

fn stabilize(&self, info: TopoInfo) -> Result<PeerRingAction>

Stabilize Operation: Perform stabilization for the successor list.

fn topo_info(&self) -> Result<TopoInfo>

A function to provide topological information about the chord.

fn extend_successor<'life0, 'life1, 'async_trait>( &'life0 self, dids: &'life1 [impl 'async_trait + LiveDid] ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Hook of updating successor

impl Debug for PeerRingAction

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

Formats the value using the given formatter.

impl From<Vec<PeerRingAction>> for PeerRingAction

fn from(acts: Vec<PeerRingAction>) -> Self

Converts to this type from the input type.

impl PartialEq 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: &Rhs) -> bool

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

impl StructuralPartialEq for PeerRingAction