Struct RefreshService

pub struct RefreshService {
    table: Arc<RoutingTable>,
    listen_endpoint: RwLock<Option<Endpoint>>,
    task_group: TaskGroup,
    config: Arc<Config>,
    monitor: Arc<Monitor>,
}

Fields

table: Arc<RoutingTable>

Routing table

listen_endpoint: RwLock<Option<Endpoint>>

Resolved listen endpoint

task_group: TaskGroup

Managing spawned tasks.

config: Arc<Config>

Holds the configuration for the P2P network.

monitor: Arc<Monitor>

Responsible for network and system monitoring.

Implementations

impl RefreshService

pub fn new( config: Arc<Config>, table: Arc<RoutingTable>, monitor: Arc<Monitor>, executor: Executor, ) -> Self

Creates a new refresh service

pub async fn start(self: &Arc<Self>) -> Result<()>

Start the refresh service

pub fn set_listen_endpoint(&self, resolved_endpoint: &Endpoint) -> Result<()>

Set the resolved listen endpoint.

pub async fn shutdown(&self)

Shuts down the refresh service

async fn refresh_loop(self: Arc<Self>) -> Result<()>

Initiates periodic refreshing of the routing table. This function will selects the first 8 entries (oldest entries) from each bucket in the routing table and starts sending Ping messages to the collected entries.

async fn do_refresh(self: Arc<Self>, entries: &[BucketEntry])

Iterates over the entries and initiates a connection.

async fn refresh_entry(self: Arc<Self>, bucket_entry: BucketEntry)

Initiates refresh for a specific entry within the routing table. It updates the routing table according to the result.

async fn connect(&self, entry: &Entry) -> Result<()>

Initiates a UDP connection with the entry and attempts to send a Ping message. If it fails, it retries according to the allowed retries specified in the Config, with backoff between each retry.

async fn listen_loop(self: Arc<Self>, endpoint: Endpoint) -> Result<()>

Set up a UDP listener and start listening for Ping messages from other peers.

async fn listen_to_ping_msg( &self, conn: &UdpConn<RefreshMsgCodec>, ) -> Result<()>

Listen to receive a Ping message and respond with a Pong message.

async fn send_ping_msg( &self, conn: &UdpConn<RefreshMsgCodec>, endpoint: &Endpoint, ) -> Result<()>

Sends a Ping msg and wait to receive the Pong message.