bft-crdt-experiment/side-node/src/websocket.rs

use async_trait::async_trait;
use bft_json_crdt::json_crdt::SignedOp;
use ezsockets::ClientConfig;
use tokio::sync::mpsc;

pub(crate) struct WebSocketClient {
    incoming_sender: mpsc::Sender<SignedOp>,
    network_receiver: mpsc::Receiver<SignedOp>,
    handle: ezsockets::Client<WebSocketClient>,
}

impl WebSocketClient {
    /// Start the websocket client
    pub(crate) async fn new(
        incoming_sender: mpsc::Sender<SignedOp>,
        network_receiver: mpsc::Receiver<SignedOp>,
    ) -> ezsockets::Client<WebSocketClient> {
        tracing_subscriber::fmt::init();
        let config = ClientConfig::new("ws://localhost:8080/websocket");
        let (handle, future) = ezsockets::connect(
            |client| WebSocketClient {
                incoming_sender,
                network_receiver,
                handle: client,
            },
            config,
        )
        .await;
        tokio::spawn(async move {
            future.await.unwrap();
        });
        handle
    }

    pub(crate) async fn start(&mut self) {
        loop {
            match self.network_receiver.try_recv() {
                Ok(signed_op) => {
                    let to_send = serde_json::to_string(&signed_op).unwrap();
                    self.handle.text(to_send).unwrap();
                }
                Err(_) => {} // ignore empty channel errors in this PoC
            }
        }
    }
}

#[async_trait]
impl ezsockets::ClientExt for WebSocketClient {
    type Call = String;

    async fn on_text(&mut self, text: String) -> Result<(), ezsockets::Error> {
        let incoming: bft_json_crdt::json_crdt::SignedOp = serde_json::from_str(&text).unwrap();
        tracing::info!("received signed op: {incoming:?}");
        self.incoming_sender.send(incoming).await.unwrap();
        Ok(())
    }

    async fn on_binary(&mut self, bytes: Vec<u8>) -> Result<(), ezsockets::Error> {
        tracing::info!("received bytes: {bytes:?}");
        Ok(())
    }

    async fn on_call(&mut self, call: Self::Call) -> Result<(), ezsockets::Error> {
        println!("received call: {call}");
        self.start().await;
        Ok(())
    }
}