raknet_rust/lib.rs
1//! `raknet-rust` is an asynchronous RakNet transport library.
2//!
3//! The crate exposes two API layers:
4//! - High-level application API: [`server`], [`client`], [`listener`], [`connection`]
5//! - Low-level protocol/session/transport API: [`low_level`]
6//!
7//! # Quick Start (Server)
8//! ```rust,no_run
9//! use raknet_rust::server::{RaknetServer, RaknetServerEvent};
10//!
11//! #[tokio::main(flavor = "current_thread")]
12//! async fn main() -> std::io::Result<()> {
13//! let mut server = RaknetServer::bind("0.0.0.0:19132".parse().unwrap()).await?;
14//!
15//! while let Some(event) = server.next_event().await {
16//! if let RaknetServerEvent::Packet { peer_id, payload, .. } = event {
17//! server.send(peer_id, payload).await?;
18//! }
19//! }
20//!
21//! Ok(())
22//! }
23//! ```
24//!
25//! # Quick Start (Client)
26//! ```rust,no_run
27//! use raknet_rust::client::{RaknetClient, RaknetClientEvent};
28//!
29//! #[tokio::main(flavor = "current_thread")]
30//! async fn main() -> std::io::Result<()> {
31//! let mut client = RaknetClient::connect("127.0.0.1:19132".parse().unwrap()).await?;
32//!
33//! while let Some(event) = client.next_event().await {
34//! match event {
35//! RaknetClientEvent::Connected { .. } => {
36//! client.send(&b"hello"[..]).await?;
37//! }
38//! RaknetClientEvent::Packet { .. } => break,
39//! RaknetClientEvent::Disconnected { .. } => break,
40//! _ => {}
41//! }
42//! }
43//!
44//! Ok(())
45//! }
46//! ```
47pub mod client;
48mod concurrency;
49pub mod connection;
50pub mod error;
51pub mod event;
52pub mod handshake;
53pub mod listener;
54mod protocol;
55pub mod proxy;
56pub mod server;
57mod session;
58pub mod telemetry;
59mod transport;
60
61/// Advanced low-level API surface.
62///
63/// This namespace exposes protocol/session/transport internals for users that need
64/// fine-grained control over wire behavior and runtime tuning.
65pub mod low_level {
66 /// Wire-level packet/datagram/frame primitives and codecs.
67 pub mod protocol {
68 pub use crate::protocol::{
69 AckNackPayload, ConnectedControlPacket, Datagram, DatagramHeader, DatagramPayload,
70 Frame, FrameHeader, RaknetCodec, Reliability, Sequence24, SequenceRange, SplitInfo,
71 ack, codec, connected, constants, datagram, frame, frame_header, primitives,
72 reliability, sequence24,
73 };
74 }
75
76 /// Session internals such as queue behavior and reliability tuning.
77 pub mod session {
78 pub use crate::session::tunables;
79 pub use crate::session::{
80 QueuePayloadResult, RakPriority, ReceiptProgress, Session, SessionMetricsSnapshot,
81 SessionState, TrackedDatagram,
82 };
83 }
84
85 /// Transport runtime internals, shard runtime config, and routing policies.
86 pub mod transport {
87 pub use crate::transport::{
88 ConnectedFrameDelivery, EventOverflowPolicy, HandshakeHeuristicsConfig,
89 IdentityProxyRouter, InboundProxyRoute, OutboundProxyRoute, ProxyRouter,
90 QueueDispatchResult, RemoteDisconnectReason, SessionTunables, ShardedRuntimeCommand,
91 ShardedRuntimeConfig, ShardedRuntimeEvent, ShardedRuntimeHandle, ShardedSendPayload,
92 TransportConfig, TransportEvent, TransportMetricsSnapshot, TransportRateLimitConfig,
93 TransportServer,
94 };
95 }
96}
97
98pub use connection::{
99 Connection, ConnectionCloseReason, ConnectionId, ConnectionIo, ConnectionMetadata, RecvError,
100};
101pub use error::{ConfigValidationError, DecodeError, EncodeError};
102pub use listener::{Incoming, Listener, ListenerMetadata};
103pub use low_level::protocol::{ConnectedControlPacket, Reliability, Sequence24};
104pub use low_level::session::RakPriority;
105pub use low_level::transport::{
106 EventOverflowPolicy, ShardedRuntimeConfig, TransportConfig, TransportMetricsSnapshot,
107};