Struct Config 

pub struct Config<C: Signer> {

    pub crypto: C,
    pub namespace: Vec<u8>,
    pub listen: SocketAddr,
    pub dialable: Ingress,
    pub bootstrappers: Vec<Bootstrapper<C::PublicKey>>,
    pub allow_dns: bool,
    pub allow_private_ips: bool,
    pub max_message_size: u32,
    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 max_concurrent_handshakes: NonZeroU32,
    pub allowed_handshake_rate_per_ip: Quota,
    pub allowed_handshake_rate_per_subnet: Quota,
    pub dial_frequency: Duration,
    pub query_frequency: Duration,
    pub dial_fail_limit: usize,
    pub tracked_peer_sets: usize,
    pub max_peer_set_size: u64,
    pub gossip_bit_vec_frequency: Duration,
    pub peer_gossip_max_count: usize,
    pub block_duration: Duration,
}

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, 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: Ingress

Dialable ingress address of the peer.

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

Peers dialed on startup.

allow_dns: bool

Whether or not to allow DNS-based ingress addresses.

When dialing a DNS-based address, the hostname is resolved and a random IP is selected from the results (shuffled for each dial attempt).

allow_private_ips: bool

Whether or not to allow connections with private IP addresses.

max_message_size: u32

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

max_concurrent_handshakes: NonZeroU32

Maximum number of concurrent handshake attempts allowed.

allowed_handshake_rate_per_ip: Quota

Quota for handshake attempts originating from a single IP address.

To cap the number of handshakes concurrently attempted for a single IP, set this to Config::handshake_timeout.

allowed_handshake_rate_per_subnet: Quota

Quota for handshake attempts originating from a single IP subnet.

dial_frequency: Duration

Average frequency at which we make a single dial attempt across all peers.

query_frequency: Duration

Average frequency at which we will fetch a new list of dialable peers.

This value also limits the rate at which we attempt to re-dial any single peer.

dial_fail_limit: usize

Times that dialing a given peer should fail before asking for updated peer information for that peer.

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: u64

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.

This also determines the rate limit for incoming BitVec and Peers messages (one per half this frequency to account for jitter).

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

block_duration: Duration

Duration after which a blocked peer is allowed to reconnect.

Implementations

impl<C: Signer> Config<C>

pub fn recommended( crypto: C, namespace: &[u8], listen: SocketAddr, dialable: impl Into<Ingress>, bootstrappers: Vec<Bootstrapper<C::PublicKey>>, max_message_size: u32, ) -> Self

Generates a configuration with reasonable defaults for usage in production.

pub fn local( crypto: C, namespace: &[u8], listen: SocketAddr, dialable: impl Into<Ingress>, bootstrappers: Vec<Bootstrapper<C::PublicKey>>, max_message_size: u32, ) -> 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 + Signer> Clone for Config<C>

where C::PublicKey: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.