hcnet

hcnet

La couche inférieure du serveur et du client virtualisés peut facilement changer de protocole tel que tcp/tcps/ws/wss/udp pour faciliter le changement de protocole en toutes circonstances. Les exigences ultérieures telles que le numéro en ligne et le contrôle des flux seront traitées ultérieurement.

gestion des rappels

Utilisation unifiée des rappels pour les fonctions de traitement

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 ( ( ) )
    }
}

Surveillance côté serveur

écoute TCP

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

surveillance ws

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

surveillance WSS

La configuration des informations du certificat pendant la surveillance peut facilement prendre en charge le protocole 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 

surveillance kcp (udp)

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

Fondamentalement, la surveillance est la même que la surveillance générale des sockets, et la complexité est similaire. Vous pouvez changer de protocole à volonté.

Commencez à écouter côté serveur

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

Pour des exemples spécifiques, veuillez vous référer à server_echo

connexion client

connexion TCP

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

connexion ws

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

connexion wss

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

connexion kcp (udp)

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

Le client commence à écouter

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

ou

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

Pour des exemples spécifiques, veuillez vous référer à client_echo

Démarrer la démo

Démarrez d'abord le serveur

cargo run --example server_echo tcp

Redémarrez le client

cargo run --example client_echo tcp