Struct Hosts 

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

Main interface for host management.

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(crate) fn new(settings: Arc<AsyncRwLock<Settings>>) -> HostsPtr

Create a new hosts list

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

Try to register a host with a new state.

pub(crate) fn unregister(&self, addr: &Url) -> Result<()>

Mark a host as Free.

pub fn prune_registry(&self) -> usize

Prune stale entries from the registry.

Removes hosts that have been in Free state longer than REGISTRY_PRUNE_AGE_SECS. This prevents unbounded growth of the registry over long-running sessions.

Returns the number of entries pruned.

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

Check if a host can be refined.

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

Return all connected channels.

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

Return connected peers (excluding seed and refinery connections).

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

Get a channel by ID.

pub fn random_channel(&self) -> Option<ChannelPtr>

Get a random connected channel.

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

Return suspended hosts.

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

Register a channel as connected.

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

Insert addresses into the greylist after filtering.

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

Find a connectable address from the given hosts.

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

Move a host to the greylist.

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

Move a host to the whitelist.

pub(crate) async fn move_host( &self, addr: &Url, last_seen: u64, dest: HostColor, ) -> Result<()>

Move a host between lists (requires Move state).

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

Get the last_seen for an address across all active lists.

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

Check if we have an existing connection to a host (any port).

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

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

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

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

Check if a host is blacklisted without a port (blocks all ports).

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

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

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

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

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

fn patch_auto_addr(&self, addr: &mut Url)

fn patch_port(&self, _addr: &mut Url)

fn is_i2p_host(host: &str) -> bool

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

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

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