Struct commonware_p2p::Config

pub struct Config<C: Crypto> {

    pub crypto: C,
    pub registry: Arc<Mutex<Registry>>,
    pub address: SocketAddr,
    pub bootstrappers: Vec<Bootstrapper>,
    pub allow_private_ips: bool,
    pub mailbox_size: usize,
    pub max_frame_length: usize,
    pub handshake_timeout: Duration,
    pub read_timeout: Duration,
    pub write_timeout: Duration,
    pub allowed_connection_rate_per_peer: Quota,
    pub allowed_incoming_connection_rate: Quota,
    pub dial_frequency: Duration,
    pub dial_rate: Quota,
    pub tracked_peer_sets: usize,
    pub gossip_bit_vec_frequency: Duration,
    pub allowed_bit_vec_rate: Quota,
    pub peer_gossip_max_count: usize,
    pub allowed_peers_rate: Quota,
}

Configuration for the peer-to-peer instance.

Warning

It is recommended to synchronize this configuration across peers in the network (with the exection of crypto, registry, address, bootstrappers, allow_private_ips, and mailbox_size). If this is not sycnhronized, connections could be unnecessarily dropped, messages could be parsed incorrectly, and/or peers will rate limit each other during normal operation.

Fields

crypto: C

Cryptographic primitives.

registry: Arc<Mutex<Registry>>

Registry for prometheus metrics.

address: SocketAddr

Dialable address of the peer.

bootstrappers: Vec<Bootstrapper>

Peers dialed on startup.

allow_private_ips: bool

Whether or not to allow connections with private IP addresses.

mailbox_size: usize

Message backlog allowed for internal actors.

When there are more messages in the mailbox than this value, any actor sending a message will be blocked until the mailbox is processed.

max_frame_length: usize

Maximum size used for all messages sent over the wire.

We use this to prevent malicious peers from sending us large messages that would consume all of our memory.

If a message is larger than this size, it will be chunked into parts of this size or smaller.

If this value is not synchronized across all connected peers, chunks will be parsed incorrectly (any non-terminal chunk must be of ~this size).

handshake_timeout: Duration

Duration after which to close the connection if the handshake is not completed.

read_timeout: Duration

Duration after which to close the connection if no message is read.

write_timeout: Duration

Duration after which to close the connection if a message cannot be written.

allowed_connection_rate_per_peer: Quota

Quota for connection attempts per peer (incoming or outgoing).

allowed_incoming_connection_rate: Quota

Quota for incoming connections across all peers.

dial_frequency: Duration

Frequency to attempt to dial known addresses.

dial_rate: Quota

Quota for peers to dial.

tracked_peer_sets: usize

Number of peer sets to keep in memory for handling peer requests.

gossip_bit_vec_frequency: Duration

Frequency we gossip about known peers.

If there is no other network activity, this message is used as a ping and should be sent more often than the read_timeout.

allowed_bit_vec_rate: Quota

Quota for bit vector messages a peer can send us.

peer_gossip_max_count: usize

Maximum number of peers we will send or consider valid when receiving in a single messsage.

This is used to prevent malicious peers from sending us a large number of peers at one time (each of which requires a signature verification).

allowed_peers_rate: Quota

Quota for peers messages a peer can send us.

Implementations

impl<C: Crypto> Config<C>

pub fn default( crypto: C, registry: Arc<Mutex<Registry>>, address: SocketAddr, bootstrappers: Vec<Bootstrapper>, allow_private_ips: bool, ) -> Self

Default produces a new configuration with reasonable defaults.

Trait Implementations

impl<C: Clone + Crypto> Clone for Config<C>

fn clone(&self) -> Config<C>

Returns a copy of the value.

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

Performs copy-assignment from source.