Struct UdpClient 

pub struct UdpClient { /* private fields */ }

Connected UDP client adapter.

Implementations

impl UdpClient

pub async fn bind<A, R>(local: A, remote: R) -> Result<Self>

where A: ToSocketAddrs, R: ToSocketAddrs,

Binds a local UDP socket and connects it to remote.

pub async fn bind_with_config<A, R>( local: A, remote: R, config: EngineConfig, ) -> Result<Self>

where A: ToSocketAddrs, R: ToSocketAddrs,

Binds a local UDP socket, connects it to remote, and uses config.

Examples found in repository

examples/frontend.rs (line 20)

async fn main() -> msrt_udp::Result<()> {
    let server = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_SERVER.to_string());

    let mut client = UdpClient::bind_with_config("127.0.0.1:0", &server, demo_config()).await?;
    println!(
        "frontend local={} remote={}",
        client.local_addr()?,
        client.peer_addr()?
    );

    reconnect(&mut client)?;
    let mut sequence = 0_u64;
    let mut next_send = Instant::now();

    loop {
        if next_send <= Instant::now() {
            let payload = format!("hello udp {sequence}");
            if client.send(payload.as_bytes())? {
                println!("queued: {payload}");
                sequence = sequence.wrapping_add(1);
            }
            next_send = Instant::now() + SEND_INTERVAL;
        }

        match client.tick().await? {
            UdpClientEvent::Message(message) if message.as_bytes() != [0] => {
                println!("message: {}", String::from_utf8_lossy(message.as_bytes()));
            }
            UdpClientEvent::Message(_) | UdpClientEvent::Idle => {}
            UdpClientEvent::SendFailed(failed) => {
                println!("send failed: {failed:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now();
            }
            UdpClientEvent::TransportUnavailable { kind } => {
                println!("transport unavailable: {kind:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now() + reconnect_delay(kind);
            }
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn from_socket(socket: UdpSocket, config: EngineConfig) -> Self

Creates a client from an already connected UDP socket.

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the local socket address.

Examples found in repository

examples/frontend.rs (line 23)

async fn main() -> msrt_udp::Result<()> {
    let server = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_SERVER.to_string());

    let mut client = UdpClient::bind_with_config("127.0.0.1:0", &server, demo_config()).await?;
    println!(
        "frontend local={} remote={}",
        client.local_addr()?,
        client.peer_addr()?
    );

    reconnect(&mut client)?;
    let mut sequence = 0_u64;
    let mut next_send = Instant::now();

    loop {
        if next_send <= Instant::now() {
            let payload = format!("hello udp {sequence}");
            if client.send(payload.as_bytes())? {
                println!("queued: {payload}");
                sequence = sequence.wrapping_add(1);
            }
            next_send = Instant::now() + SEND_INTERVAL;
        }

        match client.tick().await? {
            UdpClientEvent::Message(message) if message.as_bytes() != [0] => {
                println!("message: {}", String::from_utf8_lossy(message.as_bytes()));
            }
            UdpClientEvent::Message(_) | UdpClientEvent::Idle => {}
            UdpClientEvent::SendFailed(failed) => {
                println!("send failed: {failed:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now();
            }
            UdpClientEvent::TransportUnavailable { kind } => {
                println!("transport unavailable: {kind:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now() + reconnect_delay(kind);
            }
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn peer_addr(&self) -> Result<SocketAddr>

Returns the remote socket address.

Examples found in repository

examples/frontend.rs (line 24)

async fn main() -> msrt_udp::Result<()> {
    let server = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_SERVER.to_string());

    let mut client = UdpClient::bind_with_config("127.0.0.1:0", &server, demo_config()).await?;
    println!(
        "frontend local={} remote={}",
        client.local_addr()?,
        client.peer_addr()?
    );

    reconnect(&mut client)?;
    let mut sequence = 0_u64;
    let mut next_send = Instant::now();

    loop {
        if next_send <= Instant::now() {
            let payload = format!("hello udp {sequence}");
            if client.send(payload.as_bytes())? {
                println!("queued: {payload}");
                sequence = sequence.wrapping_add(1);
            }
            next_send = Instant::now() + SEND_INTERVAL;
        }

        match client.tick().await? {
            UdpClientEvent::Message(message) if message.as_bytes() != [0] => {
                println!("message: {}", String::from_utf8_lossy(message.as_bytes()));
            }
            UdpClientEvent::Message(_) | UdpClientEvent::Idle => {}
            UdpClientEvent::SendFailed(failed) => {
                println!("send failed: {failed:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now();
            }
            UdpClientEvent::TransportUnavailable { kind } => {
                println!("transport unavailable: {kind:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now() + reconnect_delay(kind);
            }
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn peer_state(&self) -> PeerState

Returns the endpoint peer state.

pub const fn socket(&self) -> &UdpSocket

Returns a shared reference to the UDP socket.

pub fn socket_mut(&mut self) -> &mut UdpSocket

Returns a mutable reference to the UDP socket.

pub fn into_socket(self) -> UdpSocket

Consumes the adapter and returns the UDP socket.

pub fn connect(&mut self) -> Result<()>

Starts a fresh client session.

Examples found in repository

examples/frontend.rs (line 72)

fn reconnect(client: &mut UdpClient) -> msrt_udp::Result<()> {
    client.connect()?;
    println!("session started");
    Ok(())
}

pub fn disconnect(&mut self)

Drops the active client session.

Examples found in repository

examples/frontend.rs (line 48)

async fn main() -> msrt_udp::Result<()> {
    let server = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_SERVER.to_string());

    let mut client = UdpClient::bind_with_config("127.0.0.1:0", &server, demo_config()).await?;
    println!(
        "frontend local={} remote={}",
        client.local_addr()?,
        client.peer_addr()?
    );

    reconnect(&mut client)?;
    let mut sequence = 0_u64;
    let mut next_send = Instant::now();

    loop {
        if next_send <= Instant::now() {
            let payload = format!("hello udp {sequence}");
            if client.send(payload.as_bytes())? {
                println!("queued: {payload}");
                sequence = sequence.wrapping_add(1);
            }
            next_send = Instant::now() + SEND_INTERVAL;
        }

        match client.tick().await? {
            UdpClientEvent::Message(message) if message.as_bytes() != [0] => {
                println!("message: {}", String::from_utf8_lossy(message.as_bytes()));
            }
            UdpClientEvent::Message(_) | UdpClientEvent::Idle => {}
            UdpClientEvent::SendFailed(failed) => {
                println!("send failed: {failed:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now();
            }
            UdpClientEvent::TransportUnavailable { kind } => {
                println!("transport unavailable: {kind:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now() + reconnect_delay(kind);
            }
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn send(&mut self, message: &[u8]) -> Result<bool>

Queues an application message.

Examples found in repository

examples/frontend.rs (line 34)

async fn main() -> msrt_udp::Result<()> {
    let server = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_SERVER.to_string());

    let mut client = UdpClient::bind_with_config("127.0.0.1:0", &server, demo_config()).await?;
    println!(
        "frontend local={} remote={}",
        client.local_addr()?,
        client.peer_addr()?
    );

    reconnect(&mut client)?;
    let mut sequence = 0_u64;
    let mut next_send = Instant::now();

    loop {
        if next_send <= Instant::now() {
            let payload = format!("hello udp {sequence}");
            if client.send(payload.as_bytes())? {
                println!("queued: {payload}");
                sequence = sequence.wrapping_add(1);
            }
            next_send = Instant::now() + SEND_INTERVAL;
        }

        match client.tick().await? {
            UdpClientEvent::Message(message) if message.as_bytes() != [0] => {
                println!("message: {}", String::from_utf8_lossy(message.as_bytes()));
            }
            UdpClientEvent::Message(_) | UdpClientEvent::Idle => {}
            UdpClientEvent::SendFailed(failed) => {
                println!("send failed: {failed:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now();
            }
            UdpClientEvent::TransportUnavailable { kind } => {
                println!("transport unavailable: {kind:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now() + reconnect_delay(kind);
            }
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn receive_available(&mut self) -> Result<usize>

Receives currently available UDP datagrams and feeds them into MSRT.

pub async fn poll(&mut self) -> Result<UdpClientEvent>

Polls one adapter event and sends pending UDP datagrams.

pub async fn tick(&mut self) -> Result<UdpClientEvent>

Runs receive_available followed by poll.

Examples found in repository

examples/frontend.rs (line 41)

async fn main() -> msrt_udp::Result<()> {
    let server = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_SERVER.to_string());

    let mut client = UdpClient::bind_with_config("127.0.0.1:0", &server, demo_config()).await?;
    println!(
        "frontend local={} remote={}",
        client.local_addr()?,
        client.peer_addr()?
    );

    reconnect(&mut client)?;
    let mut sequence = 0_u64;
    let mut next_send = Instant::now();

    loop {
        if next_send <= Instant::now() {
            let payload = format!("hello udp {sequence}");
            if client.send(payload.as_bytes())? {
                println!("queued: {payload}");
                sequence = sequence.wrapping_add(1);
            }
            next_send = Instant::now() + SEND_INTERVAL;
        }

        match client.tick().await? {
            UdpClientEvent::Message(message) if message.as_bytes() != [0] => {
                println!("message: {}", String::from_utf8_lossy(message.as_bytes()));
            }
            UdpClientEvent::Message(_) | UdpClientEvent::Idle => {}
            UdpClientEvent::SendFailed(failed) => {
                println!("send failed: {failed:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now();
            }
            UdpClientEvent::TransportUnavailable { kind } => {
                println!("transport unavailable: {kind:?}; reconnecting");
                client.disconnect();
                reconnect(&mut client)?;
                next_send = Instant::now() + reconnect_delay(kind);
            }
        }

        sleep(LOOP_SLEEP).await;
    }
}

Trait Implementations

impl Debug for UdpClient

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

Formats the value using the given formatter.