1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
use crate::net::constants::{DEFAULT_MTU, FRAGMENT_SIZE_DEFAULT, MAX_FRAGMENTS_DEFAULT}; use std::{default::Default, time::Duration}; #[derive(Clone)] /// Contains the configuration options to configure laminar for special use-cases. pub struct Config { /// Value which can specify the amount of time that can pass without hearing from a client before considering them disconnected pub idle_connection_timeout: Duration, /// Value which can specify the maximum size a packet can be in bytes. This value is inclusive of fragmenting; if a packet is fragmented, the total size of the fragments cannot exceed this value. /// /// Recommended value: 16384 pub max_packet_size: usize, /// Value which can specify the maximal allowed fragments. /// /// Why can't I have more than 255 (u8)? /// This is because you don't want to send more then 256 fragments over UDP, with high amounts of fragments the chance for an invalid packet is very high. /// Use TCP instead (later we will probably support larger ranges but every fragment packet then needs to be resent if it doesn't get an acknowledgment). /// /// default: 16 but keep in mind that lower is better. pub max_fragments: u8, /// Value which can specify the size of a fragment. /// /// This is the maximum size of each fragment. It defaults to `1450` bytes, due to the default MTU on most network devices being `1500`. pub fragment_size: u16, /// Value which can specify the size of the buffer that queues up fragments ready to be reassembled once all fragments have arrived.``` pub fragment_reassembly_buffer_size: u16, /// Value that specifies the size of the buffer the UDP data will be read into. Defaults to `1450` bytes. pub receive_buffer_max_size: usize, /// Value which can specify the factor which will smooth out network jitter. /// /// use-case: If one packet hast not arrived we don't directly want to transform to a bad network state. /// Value that specifies the factor used to smooth out network jitter. It defaults to 10% of the round-trip time. It is expressed as a ratio, with 0 equal to 0% and 1 equal to 100%. This helps prevent flapping of `VirtualConnections` pub rtt_smoothing_factor: f32, /// Value which can specify the maximal round trip time (rtt) for packet. /// /// Value which specifies the maximum round trip time before we consider it a problem. This is expressed in milliseconds. pub rtt_max_value: u16, /// Value which can specify the event buffer we read socket events into. /// /// Value that specifies the size of the event buffer into which we receive socket events, in bytes. Defaults to 1024. pub socket_event_buffer_size: usize, /// Value which can specify how long we should block polling for socket events. /// /// Value that specifies how long we should block polling for socket events, in milliseconds. Defaults to `1ms`. pub socket_polling_timeout: Option<Duration>, } impl Default for Config { fn default() -> Self { Self { idle_connection_timeout: Duration::from_secs(5), max_packet_size: (MAX_FRAGMENTS_DEFAULT * FRAGMENT_SIZE_DEFAULT) as usize, max_fragments: MAX_FRAGMENTS_DEFAULT as u8, fragment_size: FRAGMENT_SIZE_DEFAULT, fragment_reassembly_buffer_size: 64, receive_buffer_max_size: DEFAULT_MTU as usize, rtt_smoothing_factor: 0.10, rtt_max_value: 250, socket_event_buffer_size: 1024, socket_polling_timeout: Some(Duration::from_millis(1)), } } }