Struct grin_p2p::Peers

pub struct Peers {
    pub adapter: Arc<dyn ChainAdapter>,
    // some fields omitted
}

Fields

adapter: Arc<dyn ChainAdapter>

Methods

impl Peers

pub fn new(
    store: PeerStore,
    adapter: Arc<dyn ChainAdapter>,
    config: P2PConfig
) -> Peers

pub fn add_connected(&self, peer: Arc<Peer>) -> Result<(), Error>

Adds the peer to our internal peer mapping. Note that the peer is still returned so the server can run it.

pub fn add_banned(
    &self,
    addr: PeerAddr,
    ban_reason: ReasonForBan
) -> Result<(), Error>

Add a peer as banned to block future connections, usually due to failed handshake

pub fn is_known(&self, addr: PeerAddr) -> bool

pub fn connected_peers(&self) -> Vec<Arc<Peer>>

Get vec of peers we are currently connected to.

pub fn outgoing_connected_peers(&self) -> Vec<Arc<Peer>>

pub fn get_connected_peer(&self, addr: PeerAddr) -> Option<Arc<Peer>>

Get a peer we're connected to by address.

pub fn peer_count(&self) -> u32

Number of peers currently connected to.

pub fn peer_outbound_count(&self) -> u32

Number of outbound peers currently connected to.

pub fn more_work_peers(&self) -> Result<Vec<Arc<Peer>>, Error>

pub fn more_or_same_work_peers(&self) -> Result<usize, Error>

pub fn more_work_peer(&self) -> Option<Arc<Peer>>

Returns single random peer with more work than us.

pub fn most_work_peers(&self) -> Vec<Arc<Peer>>

Return vec of connected peers that currently have the most worked branch, showing the highest total difficulty.

pub fn most_work_peer(&self) -> Option<Arc<Peer>>

Returns single random peer with the most worked branch, showing the highest total difficulty.

pub fn is_banned(&self, peer_addr: PeerAddr) -> bool

pub fn ban_peer(&self, peer_addr: PeerAddr, ban_reason: ReasonForBan)

Ban a peer, disconnecting it if we're currently connected

pub fn unban_peer(&self, peer_addr: PeerAddr)

Unban a peer, checks if it exists and banned then unban

pub fn broadcast_compact_block(&self, b: &CompactBlock)

Broadcasts the provided compact block to PEER_MAX_COUNT of our peers. This is only used when initially broadcasting a newly mined block from a mining node so we want to broadcast it far and wide. A peer implementation may drop the broadcast request if it knows the remote peer already has the block.

pub fn broadcast_header(&self, bh: &BlockHeader)

Broadcasts the provided header to PEER_PREFERRED_COUNT of our peers. We may be connected to PEER_MAX_COUNT peers so we only want to broadcast to a random subset of peers. A peer implementation may drop the broadcast request if it knows the remote peer already has the header.

pub fn broadcast_transaction(&self, tx: &Transaction)

Broadcasts the provided transaction to PEER_PREFERRED_COUNT of our peers. We may be connected to PEER_MAX_COUNT peers so we only want to broadcast to a random subset of peers. A peer implementation may drop the broadcast request if it knows the remote peer already has the transaction.

pub fn check_all(&self, total_difficulty: Difficulty, height: u64)

Ping all our connected peers. Always automatically expects a pong back or disconnects. This acts as a liveness test.

pub fn all_peers(&self) -> Vec<PeerData>

All peer information we have in storage

pub fn find_peers(
    &self,
    state: State,
    cap: Capabilities,
    count: usize
) -> Vec<PeerData>

Find peers in store (not necessarily connected) and return their data

pub fn get_peer(&self, peer_addr: PeerAddr) -> Result<PeerData, Error>

Get peer in store by address

pub fn exists_peer(&self, peer_addr: PeerAddr) -> Result<bool, Error>

Whether we've already seen a peer with the provided address

pub fn save_peer(&self, p: &PeerData) -> Result<(), Error>

Saves updated information about a peer

pub fn update_state(
    &self,
    peer_addr: PeerAddr,
    new_state: State
) -> Result<(), Error>

Updates the state of a peer in store

pub fn clean_peers(&self, max_count: usize)

Iterate over the peer list and prune all peers we have lost connection to or have been deemed problematic. Also avoid connected peer count getting too high.

pub fn stop(&self)

pub fn enough_peers(&self) -> bool

pub fn healthy_peers_mix(&self) -> bool

We have enough peers, both total connected and outbound connected

pub fn remove_expired(&self)

Removes those peers that seem to have expired

Trait Implementations

impl ChainAdapter for Peers

fn total_difficulty(&self) -> Result<Difficulty, Error>

Current total difficulty on our chain

fn total_height(&self) -> Result<u64, Error>

Current total height

fn get_transaction(&self, kernel_hash: Hash) -> Option<Transaction>

fn tx_kernel_received(
    &self,
    kernel_hash: Hash,
    peer_info: &PeerInfo
) -> Result<bool, Error>

fn transaction_received(
    &self,
    tx: Transaction,
    stem: bool
) -> Result<bool, Error>

A valid transaction has been received from one of our peers

fn block_received(
    &self,
    b: Block,
    peer_info: &PeerInfo,
    was_requested: bool
) -> Result<bool, Error>

A block has been received from one of our peers. Returns true if the block could be handled properly and is not deemed defective by the chain. Returning false means the block will never be valid and may result in the peer being banned.

fn compact_block_received(
    &self,
    cb: CompactBlock,
    peer_info: &PeerInfo
) -> Result<bool, Error>

fn header_received(
    &self,
    bh: BlockHeader,
    peer_info: &PeerInfo
) -> Result<bool, Error>

fn headers_received(
    &self,
    headers: &[BlockHeader],
    peer_info: &PeerInfo
) -> Result<bool, Error>

A set of block header has been received, typically in response to a block header request.

fn locate_headers(&self, hs: &[Hash]) -> Result<Vec<BlockHeader>, Error>

Finds a list of block headers based on the provided locator. Tries to identify the common chain and gets the headers that follow it immediately.

fn get_block(&self, h: Hash) -> Option<Block>

Gets a full block by its hash.

fn kernel_data_read(&self) -> Result<File, Error>

fn kernel_data_write(&self, reader: &mut dyn Read) -> Result<bool, Error>

fn txhashset_read(&self, h: Hash) -> Option<TxHashSetRead>

Provides a reading view into the current txhashset state as well as the required indexes for a consumer to rewind to a consistant state at the provided block hash.

fn txhashset_receive_ready(&self) -> bool

Whether the node is ready to accept a new txhashset. If this isn't the case, the archive is provided without being requested and likely an attack attempt. This should be checked before downloading the whole state data.

fn txhashset_write(
    &self,
    h: Hash,
    txhashset_data: File,
    peer_info: &PeerInfo
) -> Result<bool, Error>

Writes a reading view on a txhashset state that's been provided to us. If we're willing to accept that new state, the data stream will be read as a zip file, unzipped and the resulting state files should be rewound to the provided indexes.

fn txhashset_download_update(
    &self,
    start_time: DateTime<Utc>,
    downloaded_size: u64,
    total_size: u64
) -> bool

Update txhashset downloading progress

fn get_tmp_dir(&self) -> PathBuf

Get the Grin specific tmp dir

fn get_tmpfile_pathname(&self, tmpfile_name: String) -> PathBuf

Get a tmp file path in above specific tmp dir (create tmp dir if not exist) Delete file if tmp file already exists

impl NetAdapter for Peers

fn find_peer_addrs(&self, capab: Capabilities) -> Vec<PeerAddr>

Find good peers we know with the provided capability and return their addresses.

fn peer_addrs_received(&self, peer_addrs: Vec<PeerAddr>)

A list of peers has been received from one of our peers.

fn peer_difficulty(&self, addr: PeerAddr, diff: Difficulty, height: u64)

Heard total_difficulty from a connected peer (via ping/pong).

fn is_banned(&self, addr: PeerAddr) -> bool

Is this peer currently banned?