Struct UdpServer 

pub struct UdpServer<const N: usize> { /* private fields */ }

Multi-peer UDP server adapter.

Implementations

impl<const N: usize> UdpServer<N>

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

where A: ToSocketAddrs,

Binds a UDP server socket using default MSRT config.

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

where A: ToSocketAddrs,

Binds a UDP server socket using config.

Examples found in repository

examples/server.rs (line 18)

async fn main() -> msrt_udp::Result<()> {
    let bind = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_BIND.to_string());
    let mut server = UdpServer::<16>::bind_with_config(&bind, demo_config()).await?;
    println!("server listening on {}", server.local_addr()?);

    let mut next_idle_sweep = Instant::now() + Duration::from_secs(1);

    loop {
        match server.tick().await? {
            UdpServerEvent::Message { peer, message } if message.as_bytes() != [0] => {
                let text = String::from_utf8_lossy(message.as_bytes());
                println!("{peer}: {text}");
                let reply = format!("echo from server: {text}");
                let _ = server.send_to(peer, reply.as_bytes())?;
            }
            UdpServerEvent::Message { .. } | UdpServerEvent::Idle => {}
            UdpServerEvent::SendFailed { peer, failed } => {
                println!("{peer}: send failed: {failed:?}; disconnecting peer");
                server.disconnect(peer);
            }
        }

        if next_idle_sweep <= Instant::now() {
            let disconnected = server.disconnect_idle(IDLE_TIMEOUT.as_millis() as u64);
            if disconnected > 0 {
                println!("disconnected {disconnected} idle peer(s)");
            }
            next_idle_sweep = Instant::now() + Duration::from_secs(1);
        }

        sleep(LOOP_SLEEP).await;
    }
}

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

Creates a server from an existing UDP socket.

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

Returns the local socket address.

Examples found in repository

examples/server.rs (line 19)

async fn main() -> msrt_udp::Result<()> {
    let bind = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_BIND.to_string());
    let mut server = UdpServer::<16>::bind_with_config(&bind, demo_config()).await?;
    println!("server listening on {}", server.local_addr()?);

    let mut next_idle_sweep = Instant::now() + Duration::from_secs(1);

    loop {
        match server.tick().await? {
            UdpServerEvent::Message { peer, message } if message.as_bytes() != [0] => {
                let text = String::from_utf8_lossy(message.as_bytes());
                println!("{peer}: {text}");
                let reply = format!("echo from server: {text}");
                let _ = server.send_to(peer, reply.as_bytes())?;
            }
            UdpServerEvent::Message { .. } | UdpServerEvent::Idle => {}
            UdpServerEvent::SendFailed { peer, failed } => {
                println!("{peer}: send failed: {failed:?}; disconnecting peer");
                server.disconnect(peer);
            }
        }

        if next_idle_sweep <= Instant::now() {
            let disconnected = server.disconnect_idle(IDLE_TIMEOUT.as_millis() as u64);
            if disconnected > 0 {
                println!("disconnected {disconnected} idle peer(s)");
            }
            next_idle_sweep = Instant::now() + Duration::from_secs(1);
        }

        sleep(LOOP_SLEEP).await;
    }
}

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 peer_state(&mut self, peer: SocketAddr) -> Option<PeerState>

Returns the peer state for peer.

pub fn peers(&self) -> impl Iterator<Item = SocketAddr> + '_

Returns the currently accepted peers.

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

Queues an application message for peer.

Examples found in repository

examples/server.rs (line 29)

async fn main() -> msrt_udp::Result<()> {
    let bind = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_BIND.to_string());
    let mut server = UdpServer::<16>::bind_with_config(&bind, demo_config()).await?;
    println!("server listening on {}", server.local_addr()?);

    let mut next_idle_sweep = Instant::now() + Duration::from_secs(1);

    loop {
        match server.tick().await? {
            UdpServerEvent::Message { peer, message } if message.as_bytes() != [0] => {
                let text = String::from_utf8_lossy(message.as_bytes());
                println!("{peer}: {text}");
                let reply = format!("echo from server: {text}");
                let _ = server.send_to(peer, reply.as_bytes())?;
            }
            UdpServerEvent::Message { .. } | UdpServerEvent::Idle => {}
            UdpServerEvent::SendFailed { peer, failed } => {
                println!("{peer}: send failed: {failed:?}; disconnecting peer");
                server.disconnect(peer);
            }
        }

        if next_idle_sweep <= Instant::now() {
            let disconnected = server.disconnect_idle(IDLE_TIMEOUT.as_millis() as u64);
            if disconnected > 0 {
                println!("disconnected {disconnected} idle peer(s)");
            }
            next_idle_sweep = Instant::now() + Duration::from_secs(1);
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn disconnect(&mut self, peer: SocketAddr) -> bool

Disconnects a peer and frees its server slot.

Examples found in repository

examples/server.rs (line 34)

async fn main() -> msrt_udp::Result<()> {
    let bind = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_BIND.to_string());
    let mut server = UdpServer::<16>::bind_with_config(&bind, demo_config()).await?;
    println!("server listening on {}", server.local_addr()?);

    let mut next_idle_sweep = Instant::now() + Duration::from_secs(1);

    loop {
        match server.tick().await? {
            UdpServerEvent::Message { peer, message } if message.as_bytes() != [0] => {
                let text = String::from_utf8_lossy(message.as_bytes());
                println!("{peer}: {text}");
                let reply = format!("echo from server: {text}");
                let _ = server.send_to(peer, reply.as_bytes())?;
            }
            UdpServerEvent::Message { .. } | UdpServerEvent::Idle => {}
            UdpServerEvent::SendFailed { peer, failed } => {
                println!("{peer}: send failed: {failed:?}; disconnecting peer");
                server.disconnect(peer);
            }
        }

        if next_idle_sweep <= Instant::now() {
            let disconnected = server.disconnect_idle(IDLE_TIMEOUT.as_millis() as u64);
            if disconnected > 0 {
                println!("disconnected {disconnected} idle peer(s)");
            }
            next_idle_sweep = Instant::now() + Duration::from_secs(1);
        }

        sleep(LOOP_SLEEP).await;
    }
}

pub fn disconnect_idle(&mut self, timeout_ms: u64) -> usize

Disconnects every peer idle for at least timeout_ms.

Examples found in repository

examples/server.rs (line 39)

async fn main() -> msrt_udp::Result<()> {
    let bind = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_BIND.to_string());
    let mut server = UdpServer::<16>::bind_with_config(&bind, demo_config()).await?;
    println!("server listening on {}", server.local_addr()?);

    let mut next_idle_sweep = Instant::now() + Duration::from_secs(1);

    loop {
        match server.tick().await? {
            UdpServerEvent::Message { peer, message } if message.as_bytes() != [0] => {
                let text = String::from_utf8_lossy(message.as_bytes());
                println!("{peer}: {text}");
                let reply = format!("echo from server: {text}");
                let _ = server.send_to(peer, reply.as_bytes())?;
            }
            UdpServerEvent::Message { .. } | UdpServerEvent::Idle => {}
            UdpServerEvent::SendFailed { peer, failed } => {
                println!("{peer}: send failed: {failed:?}; disconnecting peer");
                server.disconnect(peer);
            }
        }

        if next_idle_sweep <= Instant::now() {
            let disconnected = server.disconnect_idle(IDLE_TIMEOUT.as_millis() as u64);
            if disconnected > 0 {
                println!("disconnected {disconnected} idle peer(s)");
            }
            next_idle_sweep = Instant::now() + Duration::from_secs(1);
        }

        sleep(LOOP_SLEEP).await;
    }
}

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

Receives currently available UDP datagrams and feeds them into MSRT.

Unknown peers are accepted automatically. If the fixed-capacity peer table is full, Error::Accept is returned.

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

Polls one adapter event and sends pending UDP datagrams.

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

Runs receive_available followed by poll.

Examples found in repository

examples/server.rs (line 24)

async fn main() -> msrt_udp::Result<()> {
    let bind = env::args()
        .nth(1)
        .unwrap_or_else(|| DEFAULT_BIND.to_string());
    let mut server = UdpServer::<16>::bind_with_config(&bind, demo_config()).await?;
    println!("server listening on {}", server.local_addr()?);

    let mut next_idle_sweep = Instant::now() + Duration::from_secs(1);

    loop {
        match server.tick().await? {
            UdpServerEvent::Message { peer, message } if message.as_bytes() != [0] => {
                let text = String::from_utf8_lossy(message.as_bytes());
                println!("{peer}: {text}");
                let reply = format!("echo from server: {text}");
                let _ = server.send_to(peer, reply.as_bytes())?;
            }
            UdpServerEvent::Message { .. } | UdpServerEvent::Idle => {}
            UdpServerEvent::SendFailed { peer, failed } => {
                println!("{peer}: send failed: {failed:?}; disconnecting peer");
                server.disconnect(peer);
            }
        }

        if next_idle_sweep <= Instant::now() {
            let disconnected = server.disconnect_idle(IDLE_TIMEOUT.as_millis() as u64);
            if disconnected > 0 {
                println!("disconnected {disconnected} idle peer(s)");
            }
            next_idle_sweep = Instant::now() + Duration::from_secs(1);
        }

        sleep(LOOP_SLEEP).await;
    }
}

Trait Implementations

impl<const N: usize> Debug for UdpServer<N>

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

Formats the value using the given formatter.