imranmaj / websockets Goto Github PK

async fn foo() {
  // ...
  tokio::select!{
    _ = done_soon() => {
      do_stuff()
    },
    _ = websocket.receive() => {
      // ...
    }
  }
}

let mut conn = WebSocket::connect(&url).await.unwrap();
let (sink, stream) = conn.duplex().split();

let conn_stream = stream! {
    while let Some(frame) = stream.next().await {
        // Return a frame for certain responses
        yield frame;
    }
};

// Combine frame responses from frames received through a channel
futures::stream::select(conn_stream, frame_receiver.into_stream())
    .forward(sink)

#[tokio::main]
async fn main() {
    let mut binding = WebSocket::builder();
    let options = binding
        .add_header("Sec-WebSocket-Protocol", "wamp.json");

    let mut client = WampClient::connect("wss://chat.some.co/chat", options).await.unwrap();

    client.send(Hello { 
        realm: "co.fun.chat".to_string(), 
        details: json::object! {
           ...
        }
    }).await.unwrap();

    client.loop_messages().await;
}

pub struct WampClient {
    websocket: WebSocket,
    ...
}

impl WampClient {
    pub async fn connect(url: &str, mut options: &mut WebSocketBuilder) -> Result<Self, WebSocketError> {
        let websocket = options.connect(url).await?;
        
        Ok(Self { 
            websocket, 
            ...
        })
    }
    
   pub async fn send<M: WampMessageTrait>(&mut self, message: M) -> Result<(), Error> {
        Ok(self.websocket.send_text(
          message
                  .to_json()
                  .map_err(|e| Error::JsonError(e))?
                  .to_string()
              )
              .await
              .map_err(|e| Error::WsError(e))?
       )
    }
}