Enum PeerRingAction 

pub enum PeerRingAction {
    None,
    SomeEntry(EntryLookupEvidence),
    EntryMisses(Vec<PlacementMiss>),
    Some(Did),
    RemoteAction(Did, RemoteAction),
    MultiActions(Vec<PeerRingAction>),
}

Describes either a completed peer-ring operation or work to continue remotely.

Variants

None

No result, the whole manipulation is done internally.

SomeEntry(EntryLookupEvidence)

Found an entry together with lookup evidence.

EntryMisses(Vec<PlacementMiss>)

Observed placement misses without a hit.

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 PeerRingAction::None.

pub fn is_some(&self) -> bool

Returns true if the action is PeerRingAction::Some.

pub fn is_some_entry(&self) -> bool

Returns true if the action is PeerRingAction::SomeEntry.

pub fn is_remote(&self) -> bool

Returns true if the action is PeerRingAction::RemoteAction.

pub fn is_multi(&self) -> bool

Returns true if the action is PeerRingAction::MultiActions.

Trait Implementations

impl Chord<PeerRingAction> for PeerRing

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

Join a DHT containing a node identified by did.

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

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

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

Notify the DHT that a node is its predecessor. According to the paper, this method should be called periodically. This method should return the predecessor after updating.

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 entry_lookup<'life0, 'async_trait>( &'life0 self, entry_key: Did, ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Look up an Entry by its ring key. Always finds resource by DHT, ignoring the local cache.

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

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

Store entry if it’s 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, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Cache fetched resource locally.

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

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

Get local cache.

impl ChordStorageRepair<PeerRingAction> for PeerRing

fn republish_local_entries<'life0, 'async_trait>( &'life0 self, redundancy: u16, ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Republish every locally stored entry to its current affine owners.

fn read_repair_entry<'life0, 'life1, 'async_trait>( &'life0 self, entry: Entry, misses: &'life1 [PlacementMiss], redundancy: u16, ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Copy a found entry only to placement keys observed missing during lookup.

impl ChordStorageSync<PeerRingAction> for PeerRing

fn sync_entries_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 Entrys that are no longer between current node and new_successor, and copy them to the new successor.

fn acknowledge_synced_entries<'life0, 'life1, 'async_trait>( &'life0 self, acks: &'life1 [SyncedEntryAck], ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>>

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

Delete local entries whose placement keys and exact values were durably stored by the successor during sync.

impl Clone for PeerRingAction

fn clone(&self) -> PeerRingAction

Returns a duplicate 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,

Hook of updating successor

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

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.

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

HMCC/Zave Rectify operation.

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

Steps before Stabilize Operation.

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

Stabilize operation in the paper.

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

A helper function to get the topological info about the chord.

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(actions: Vec<PeerRingAction>) -> Self

Converts to this type from the input type.

impl PartialEq for PeerRingAction

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PeerRingAction