Struct rings_node::prelude::PeerRing

pub struct PeerRing {
    pub did: Did,
    pub finger: Arc<Mutex<FingerTable>>,
    pub successor_seq: Arc<Mutex<SuccessorSeq>>,
    pub predecessor: Arc<Mutex<Option<Did>>>,
    pub storage: Arc<KvStorage>,
    pub cache: Arc<MemStorage<Did, VirtualNode>>,
}

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: Arc<Mutex<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: Arc<KvStorage>

Local storage for ChordStorage.

cache: Arc<MemStorage<Did, VirtualNode>>

Local cache for ChordStorage.

Implementations

impl PeerRing

pub async fn new(did: Did) -> impl Future<Output = Result<PeerRing, Error>>

Create a new Chord ring.

pub async fn new_with_config(
    did: Did,
    succ_max: u8
) -> impl Future<Output = Result<PeerRing, Error>>

Create a new Chord Ring with given successor_seq max num, and finger_size.

pub fn new_with_storage(did: Did, succ_max: u8, storage: KvStorage) -> PeerRing

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

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

Lock and return MutexGuard of 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<Option<Did>, Error>

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

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.

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

called periodically. checks whether predecessor has failed.

impl ChordStorage<PeerRingAction> for PeerRing

fn vnode_lookup<'life0, 'async_trait>(
    &'life0 self,
    vid: Did
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    PeerRing: '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, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    PeerRing: '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.

fn sync_vnode_with_successor<'life0, 'async_trait>(
    &'life0 self,
    new_successor: Did
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    PeerRing: '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.

fn local_cache_set(&self, vnode: VirtualNode)

Cache fetched vnode locally.

fn local_cache_get(&self, vid: Did) -> Option<VirtualNode>

Get vnode from local cache.

impl Clone for PeerRing

fn clone(&self) -> PeerRing

Returns a copy of the value.

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

Performs copy-assignment from source.