Struct Config

pub struct Config<C: Scheme> {

    pub crypto: C,
    pub namespace: Vec<u8>,
    pub listen: SocketAddr,
    pub dialable: SocketAddr,
    pub bootstrappers: Vec<Bootstrapper<C::PublicKey>>,
    pub allow_private_ips: bool,
    pub max_message_size: usize,
    pub mailbox_size: usize,
    pub synchrony_bound: Duration,
    pub max_handshake_age: Duration,
    pub handshake_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 max_peer_set_size: 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 exception of crypto, registry, listen, bootstrappers, allow_private_ips, and mailbox_size). If this is not synchronized, 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.

namespace: Vec<u8>

Prefix for all signed messages to avoid replay attacks.

listen: SocketAddr

Address to listen on.

dialable: SocketAddr

Dialable address of the peer.

bootstrappers: Vec<Bootstrapper<C::PublicKey>>

Peers dialed on startup.

allow_private_ips: bool

Whether or not to allow connections with private IP addresses.

max_message_size: usize

Maximum size allowed for messages over any connection.

The actual size of the network message will be higher due to overhead from the protocol; this may include additional metadata, data from the codec, and/or cryptographic signatures.

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.

synchrony_bound: Duration

Time into the future that a timestamp can be and still be considered valid.

max_handshake_age: Duration

Duration after which a handshake message is considered stale.

handshake_timeout: Duration

Timeout for the handshake process.

This is often set to some value less than the connection read timeout to prevent unauthenticated peers from holding open connection.

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

max_peer_set_size: usize

Maximum number of peers to track in a single peer set.

This is used to limit the size of the bit vec messages, which will take one bit per peer in the set. This number can be set to a reasonably high value that we never expect to reach.

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

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, namespace: &[u8], listen: SocketAddr, dialable: SocketAddr, bootstrappers: Vec<Bootstrapper<C::PublicKey>>, max_message_size: usize, ) -> Self

Generates a configuration with reasonable defaults for usage in production.

pub fn aggressive( crypto: C, namespace: &[u8], listen: SocketAddr, dialable: SocketAddr, bootstrappers: Vec<Bootstrapper<C::PublicKey>>, max_message_size: usize, ) -> 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>

where C::PublicKey: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.