Struct Hosts

pub struct Hosts {
    registry: Mutex<HashMap<Url, HostState>>,
    pub container: HostContainer,
    store_publisher: PublisherPtr<usize>,
    pub(super) channel_publisher: PublisherPtr<Result<ChannelPtr>>,
    pub(super) disconnect_publisher: PublisherPtr<Error>,
    pub(super) last_connection: Mutex<Instant>,
    pub(super) ipv6_available: AtomicBool,
    auto_self_addrs: Mutex<RingBuffer<Ipv6Addr, 20>>,
    settings: Arc<RwLock<Settings>>,
}

Main parent class for the management and manipulation of hostlists.

Keeps track of hosts and their current state via the HostRegistry, and stores hostlists and associated methods in the HostContainer. Also operates two publishers to notify other parts of the code base when new channels have been created or new hosts have been added to the hostlist.

Fields

registry: Mutex<HashMap<Url, HostState>>

A registry that tracks hosts and their current state.

container: HostContainer

Hostlists and associated methods.

store_publisher: PublisherPtr<usize>

Publisher listening for store updates

channel_publisher: PublisherPtr<Result<ChannelPtr>>

Publisher for notifications of new channels

disconnect_publisher: PublisherPtr<Error>

Publisher listening for network disconnects

last_connection: Mutex<Instant>

Keeps track of the last time a connection was made.

ipv6_available: AtomicBool

Marker for IPv6 availability

auto_self_addrs: Mutex<RingBuffer<Ipv6Addr, 20>>

Auto self discovered addresses. Used for filtering self connections.

settings: Arc<RwLock<Settings>>

Pointer to configured P2P settings

Implementations

impl Hosts

pub(super) fn new(settings: Arc<AsyncRwLock<Settings>>) -> HostsPtr

Create a new hosts list

pub(super) async fn insert(&self, color: HostColor, addrs: &[(Url, u64)])

Safely insert into the HostContainer. Filters the addresses first before storing and notifies the publisher. Must be called when first receiving greylist addresses.

pub fn refinable(&self, addr: Url) -> bool

Check whether a peer is available to be refined currently. Returns true if available, false otherwise.

pub(super) fn try_register( &self, addr: Url, new_state: HostState, ) -> Result<HostState>

Try to update the registry. If the host already exists, try to update its state. Otherwise add the host to the registry along with its state.

pub(super) async fn check_addrs( &self, hosts: Vec<(Url, u64)>, ) -> Option<(Url, u64)>

pub(super) fn unregister(&self, addr: &Url)

Mark as host as Free which frees it up for most future operations.

pub fn channels(&self) -> Vec<ChannelPtr>

Return the list of all connected channels, including seed and refinery connections.

pub fn get_channel(&self, id: u32) -> Option<ChannelPtr>

Grab the channel pointer of provided channel ID, if it exists.

pub fn peers(&self) -> Vec<ChannelPtr>

Return the list of connected peers. Seed and refinery connections are not taken into account.

pub(super) fn suspended(&self) -> Vec<Url>

Returns the list of suspended channels.

pub fn random_channel(&self) -> ChannelPtr

Retrieve a random connected channel

pub(super) async fn register_channel(&self, channel: ChannelPtr)

Add a channel to the set of connected channels

pub async fn subscribe_store(&self) -> Subscription<usize>

Get notified when new hosts have been inserted into a hostlist.

pub async fn subscribe_channel(&self) -> Subscription<Result<ChannelPtr>>

Get notified when a new channel has been created

pub async fn subscribe_disconnect(&self) -> Subscription<Error>

Get notified when a node has no active connections (is disconnected)

pub fn is_local_host(&self, url: &Url) -> bool

Check whether a URL is local host

pub fn is_ipv6(&self, url: &Url) -> bool

Check whether a URL is IPV6

pub(super) async fn import_blacklist(&self) -> Result<()>

Import blacklisted peers specified in the config file.

pub(super) fn block_all_ports(&self, url: &Url) -> bool

To block a peer trying to access by all ports, simply store its hostname in the blacklist. This method will check if a host is stored in the blacklist without a port, and if so, it will return true.

async fn filter_addresses(&self, addrs: &[(Url, u64)]) -> Vec<(Url, u64)>

Filter given addresses based on certain rulesets and validity. Strictly called only on the first time learning of new peers.

pub fn fetch_last_seen(&self, addr: &Url) -> Option<u64>

Method to fetch the last_seen field for a give address when we do not know what hostlist it is on.

pub fn greylist_host(&self, addr: &Url, last_seen: u64) -> Result<()>

Downgrade host to Greylist, remove from Gold or White list.

pub fn whitelist_host(&self, addr: &Url, last_seen: u64) -> Result<()>

pub(super) fn move_host( &self, addr: &Url, last_seen: u64, destination: HostColor, ) -> Result<()>

A single function for moving hosts between hostlists. Called on the following occasions:

• When we cannot connect to a peer: move to grey, remove from white and gold.
• When a peer disconnects from us: move to grey, remove from white and gold.
• When the refinery passes successfully: move to white, remove from greylist.
• When we connect to a peer, move to gold, remove from white or grey.
• When we add a peer to the black list: move to black, remove from all other lists.

Note that this method puts a given Url into the “Move” state but does not reset the state afterwards. This is because the next state will differ depending on its usage. The state transition from Move to Connected or Suspend are both valid operations. In some cases, unregister() can be called after move_host() to explicitly mark the host state as Free.

pub(super) fn add_auto_addr(&self, addr: Ipv6Addr)

Upon version exchange, the node reports our external network address to us. Accumulate them here in a ring buffer.

pub fn guess_auto_addr(&self) -> Option<Ipv6Addr>

Pick the most frequent occuring reported external address from other nodes as our auto ipv6 address.

pub async fn external_addrs(&self) -> Vec<Url>

The external_addrs is set by the user but we need the actual addresses. If the external_addr is set to [::] (unspecified), then replace it with the the best guess from guess_auto_addr(). Also if the port is 0, we lookup the port from the InboundSession.

fn patch_auto_addr(&self, ext_addr: &mut Url) -> Option<()>

Make a best effort guess from the most frequently reported ipv6 auto address to set any unspecified ipv6 addrs: external_addrs = ["tcp://[::]:1365"].

fn patch_port(&self, ext_addr: &mut Url) -> Option<()>

If the port number specified is 0, then replace it with whatever the OS has assigned as a port for that inbound.