Struct rings_core::dht::PeerRing

pub struct PeerRing {
    pub id: Did,
    pub finger: Arc<Mutex<FingerTable>>,
    pub successor: Arc<Mutex<Successor>>,
    pub predecessor: Arc<Mutex<Option<Did>>>,
    pub storage: Arc<PersistenceStorage>,
    pub cache: Arc<MemStorage<Did, VirtualNode>>,
}

Implementation of PeerRing

Fields

id: Did

PeerRing’s id is address of Node

finger: Arc<Mutex<FingerTable>>

first node on circle that succeeds (n + 2 ^(k-1) ) mod 2^m , 1 <= k<= m for index start with 0, it should be (n+2^k) mod 2^m

successor: Arc<Mutex<Successor>>

The next node on the identifier circle; finger[1].node

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

The previous node on the identifier circle

storage: Arc<PersistenceStorage>

LocalStorage for DHT Query

cache: Arc<MemStorage<Did, VirtualNode>>

LocalCache

Implementations

impl PeerRing

pub async fn new(id: Did) -> Result<Self>

Create a new Chord ring.

pub async fn new_with_config(id: Did, succ_max: u8) -> Result<Self>

Create a new Chord Ring with given successor_max, and finger_size

pub fn new_with_storage(id: Did, storage: Arc<PersistenceStorage>) -> Self

Init with given Storage

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

Lock and return MutexGuard of Successor

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

Lock and return MutexGuard of Finger Table

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

Lock and return MutexGuard of Predecessor

pub fn first(&self) -> Result<Option<Did>>

Get first element from Finger Table

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

remove a node from dht finger table remove a node from dht successor table if suuccessor is empty, set it to the cloest node

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

Calculate Bias of the Did on the Ring

pub fn number_of_fingers(&self) -> Result<usize>

finger length

Trait Implementations

impl Chord<PeerRingAction> for PeerRing

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

join a PeerRing ring containing node id .

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

Fig.5 n.find_successor(id)

impl ChordStabilize<PeerRingAction> for PeerRing

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

n’ thinks it might be our predecessor.

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

called periodically. refreshes finger table entries. next stores the index of the next finger to fix.

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

called periodically. checks whether predecessor has failed.

fn closest_preceding_node(&self, id: Did) -> Result<Did>

Fig.5. n.cloest_preceding_node(id) for i = m downto1 if (finger[i] <- (n, id)) return finger[i] return n

impl ChordStorage<PeerRingAction> for PeerRing

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

lookup always check data via finger table

fn cache(&self, vnode: VirtualNode)

When a vnode data is fetched from remote, it should be cache at local

fn fetch_cache(&self, id: &Did) -> Option<VirtualNode>

When a VNode data is fetched from remote, it should be cache at local

fn store<'life0, 'async_trait>(
    &'life0 self,
    peer: VirtualNode
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

If address of VNode is in range(self, successor), it should store locally, otherwise, it should on remote successor

fn store_vec<'life0, 'async_trait>(
    &'life0 self,
    vps: Vec<VirtualNode>
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

store a vec of data

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

This function should call when successor is updated

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.

impl SubRingManager<PeerRingAction> for PeerRing

fn join_subring<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 Did,
    rid: &'life2 Did
) -> Pin<Box<dyn Future<Output = Result<PeerRingAction>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

get a subring for update join a node to subring via given name When Node A join Channel C which’s vnode is stored on Node B A send JoinSubRing to Address C, Node B got the Message And Update the Chord Finger Table, then, Node B Response it’s finger table to A And Noti closest preceding node that A is Joined

fn cloest_preceding_node_for_subring<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    id: &'life1 Did,
    rid: &'life2 Did
) -> Pin<Box<dyn Future<Output = Option<Result<Did>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

search a cloest preceding node

fn get_subring<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 Did
) -> Pin<Box<dyn Future<Output = Result<SubRing>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

get subring from storage by id

fn store_subring<'life0, 'life1, 'async_trait>(
    &'life0 self,
    subring: &'life1 SubRing
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

store a subring to storage

fn get_subring_by_name<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<SubRing>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

get subring from storage by name