hcnet

hcnet

La capa inferior del servidor y cliente virtualizados puede cambiar fácilmente protocolos como tcp/tcps/ws/wss/udp para facilitar el cambio de protocolo bajo cualquier circunstancia. Los requisitos posteriores, como el número en línea y el control de flujo, se procesarán más adelante.

manejo de devolución de llamada

Uso unificado de devoluciones de llamada para funciones de procesamiento.

NetResult<()> { trace!("ws on_open"); Ok(()) } /// 此接口在远程服务端被关闭时进行触发 async fn on_close(&mut self, code: CloseCode, reason: String) { trace!( "on_close code = {}, reason = {reason}", Into::::into(code) ); } /// ping消息收到, 将会自动返回pong消息 async fn on_ping(&mut self, data: Vec) -> NetResult> { trace!("on_ping"); Ok(data) } /// pong消息 async fn on_pong(&mut self, data: Vec) -> NetResult<()> { let _data = data; trace!("on_pong"); Ok(()) } /// message信息收到 async fn on_message(&mut self, msg: Message) -> NetResult<()> { let _ = msg; Ok(()) } async fn on_request(&mut self, req: Request>) -> NetResult>> { WsHandshake::build_request(&req) } async fn on_response(&mut self, res: Request>) -> NetResult<()> { let _ = res; Ok(()) } } ">

 /// 连接处理回调函数
# [ async_trait ]
pub trait Handler {
    /// 此接口只有在服务端接受服务时进行触发
    /// 接收新的端口连接, 如果处理将在此触发
    async fn on_accept ( & mut self , conn : NetConn ) -> NetResult < ( ) > {
        let _conn = conn ;
        unreachable ! ( "Listener must impl accept" )
    }

    /// 此接口在可以发送消息时触发
    /// 例如websocket将在握手成功后触发该函数
    async fn on_open ( & mut self ) -> NetResult < ( ) > {
        trace ! ( "ws on_open" ) ;
        Ok ( ( ) )
    }

    /// 此接口在远程服务端被关闭时进行触发
    async fn on_close ( & mut self , code : CloseCode , reason : String ) {
        trace ! (
            "on_close code = {}, reason = {reason}" ,
            Into :: < u16 > :: into ( code )
        ) ;
    }

    /// ping消息收到, 将会自动返回pong消息
    async fn on_ping ( & mut self , data : Vec < u8 > ) -> NetResult < Vec < u8 > > {
        trace ! ( "on_ping" ) ;
        Ok ( data )
    }

    /// pong消息
    async fn on_pong ( & mut self , data : Vec < u8 > ) -> NetResult < ( ) > {
        let _data = data ;
        trace ! ( "on_pong" ) ;
        Ok ( ( ) )
    }

    /// message信息收到
    async fn on_message ( & mut self , msg : Message ) -> NetResult < ( ) > {
        let _ = msg ;
        Ok ( ( ) )
    }

    async fn on_request ( & mut self , req : Request < Vec < u8 > > ) -> NetResult < Response < Vec < u8 > > > {
        WsHandshake :: build_request ( & req )
    }

    async fn on_response ( & mut self , res : Request < Vec < u8 > > ) -> NetResult < ( ) > {
        let _ = res ;
        Ok ( ( ) )
    }
}

Monitoreo del lado del servidor

escucha tcp

 NetConn :: tcp_bind ( "0.0.0.0:2003" , Settings :: default ( ) ) . await 

monitoreo de ws

 NetConn :: ws_bind ( "0.0.0.0:2003" , Settings :: default ( ) ) . await 

monitoreo de agua

La configuración de la información del certificado durante el monitoreo puede admitir fácilmente el protocolo wss.

 let mut settings = Settings {
    domain : Some ( "test.wmproxy.net" . to_string ( ) ) ,
    cert : Some ( "key/example.com.pem" . to_string ( ) ) ,
    key : Some ( "key/example.com.key" . to_string ( ) ) ,
    .. Settings :: default ( )
} ;
NetConn :: ws_bind ( "0.0.0.0:2003" , settings ) . await 

monitoreo kcp (udp)

 NetConn :: kcp_bind ( "0.0.0.0:2003" ) . await

Básicamente, el monitoreo es el mismo que el monitoreo general de sockets y la complejidad es similar. Puede cambiar cualquier protocolo a voluntad.

Comience a escuchar en el lado del servidor

 let h = conn . run_handler ( |_| ServerHandler ) . await . unwrap ( ) ;
let _ = tokio :: join! ( h ) ;

Para ejemplos específicos, consulte server_echo

conexión de cliente

conexión TCP

 NetConn :: tcp_connect ( "127.0.0.1:2003" ) . await 

conexión ws

 NetConn :: ws_connect ( "ws://example.com:2003" ) . await 

conexión wss

 NetConn :: ws_connect ( "wss://example.com:2003" ) . await 

conexión kcp(udp)

 NetConn :: kcp_connect ( "wss://example.com:2003" ) . await

El cliente comienza a escuchar

 let ( mut sender , receiver ) = NetSender :: new ( 10 , 1 ) ;
let _ = conn . run_with_handler (
        ClientHandler {
            sender : sender . clone ( ) ,
        } ,
        receiver ,
    ) . await ;

o

 let _ = conn . run_handler ( |sender| ClientHandler { sender } ) . await ;

Para ejemplos específicos, consulte client_echo

Iniciar demostración

Inicie el servidor primero

cargo run --example server_echo tcp

Reiniciar el cliente

cargo run --example client_echo tcp