Struct diem_config::config::NetworkConfig

pub struct NetworkConfig {

    pub max_connection_delay_ms: u64,
    pub connection_backoff_base: u64,
    pub connectivity_check_interval_ms: u64,
    pub network_channel_size: usize,
    pub max_concurrent_network_reqs: usize,
    pub discovery_method: DiscoveryMethod,
    pub discovery_methods: Vec<DiscoveryMethod>,
    pub identity: Identity,
    pub listen_address: NetworkAddress,
    pub mutual_authentication: bool,
    pub network_address_key_backend: Option<SecureBackend>,
    pub network_id: NetworkId,
    pub seed_addrs: HashMap<PeerId, Vec<NetworkAddress>>,
    pub seeds: PeerSet,
    pub max_frame_size: usize,
    pub enable_proxy_protocol: bool,
    pub ping_interval_ms: u64,
    pub ping_timeout_ms: u64,
    pub ping_failures_tolerated: u64,
    pub max_outbound_connections: usize,
    pub max_inbound_connections: usize,
    pub inbound_rate_limit_config: Option<RateLimitConfig>,
    pub outbound_rate_limit_config: Option<RateLimitConfig>,
}

Fields

max_connection_delay_ms: u64

connection_backoff_base: u64

connectivity_check_interval_ms: u64

network_channel_size: usize

max_concurrent_network_reqs: usize

discovery_method: DiscoveryMethod

discovery_methods: Vec<DiscoveryMethod>

identity: Identity

listen_address: NetworkAddress

mutual_authentication: bool

network_address_key_backend: Option<SecureBackend>

network_id: NetworkId

seed_addrs: HashMap<PeerId, Vec<NetworkAddress>>

seeds: PeerSet

max_frame_size: usize

enable_proxy_protocol: bool

ping_interval_ms: u64

ping_timeout_ms: u64

ping_failures_tolerated: u64

max_outbound_connections: usize

max_inbound_connections: usize

inbound_rate_limit_config: Option<RateLimitConfig>

outbound_rate_limit_config: Option<RateLimitConfig>

Implementations

impl NetworkConfig

pub fn network_with_id(network_id: NetworkId) -> NetworkConfig

impl NetworkConfig

pub fn identity_key(&self) -> PrivateKey

pub fn identity_from_storage(&self) -> IdentityFromStorage

pub fn discovery_methods(&self) -> Vec<&DiscoveryMethod>

pub fn encryptor(&self) -> Encryptor<Storage>

pub fn load_validator_network(&mut self) -> Result<(), Error>

Per convenience, so that NetworkId isn’t needed to be specified for validator_networks

pub fn load_fullnode_network(&mut self) -> Result<(), Error>

pub fn peer_id(&self) -> PeerId

pub fn random(&mut self, rng: &mut StdRng)

pub fn random_with_peer_id(&mut self, rng: &mut StdRng, peer_id: Option<PeerId>)

pub fn verify_seeds(&self) -> Result<(), Error>

Trait Implementations

impl Clone for NetworkConfig

fn clone(&self) -> NetworkConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NetworkConfig

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

Formats the value using the given formatter.

impl Default for NetworkConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NetworkConfigwhere NetworkConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<NetworkConfig> for NetworkConfig

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for NetworkConfig

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NetworkConfig