Struct PeerRing 

pub struct PeerRing {
    pub did: Did,
    pub storage: Box<dyn KvStorageInterface<Entry> + Sync + Send>,
    pub cache: Box<dyn KvStorageInterface<Entry> + Sync + Send>,
    /* private fields */
}

Chord routing and replicated-storage state for one network peer.

Fields

did: Did

The DID of the current node.

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

Persistent replicated-entry storage.

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

Local fetched-entry cache.

Implementations

impl PeerRing

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

Construct a peer ring with caller-provided entry storage.

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

Construct a peer ring with caller-provided storage and finger-table size.

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

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

Construct a peer ring with storage and virtual ownership configuration.

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

👎Deprecated:

use PeerRing::successors

Return the successor sequence.

pub fn successors(&self) -> SuccessorSeq

Return the successor sequence.

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

Remove a node from finger, predecessor, and successor state.

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

Calculate the DID’s clockwise bias from this node.

impl PeerRing

pub fn storage_virtual_nodes_enabled(&self) -> Result<bool, Error>

Return whether the storage virtual-node registry is enabled.

pub fn storage_virtual_positions( &self, owner: Did, ) -> Result<Vec<VirtualNode>, Error>

Return virtual storage positions owned by owner.

Trait Implementations

impl Chord<PeerRingAction> for PeerRing

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

Join a DHT containing a node identified by did.

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

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

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, 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 DHT, ignoring the local cache.

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,

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

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

where 'life0: 'async_trait, PeerRing: '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, 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], redundancy: u16, ) -> 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,

Hook of updating successor

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

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.

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

HMCC/Zave Rectify operation.

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

Steps before Stabilize Operation.

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

Stabilize operation in the paper.

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

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