Struct PeerRing 

pub struct PeerRing {
    pub did: Did,
    pub finger: Arc<Mutex<FingerTable>>,
    pub successor_seq: SuccessorSeq,
    pub predecessor: Arc<Mutex<Option<Did>>>,
    pub storage: Box<dyn KvStorageInterface<Entry> + Send + Sync>,
    pub cache: Box<dyn KvStorageInterface<Entry> + Send + Sync>,
}

PeerRing is used to help a node interact with other nodes. All nodes in rings network form a clockwise ring in the order of Did. This struct takes its name from that. PeerRing implemented Chord algorithm. PeerRing implemented ChordStorage protocol.

Fields

did: Did

The did of current node.

finger: Arc<Mutex<FingerTable>>

FingerTable help node to find successor quickly.

successor_seq: SuccessorSeq

The next node on the ring. The SuccessorSeq may contain multiple node dids for fault tolerance. The min did should be same as the first element in finger table.

predecessor: Arc<Mutex<Option<Did>>>

The did of previous node on the ring.

storage: Box<dyn KvStorageInterface<Entry> + Send + Sync>

Local storage for ChordStorage.

cache: Box<dyn KvStorageInterface<Entry> + Send + Sync>

Local cache for ChordStorage.

Implementations

impl PeerRing

pub fn new_with_storage( did: Did, succ_max: u8, storage: Box<dyn KvStorageInterface<Entry> + Send + Sync>, ) -> PeerRing

Same as new with config, but with a given storage.

pub fn new_with_storage_and_finger_table_size( did: Did, succ_max: u8, storage: Box<dyn KvStorageInterface<Entry> + Send + Sync>, finger_table_size: usize, ) -> PeerRing

Same as new with config, but with a given storage and finger table size.

Did is 160-bit. Sizes above DEFAULT_FINGER_TABLE_SIZE are clamped by FingerTable::new; zero is allowed to disable finger maintenance.

pub fn lock_successor(&self) -> Result<SuccessorSeq, Error>

👎Deprecated

Return successor sequence. This function is deprecated, please use [chord.successors] instead.

pub fn successors(&self) -> SuccessorSeq

Return successor sequence

pub fn lock_finger(&self) -> Result<MutexGuard<'_, FingerTable>, Error>

Lock and return MutexGuard of finger table.

pub fn lock_predecessor(&self) -> Result<MutexGuard<'_, Option<Did>>, Error>

Lock and return MutexGuard of predecessor.

pub fn remove(&self, did: Did) -> Result<(), Error>

Remove a node from finger table. Also remove it from successor sequence. If successor_seq become empty, try setting the closest node to it.

pub fn bias(&self, did: Did) -> BiasId

Calculate bias of the Did on the ring.

Trait Implementations

impl Chord<PeerRingAction> for PeerRing

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

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, Error>

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, Error>

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, Error>

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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, PeerRing: 'async_trait,

Look up an Entry by its ring key. Always finds resource by finger table, ignoring the local cache. If the entry_key is between current node and its successor, its resource should be stored in current node.

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

where 'life0: 'async_trait, PeerRing: 'async_trait,

Handle EntryOperation if the target entry 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<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, PeerRing: 'async_trait,

Cache fetched entry locally.

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

where 'life0: 'async_trait, PeerRing: 'async_trait,

Get entry from 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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, PeerRing: '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], ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, PeerRing: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, PeerRing: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, PeerRing: 'async_trait,

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

impl CorrectChord<PeerRingAction> for PeerRing

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

where 'life0: 'async_trait, PeerRing: '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 LiveDid + 'async_trait, ) -> Pin<Box<dyn Future<Output = Result<PeerRingAction, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, PeerRing: '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<(), Error>

HMCC/Zave Rectify operation.

Rectify is the local predecessor transition run when this node receives a predecessor notification from pred. It has no remote action: the message layer’s report path is handled by NotifyPredecessorSend.

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

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, Error>

Stabilize Operation:

Mirrors the TLA+-style CorrectStabilize operator in tests/default/dht_convergence.rs. The old head is captured before updating successors for the improved-successor query check; the remote successor list contributes but_last; and notify is emitted for the post-update head when that head is not self.

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

A function to provide topological information about the chord.

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

where 'life0: 'async_trait, 'life1: 'async_trait, PeerRing: 'async_trait,

Hook of updating successor