Yet another project rewritten in Rust.

Features

• Stream/Sink/Future based async API.
  • Low level API but easy to use.
• RakNet features:
  • Support Unreliable, Reliable and ReliableOrdered packets.
  • Support multiple order channels.
  • Support ACK/NACK mechanism.
• Full tracing:
  • You can track a packet's span during deduplication, fragmentation, ...

Roadmap

Ordered by priority

• Documentation
• Simulation testing
• Bulk benchmark
• Optimize performance for single thread runtime (IO without Send)
• Robust client implementation
• Use stable rust toolchain (I like nightly)

Getting Started

See examples or integration testing for basic usage.

Server

Most operations are performed on Stream and Sink. There will be some optional options in opts.

Keep polling incoming because it also serves as the router to every connections. Apply Sink::poll_flush to IO will trigger to flush all pending packets, ACK/NACK, and stale packets. Apply Sink::poll_close to IO will ensure that all data is received by the peer before returning (i.e It may keep resending infinitely.).

Notice: All calculations are lazy. You need to decide how long to flush once, and how long to wait when closing before considering the peer is disconnected.

use bytes::Bytes;
use futures::{SinkExt, StreamExt};
use raknet_rs::server::{self, MakeIncoming};

let socket = tokio::net::UdpSocket::bind("127.0.0.1:0").await?;
let config = server::Config::new()
    .send_buf_cap(1024)
    .sever_guid(114514)
    .advertisement(&b"Hello, I am server"[..])
    ...
let mut incoming = socket.make_incoming(config);
let (reader, _) = incoming.next().await.unwrap();
tokio::pin!(reader);
let data: Bytes = reader.next().await.unwrap();

Client

The current version of the client only has the most basic handshake implementation, and it is not recommended to use it directly.

use bytes::Bytes;
use futures::{SinkExt, StreamExt};
use raknet_rs::client::{self, ConnectTo};
use raknet_rs::Reliability;

let socket = tokio::net::UdpSocket::bind("0.0.0.0:0").await?;
let config = client::Config::new()
    .send_buf_cap(1024)
    .client_guid(1919810)
    ...
let (_, writer) = socket.connect_to(<addr>, config).await?;
tokio::pin!(writer);
writer.send(Message::new(Reliability::Reliable, 0, Bytes::from_static(b"Hello, Anyone there?")))
    .await?;