Struct durian::ServerConfig

pub struct ServerConfig {
    pub addr: String,
    pub wait_for_clients: u32,
    pub total_expected_clients: Option<u32>,
    pub max_concurrent_accepts: u32,
    pub num_receive_streams: u32,
    pub num_send_streams: u32,
    pub keep_alive_interval: Option<Duration>,
    pub idle_timeout: Option<Duration>,
    pub alpn_protocols: Option<Vec<Vec<u8>>>,
}

Server configuration for spinning up a server on a socket address via PacketManager::init_server()

Fields

addr: String

Socket address of the server (hostname:port) (e.g. “127.0.0.1:5001”)

wait_for_clients: u32

Number of clients to block waiting for incoming connections

total_expected_clients: Option<u32>

[Optional] Total number of clients the server expects to connect with. The server will spin up a thread that waits for incoming client connections until total_expected_clients is reached. Set to None to allow any number of clients connections. If wait_for_clients > total_expected_clients, the server will still wait for wait_for_clients number of client connections.

max_concurrent_accepts: u32

Set the max number of concurrent connection accepts to process at any given time.

A thread will be spawned for each, allowing max_concurrent_accepts connections to come in at the same time. Default to wait_for_clients + total_expected_clients(if set), else number of cores available.

num_receive_streams: u32

Number of receive streams to accept from server to client. Must be equal to number of receive packets registered through PacketManager::register_receive_packet()

num_send_streams: u32

Number of send streams to open from client to server. Must be equal to number of send packets registered through PacketManager::register_send_packet()

keep_alive_interval: Option<Duration>

Period of inactivity before sending a keep-alive packet

Keep-alive packets prevent an inactive but otherwise healthy connection from timing out.

None to disable, which is the default. Only one side of any given connection needs keep-alive enabled for the connection to be preserved. Must be set lower than the idle_timeout of both peers to be effective.

idle_timeout: Option<Duration>

Maximum duration of inactivity to accept before timing out the connection. The true idle timeout is the minimum of this and the peer’s own max idle timeout. Defaults to 60 seconds. None represents an infinite timeout.

IMPORTANT: In the case of clients disconnecting abruptly, i.e. your application cannot call PacketManager::close_connection() or PacketManager::finish_connection() gracefully, the true idle timeout will help to remove disconnected clients from the connection queue, thus allowing them to reconnect after that timeout frame.

WARNING: If a peer or its network path malfunctions or acts maliciously, an infinite idle timeout can result in permanently hung futures!

alpn_protocols: Option<Vec<Vec<u8>>>

Protocols to send to server if applicable.

Example:

use durian::ServerConfig;

let mut config = ServerConfig::new("127.0.0.1:5000", 0, None, 2, 2);
config.with_alpn_protocols(&[b"hq-29"]);

Implementations

impl ServerConfig

pub fn new<S: Into<String>>( addr: S, wait_for_clients: u32, total_expected_clients: Option<u32>, num_receive_streams: u32, num_send_streams: u32 ) -> Self

Construct and return a new ServerConfig

pub fn new_with_max_clients<S: Into<String>>( addr: S, wait_for_clients: u32, num_receive_streams: u32, num_send_streams: u32 ) -> Self

Construct and return a new ServerConfig that only allows up to wait_for_clients number of client connections

pub fn new_listening<S: Into<String>>( addr: S, wait_for_clients: u32, num_receive_streams: u32, num_send_streams: u32 ) -> Self

Construct and return a new ServerConfig, with total_expected_clients set to None so the server continuously accepts new client connections

pub fn with_keep_alive_interval(&mut self, duration: Duration) -> &mut Self

Set the keep alive interval

pub fn with_idle_timeout(&mut self, duration: Option<Duration>) -> &mut Self

Set the max idle timeout

pub fn with_alpn_protocols(&mut self, protocols: &[&[u8]]) -> &mut Self

Set the ALPN protocols

pub fn with_max_concurrent_accepts( &mut self, max_concurrent_accepts: u32 ) -> &mut Self

Set the max concurrent accept connections

Trait Implementations

impl Clone for ServerConfig

fn clone(&self) -> ServerConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ServerConfig

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

Formats the value using the given formatter.

impl PartialEq<ServerConfig> for ServerConfig

fn eq(&self, other: &ServerConfig) -> 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 Eq for ServerConfig

impl StructuralEq for ServerConfig

impl StructuralPartialEq for ServerConfig