Struct commonware_p2p::Config

pub struct Config<C: Scheme> {

    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 tcp_nodelay: Option<bool>,
    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.

tcp_nodelay: Option<bool>

Whether or not to disable Nagle’s algorithm.

The algorithm combines a series of small network packets into a single packet before sending to reduce overhead of sending multiple small packets which might not be efficient on slow, congested networks. However, to do so the algorithm introduces a slight delay as it waits to accumulate more data. Latency-sensitive networks should consider disabling it to send the packets as soon as possible to reduce latency.

Note: Make sure that your compile target has and allows this configuration otherwise panics or unexpected behaviours are possible.

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 track.

We will attempt to maintain connections to peers stored across all peer sets, not just the most recent. This allows us to continue serving requests to peers that have recently been evicted and/or to communicate with peers in a future set (if we, for example, are trying to do a reshare of a threshold key).

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: Scheme> Config<C>

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

Generates a configuration with reasonable defaults for usage in production.

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

Generates a configuration that minimizes peer discovery latency. This can be useful when running local demos.

Warning

It is not recommended to use this configuration in production.

Trait Implementations

impl<C: Clone + Scheme> 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.