rust raknet

rejilla de óxido

Implementación del protocolo RakNet por parte de Rust.

Raknet es un protocolo de transporte udp confiable que generalmente se usa para la comunicación entre clientes y servidores de juegos, y Minecraft Bedrock Edtion lo utiliza para la comunicación subyacente.

El protocolo Raknet admite varias opciones de confiabilidad y tiene un mejor rendimiento de transmisión que TCP en entornos de red inestables. Este proyecto es una implementación incompleta del protocolo mediante ingeniería inversa.

Requiere soporte de tiempo de ejecución asíncrono >= Tokio 1.x.

Referencia: http://www.jenkinssoftware.com/raknet/manual/index.html

Este proyecto no está afiliado a Jenkins Software LLC ni a RakNet.

Características

• asíncrono
• Licencia MIT
• Implementación de Rust puro
• Retransmisión rápida
• Retransmisión selectiva (TCP/retransmisión completa)
• ACK no retrasado (TCP/ACK retrasado)
• RTO no duplicado (TCP/RTO duplicado)
• Soporte para Linux/Windows/Mac/BSD
• Compatible con minecraft

Empezar

 # Cargo.toml
[ dependencies ]
rust-raknet = " * "

Documentación: https://docs.rs/rust-raknet/latest/rust_raknet/

Fiabilidad

• faltón
• secuenciado poco confiable
• confiable
• ordenado confiable
• secuenciado confiable

Ejemplo

 //server

async fn serve ( ) {
    let mut listener = RaknetListener :: bind ( "127.0.0.1:19132" . parse ( ) . unwrap ( ) ) . await . unwrap ( ) ;
    listener . listen ( ) . await ;
    loop {
        let socket = listener . accept ( ) . await . unwrap ( ) ;
        let buf = socket . recv ( ) . await . unwrap ( ) ;
        if buf [ 0 ] == 0xfe {
            //do something
        }
    }
    listener . close ( ) . await . unwrap ( ) ;
} 

 //client

async fn connect ( ) {
    let socket = RaknetSocket :: connect ( "127.0.0.1:19132" . parse ( ) . unwrap ( ) ) . await . unwrap ( ) ;
    socket . send ( & [ 0xfe ] , Reliability :: ReliableOrdered ) . await . unwrap ( ) ;
    let buf = socket . recv ( ) . await . unwrap ( ) ;
    if buf [ 0 ] == 0xfe {
        //do something
    }
    socket . close ( ) . await . unwrap ( ) ;
}

Punto de referencia

Utilice Tcp para comparar con este proyecto. Establezca la tasa de pérdida de paquetes del servidor en 50%, el cliente se conecta al servidor y el servidor envía un paquete de 800 bytes cada 30 ms, un total de 100 veces. El cliente cuenta el tiempo de demora de cada dato recibido y calcula el tiempo promedio de recepción 100 veces. Se obtienen los siguientes resultados.

Código de prueba: https://github.com/b23r0/rust-raknet/blob/main/example/test_benchmark/src/main.rs

Resultado:

(12 de junio de 2022)

En el entorno de red con una alta tasa de pérdida de paquetes, este proyecto puede reducir el tiempo de retraso en aproximadamente un 50 % en comparación con TCP.

Contribuyendo

Opciones:

• Informar un ERROR
• Enviar un PROBLEMA sobre sugerencia
• Enviar un PR mejorado
• Agregue un ejemplo del uso de Rust-raknet.
• Complemente la documentación sobre el uso de Rust-raknet.

Gracias a estas maravillosas personas.

b23r0

sustantivofve

¡Contribuciones de cualquier tipo son bienvenidas! Si alguna vez has querido contribuir al código abierto y a una gran causa, ¡ahora es tu oportunidad!

Donación

BTC: 1HeroYcNYMhjsq8RYCx1stSaRZnQd9B9Eq

ETH: 0x9999997B3deF7b69c09D7a9CA65E5242fb04a764