Struct Client 

pub struct Client { /* private fields */ }

Low-level synchronous IRTT client.

Client exposes the protocol steps directly: connect a UDP socket, open a session, send probes, receive replies, poll timeouts, and close. Callers that do not need to own this loop can use the unified managed API in crate::managed when the tokio feature is enabled.

Example

Client is the runtime-free adapter. The caller drives receives and timeout polling between sends; see the standalone example for a complete loop. This example type-checks without contacting a server:

use irtt_client::{Client, ClientConfig};

let mut client = Client::connect(ClientConfig::default())?;
let outcome = client.open()?;
println!("opened: {outcome:?}");
let sent = client.send_probe()?;
println!("sent: {sent:?}");
let received = client.recv_once()?;
println!("received: {received:?}");
let timed_out = client.poll_timeouts()?;
println!("timeouts: {timed_out:?}");
let closed = client.close()?;
println!("closed: {closed:?}");

Implementations

impl Client

pub fn connect(config: ClientConfig) -> Result<Self, ClientError>

Resolve the configured server and create a connected UDP socket.

This validates local configuration and prepares the open request, but it does not contact the server. Call open to perform the IRTT open exchange.

Examples found in repository

examples/blocking_client.rs (line 40)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn open(&mut self) -> Result<OpenOutcome, ClientError>

Perform the IRTT open exchange.

On success, returns the negotiated open outcome and transitions the client into either an open probe session or completed no-test state. Open attempts use ClientConfig::open_timeouts. Malformed or unrelated datagrams are ignored until the current attempt’s absolute deadline, so one attempt may consume several datagrams without retransmitting. Silence or ignored traffic eventually produces ClientError::OpenTimeout. A structurally recognizable malformed or incompatible Open reply from the connected peer is terminal; when HMAC is configured, that recognition additionally requires authentication.

When a trusted reply allocates a token but later negotiation or socket preparation fails, the client sends a best-effort cleanup close and preserves the original failure. Failed opening never leaves the session machine open.

Examples found in repository

examples/blocking_client.rs (line 48)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn close(&mut self) -> Result<Vec<ClientEvent>, ClientError>

Send a close request and emit a ClientEvent::SessionClosed event.

The close event means the client has sent its close packet and stopped tracking the session locally; it is not a server acknowledgement. If the send fails, the negotiated DSCP is restored best-effort and the session and probe schedule remain open.

Examples found in repository

examples/blocking_client.rs (line 96)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn next_send_deadline(&self) -> Option<Instant>

Return the monotonic deadline for the next probe send, if another probe is scheduled.

Examples found in repository

examples/blocking_client.rs (line 65)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn probe_timeout(&self) -> Duration

Return the local timeout used to classify pending probes as lost.

Examples found in repository

examples/blocking_client.rs (line 60)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn send_probe(&mut self) -> Result<Vec<ClientEvent>, ClientError>

Send one echo probe if the negotiated run is still active.

Returns an EchoSent event when a probe is sent. Returns an empty event list when the run duration has elapsed and no further probe should be sent.

Examples found in repository

examples/blocking_client.rs (line 72)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn recv_once(&mut self) -> Result<Vec<ClientEvent>, ClientError>

Receive and classify at most one datagram from the socket.

Returns an empty event list when the socket read would block or times out. Malformed or unrelated datagrams are reported as warning events.

Examples found in repository

examples/blocking_client.rs (line 80)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn recv_available( &mut self, budget: RecvBudget, ) -> Result<Vec<ClientEvent>, ClientError>

Receive and classify datagrams until a receive produces no events or the receive budget is exhausted.

pub fn poll_timeouts(&mut self) -> Result<Vec<ClientEvent>, ClientError>

Polls for probes that have timed out as of the current monotonic time.

Examples found in repository

examples/blocking_client.rs (line 87)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn poll_timeouts_at( &mut self, now: Instant, ) -> Result<Vec<ClientEvent>, ClientError>

Polls for probes that have timed out as of now.

This is useful for callers that drive Client from their own event loop and want timeout decisions to use the same sampled Instant as their scheduling logic.

now is monotonic time only; wall-clock time is not used for timeout expiry.

pub fn is_run_complete(&self) -> bool

Return whether the current run has completed.

A normal run is complete once no more probes will be sent and all pending probes have either replied or timed out. No-test and closed sessions are also considered complete.

Examples found in repository

examples/blocking_client.rs (line 61)

fn main() {
    let config = ClientConfig {
        server_addr: "127.0.0.1:2112".to_owned(),
        duration: Some(RUN_DURATION),
        interval: Duration::from_millis(200),
        // A single short attempt keeps this example fast when no server is
        // reachable; production callers should generally keep the default.
        open_timeouts: vec![Duration::from_millis(300)],
        socket_config: irtt_client::SocketConfig {
            recv_timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        },
        ..Default::default()
    };

    let mut client = match Client::connect(config) {
        Ok(client) => client,
        Err(err) => {
            eprintln!("failed to prepare client socket: {err}");
            return;
        }
    };

    match client.open() {
        Ok(outcome) => println!("session opened: {outcome:?}"),
        Err(err) => {
            eprintln!("open failed (is a server running at 127.0.0.1:2112?): {err}");
            return;
        }
    }

    // The run itself lasts `duration`, but a lost probe isn't classified as
    // `EchoLoss` until `probe_timeout()` after it was sent; wait at least
    // that much past the run's own end so a loss near the end can still be
    // observed and printed before this example gives up and closes.
    let deadline = Instant::now() + RUN_DURATION + client.probe_timeout();
    while Instant::now() < deadline && !client.is_run_complete() {
        // send_probe is caller-paced: only call it once its own schedule
        // says a probe is due, rather than as fast as the loop spins.
        if client
            .next_send_deadline()
            .is_some_and(|send_at| Instant::now() >= send_at)
        {
            // A failed send retains its prepared probe without advancing the
            // schedule, so a persistent error (e.g. the interface going
            // down) would otherwise make this loop retry silently until the
            // safety deadline instead of reporting it.
            match client.send_probe() {
                Ok(events) => events.iter().for_each(print_event),
                Err(err) => {
                    eprintln!("send failed: {err}");
                    break;
                }
            }
        }
        match client.recv_once() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("receive failed: {err}");
                break;
            }
        }
        match client.poll_timeouts() {
            Ok(events) => events.iter().for_each(print_event),
            Err(err) => {
                eprintln!("timeout polling failed: {err}");
                break;
            }
        }
    }

    match client.close() {
        Ok(events) => events.iter().for_each(print_event),
        Err(err) => eprintln!("close failed: {err}"),
    }
}

pub fn is_peer_closed(&self) -> bool

Return whether the session was closed by a peer close-flagged reply.

Direct operations on a closed client still return ClientError::AlreadyClosed. This method lets higher-level run loops avoid treating a successfully observed peer close as a local cleanup failure.

Trait Implementations

impl Debug for Client

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

Formats the value using the given formatter.