Struct RUdpSocket

pub struct RUdpSocket { /* private fields */ }

A RUdp Client Socket

Represents a connection between you (the host) and the remote. You can send messages, receive messages and poll it for various events.

Once dropped, the socket will send a “terminate” message to the remote before shutting down.

A RUdpServer holds 0, 1 or more of them.

Implementations

impl RUdpSocket

pub fn connect<A: ToSocketAddrs>(remote_addr: A) -> IoResult<RUdpSocket>

Creates a Socket and connects to the remote instantly.

This will fail ONLY if there is something wrong with the network, preventing it to create a UDP Socket. This is NOT blocking, so any timeout event or things or the like will arrive as SocketEvents.

The socket will be created with the status SynSent, after which there will be 2 outcomes:

• The remote answered SynAck, and we set the status as “Connected”
• The remote did not answer, and we will get a timeout

Examples found in repository

examples/client.rs (line 5)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let mut client = reliudp::RUdpSocket::connect("127.0.0.1:61244").expect("Failed to create client");
    for i in 0.. {
        client.next_tick()?;
        // if i % 10 == 0 { dbg!(client.status()); }
        for client_event in client.drain_events() {
            if let SocketEvent::Data(d) = client_event {
                println!("Client: Incoming {:?} bytes (n={:?}) at frame {:?}", d.len(), d[0], i);
            } else {
                println!("Client: Incoming event {:?} at frame {:?}", client_event, i);
            }
        }
        
        ::std::thread::sleep(::std::time::Duration::from_millis(5));
    }
    Ok(())
}

examples/simple.rs (line 11)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let really_big_message: Vec<u8> = (0..65536).map(|v| (v % 256) as u8).collect();
    let really_big_message: Arc<[u8]> = Arc::from(really_big_message.into_boxed_slice());

    let mut server = reliudp::RUdpServer::new("0.0.0.0:50000").expect("Failed to create server");

    let mut client = reliudp::RUdpSocket::connect("192.168.1.89:50000").expect("Failed to create client");

    let mut sent_message: bool = false;

    println!("Created server & client. Starting main loop");
    for _frame in 0..300 {
        server.next_tick()?;
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }

        for server_event in server.drain_events() {
            println!("Server: Incoming event {:?}", server_event);
        }
        
        if !sent_message {
            client.send_data(Arc::clone(&really_big_message), reliudp::MessageType::KeyMessage);
            sent_message = true;
        }

        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    {
        // drop the server;
        let _s = server;
    }
    
    for _frame in 0..10 {
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }
        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    println!("Done.");
    Ok(())
}

pub fn set_timeout_delay(&mut self, timeout_delay: u64)

Set the number of iterations required before a remote is set as “dead”.

For instance, if your tick is every 50ms, and your timeout_delay is of 24, then roughly 50*24=1200ms (=1.2s) without a message from the remote will cause a timeout error.

pub fn set_timeout_delay_with( &mut self, milliseconds: u64, tick_interval_milliseconds: u64, )

pub fn set_heartbeat_delay(&mut self, heartbeat_delay: u64)

Set the number of iterations required before we send a “heartbeat” message to the remote, to make sure they don’t consider us as timed out.

pub fn set_heartbeat_delay_with( &mut self, milliseconds: u64, heartbeat_interval_milliseconds: u64, )

pub fn drain_events<'a>(&'a mut self) -> impl Iterator<Item = SocketEvent> + 'a

Drains socket events for this Socket.

This is one of the 2 ways to loop over all incoming events. See the examples for how to use it.

Examples found in repository

examples/client.rs (line 9)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let mut client = reliudp::RUdpSocket::connect("127.0.0.1:61244").expect("Failed to create client");
    for i in 0.. {
        client.next_tick()?;
        // if i % 10 == 0 { dbg!(client.status()); }
        for client_event in client.drain_events() {
            if let SocketEvent::Data(d) = client_event {
                println!("Client: Incoming {:?} bytes (n={:?}) at frame {:?}", d.len(), d[0], i);
            } else {
                println!("Client: Incoming event {:?} at frame {:?}", client_event, i);
            }
        }
        
        ::std::thread::sleep(::std::time::Duration::from_millis(5));
    }
    Ok(())
}

examples/simple.rs (line 20)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let really_big_message: Vec<u8> = (0..65536).map(|v| (v % 256) as u8).collect();
    let really_big_message: Arc<[u8]> = Arc::from(really_big_message.into_boxed_slice());

    let mut server = reliudp::RUdpServer::new("0.0.0.0:50000").expect("Failed to create server");

    let mut client = reliudp::RUdpSocket::connect("192.168.1.89:50000").expect("Failed to create client");

    let mut sent_message: bool = false;

    println!("Created server & client. Starting main loop");
    for _frame in 0..300 {
        server.next_tick()?;
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }

        for server_event in server.drain_events() {
            println!("Server: Incoming event {:?}", server_event);
        }
        
        if !sent_message {
            client.send_data(Arc::clone(&really_big_message), reliudp::MessageType::KeyMessage);
            sent_message = true;
        }

        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    {
        // drop the server;
        let _s = server;
    }
    
    for _frame in 0..10 {
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }
        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    println!("Done.");
    Ok(())
}

pub fn next_event(&mut self) -> Option<SocketEvent>

Gets the next socket event for this socket.

pub fn send_data(&mut self, data: Arc<[u8]>, message_type: MessageType)

Send data to the remote.

Examples found in repository

examples/simple.rs (line 29)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let really_big_message: Vec<u8> = (0..65536).map(|v| (v % 256) as u8).collect();
    let really_big_message: Arc<[u8]> = Arc::from(really_big_message.into_boxed_slice());

    let mut server = reliudp::RUdpServer::new("0.0.0.0:50000").expect("Failed to create server");

    let mut client = reliudp::RUdpSocket::connect("192.168.1.89:50000").expect("Failed to create client");

    let mut sent_message: bool = false;

    println!("Created server & client. Starting main loop");
    for _frame in 0..300 {
        server.next_tick()?;
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }

        for server_event in server.drain_events() {
            println!("Server: Incoming event {:?}", server_event);
        }
        
        if !sent_message {
            client.send_data(Arc::clone(&really_big_message), reliudp::MessageType::KeyMessage);
            sent_message = true;
        }

        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    {
        // drop the server;
        let _s = server;
    }
    
    for _frame in 0..10 {
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }
        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    println!("Done.");
    Ok(())
}

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

Same as terminate, but leave the Socket alive.

This is mostly useful if you want to still receive the data the other remote is currently sending at this time. However, note that no acks will be sent, so its usefulness is still limited.

pub fn terminate(self) -> IoResult<()>

Terminates the socket, by sending a “Ended” event to the remote.

pub fn ping(&self) -> Option<u32>

Returns the ping to the remote as ms

Returns None if the ping has not been computed yet

Examples found in repository

examples/server.rs (line 31)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let mut server = reliudp::RUdpServer::new("0.0.0.0:61244").expect("Failed to create server");

    let mut n = 0;
    for i in 0u64.. {
        server.next_tick()?;
        for server_event in server.drain_events() {
            println!("Server: Incoming event {:?}", server_event);
        }

        if i % 300 == 0 && server.remotes_len() > 0 {
            let big_message = generate_really_big_message(n);
            println!("Sending (n={:?}) {:?} bytes to all {:?} remotes", n, big_message.as_ref().len(), server.remotes_len());
            if n % 2 == 0 {
                server.send_data(&big_message, reliudp::MessageType::KeyMessage);
            } else {
                server.send_data(&big_message, reliudp::MessageType::Forgettable);
            }
            n += 1;

            for (address, socket) in server.iter() {
                println!("\tPing to remote {:?} is {:?}", address, socket.ping());
            }
        }
        
        ::std::thread::sleep(::std::time::Duration::from_millis(5));
    }
    Ok(())
}

pub fn next_tick(&mut self) -> IoResult<()>

Internal processing for this single source

Must be done before draining events. Even if there are no events, you will want to re-send acks, keep track of sent data, etc. next_tick does that for you.

Do NOT use this method if you have multiple remotes for a single UdpSocket (a single port): all packets not coming from the right remote (matching IP and port) will be discarded! This warning applies if this socket has been borrowed from a RUdpServer as well, because all the remotes are sharing the same port.

Examples found in repository

examples/client.rs (line 7)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let mut client = reliudp::RUdpSocket::connect("127.0.0.1:61244").expect("Failed to create client");
    for i in 0.. {
        client.next_tick()?;
        // if i % 10 == 0 { dbg!(client.status()); }
        for client_event in client.drain_events() {
            if let SocketEvent::Data(d) = client_event {
                println!("Client: Incoming {:?} bytes (n={:?}) at frame {:?}", d.len(), d[0], i);
            } else {
                println!("Client: Incoming event {:?} at frame {:?}", client_event, i);
            }
        }
        
        ::std::thread::sleep(::std::time::Duration::from_millis(5));
    }
    Ok(())
}

examples/simple.rs (line 18)

fn main() -> Result<(), Box<dyn (::std::error::Error)>> {
    let really_big_message: Vec<u8> = (0..65536).map(|v| (v % 256) as u8).collect();
    let really_big_message: Arc<[u8]> = Arc::from(really_big_message.into_boxed_slice());

    let mut server = reliudp::RUdpServer::new("0.0.0.0:50000").expect("Failed to create server");

    let mut client = reliudp::RUdpSocket::connect("192.168.1.89:50000").expect("Failed to create client");

    let mut sent_message: bool = false;

    println!("Created server & client. Starting main loop");
    for _frame in 0..300 {
        server.next_tick()?;
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }

        for server_event in server.drain_events() {
            println!("Server: Incoming event {:?}", server_event);
        }
        
        if !sent_message {
            client.send_data(Arc::clone(&really_big_message), reliudp::MessageType::KeyMessage);
            sent_message = true;
        }

        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    {
        // drop the server;
        let _s = server;
    }
    
    for _frame in 0..10 {
        client.next_tick()?;

        for client_event in client.drain_events() {
            println!("Client: Incoming event {:?}", client_event);
        }
        ::std::thread::sleep(::std::time::Duration::from_micros(16666));
    }

    println!("Done.");
    Ok(())
}

pub fn status(&self) -> SocketStatus

pub fn should_clear(&self) -> bool

Returns whether or not you should clear this RUdp client.

pub fn local_addr(&self) -> SocketAddr

pub fn remote_addr(&self) -> SocketAddr

Trait Implementations

impl Debug for RUdpSocket

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

Formats the value using the given formatter.

impl Drop for RUdpSocket

fn drop(&mut self)

Executes the destructor for this type.