Struct ClientConfig 

pub struct ClientConfig {

    pub server_addr: String,
    pub duration: Option<Duration>,
    pub interval: Duration,
    pub length: u32,
    pub received_stats: ReceivedStats,
    pub stamp_at: StampAt,
    pub clock: Clock,
    pub dscp: u8,
    pub hmac_key: Option<Vec<u8>>,
    pub server_fill: Option<String>,
    pub open_timeouts: Vec<Duration>,
    pub run_mode: RunMode,
    pub negotiation_policy: NegotiationPolicy,
    pub socket_config: SocketConfig,
    pub probe_timeout: Duration,
    pub max_pending_probes: usize,
}

Configuration for opening and running an IRTT client session.

This type describes both the protocol parameters sent in the IRTT open request and the local client behavior used to drive the UDP socket. Values that are negotiated by the server are available after opening the session through NegotiatedParams.

Example

Configure a finite run with larger probes and accept documented server restrictions. Use duration: None for continuous mode, or RunMode::NoTest for negotiation without probes.

use std::time::Duration;

use irtt_client::{ClientConfig, NegotiationPolicy};

let config = ClientConfig {
    server_addr: "example.net:2112".into(),
    duration: Some(Duration::from_secs(10)),
    interval: Duration::from_millis(250),
    length: 1200,
    negotiation_policy: NegotiationPolicy::Loose,
    ..ClientConfig::default()
};

assert_eq!(config.duration, Some(Duration::from_secs(10)));
assert_eq!(config.interval, Duration::from_millis(250));
assert_eq!(config.length, 1200);

Fields

server_addr: String

Remote server name or address.

If no port is present, the default IRTT port 2112 is used. IPv6 literals may be supplied either bracketed or unbracketed when the default port should be used.

duration: Option<Duration>

Requested run duration.

Some(duration) requests a finite test and must be greater than zero. None requests continuous mode and is encoded on the wire as a zero duration. Use RunMode::NoTest when the caller wants negotiation only without sending probes.

interval: Duration

Requested spacing between probe sends.

The interval is encoded as nanoseconds in the open request and must be greater than zero. The server may return a different interval depending on the negotiated policy and server restrictions.

length: u32

Requested echo packet payload length, in bytes.

The value must fit within the UDP payload limit after protocol overhead. A server may reduce the requested length during negotiation.

received_stats: ReceivedStats

Requested server receive-statistics fields in echo replies.

stamp_at: StampAt

Requested timestamp placement in echo replies.

clock: Clock

Requested server clock sources for timestamp fields.

Clock::Unspecified is the wire default meaning “no clock tag was sent” and is not a client mode; opening a session with it is rejected. Request Clock::Wall, Clock::Monotonic, or Clock::Both.

dscp: u8

Requested DSCP codepoint.

This is the six-bit DSCP value, not the full traffic-class byte, and must be less than or equal to MAX_DSCP_CODEPOINT.

hmac_key: Option<Vec<u8>>

Optional HMAC key used to authenticate IRTT packets.

When present, open, echo, and close packets are encoded and decoded with HMAC authentication. The peer must be configured with the same key.

server_fill: Option<String>

Optional server payload fill request.

None leaves server fill behavior unspecified. Some(value) requests a non-empty server fill mode/value and must not exceed MAX_SERVER_FILL_BYTES bytes when UTF-8 encoded.

open_timeouts: Vec<Duration>

Per-attempt receive timeouts used while opening the session.

The client sends an open request for each entry until a valid open reply is received. The list must not be empty, and each timeout must be at least 200 ms.

run_mode: RunMode

Whether opening the session should start a probe test or perform a negotiation-only no-test exchange.

negotiation_policy: NegotiationPolicy

Policy for server changes to negotiable protocol parameters.

socket_config: SocketConfig

Local UDP socket configuration.

probe_timeout: Duration

Time after sending a probe before the client reports it as lost.

This timeout is local client behavior; it is not negotiated with the server. It must be greater than zero.

max_pending_probes: usize

Maximum number of probes tracked as pending/timed-out/completed.

This bounds memory used for reply classification and must be greater than zero. A very small value can reject sends when replies are still outstanding.

Trait Implementations

impl Clone for ClientConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClientConfig

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

Formats the value using the given formatter.

impl Default for ClientConfig

fn default() -> Self

Returns the “default value” for a type.

impl Eq for ClientConfig

impl PartialEq for ClientConfig

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ClientConfig