Struct P2PConfig

pub struct P2PConfig {

    pub laddr: Address,
    pub external_address: Option<Address>,
    pub seeds: Vec<Address>,
    pub persistent_peers: Vec<Address>,
    pub upnp: bool,
    pub addr_book_file: PathBuf,
    pub addr_book_strict: bool,
    pub max_num_inbound_peers: u64,
    pub max_num_outbound_peers: u64,
    pub unconditional_peer_ids: Vec<Id>,
    pub persistent_peers_max_dial_period: Timeout,
    pub flush_throttle_timeout: Timeout,
    pub max_packet_msg_payload_size: u64,
    pub send_rate: TransferRate,
    pub recv_rate: TransferRate,
    pub pex: bool,
    pub seed_mode: bool,
    pub private_peer_ids: Vec<Id>,
    pub allow_duplicate_ip: bool,
    pub handshake_timeout: Timeout,
    pub dial_timeout: Timeout,
}

peer to peer configuration options

Fields

laddr: Address

Address to listen for incoming connections

external_address: Option<Address>

Address to advertise to peers for them to dial If empty, will use the same port as the laddr, and will introspect on the listener or use UPnP to figure out the address.

seeds: Vec<Address>

Comma separated list of seed nodes to connect to

persistent_peers: Vec<Address>

Comma separated list of nodes to keep persistent connections to

upnp: bool

UPNP port forwarding

addr_book_file: PathBuf

Path to address book

addr_book_strict: bool

Set true for strict address routability rules Set false for private or local networks

max_num_inbound_peers: u64

Maximum number of inbound peers

max_num_outbound_peers: u64

Maximum number of outbound peers to connect to, excluding persistent peers

unconditional_peer_ids: Vec<Id>

List of node IDs, to which a connection will be (re)established ignoring any existing limits

persistent_peers_max_dial_period: Timeout

Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)

flush_throttle_timeout: Timeout

Time to wait before flushing messages out on the connection

max_packet_msg_payload_size: u64

Maximum size of a message packet payload, in bytes

send_rate: TransferRate

Rate at which packets can be sent, in bytes/second

recv_rate: TransferRate

Rate at which packets can be received, in bytes/second

pex: bool

Set true to enable the peer-exchange reactor

seed_mode: bool

Seed mode, in which node constantly crawls the network and looks for peers. If another node asks it for addresses, it responds and disconnects.

Does not work if the peer-exchange reactor is disabled.

private_peer_ids: Vec<Id>

Comma separated list of peer IDs to keep private (will not be gossiped to other peers)

allow_duplicate_ip: bool

Toggle to disable guard against peers connecting from the same ip.

handshake_timeout: Timeout

Handshake timeout

dial_timeout: Timeout

Timeout when dialing other peers

Trait Implementations

impl Clone for P2PConfig

fn clone(&self) -> P2PConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for P2PConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for P2PConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for P2PConfig

fn eq(&self, other: &P2PConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for P2PConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for P2PConfig

impl StructuralPartialEq for P2PConfig