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

/** use cli::{parse_args, Commands};

pub(crate) mod cli;
pub(crate) mod init;
pub(crate) mod keys;
pub(crate) mod list_transaction_crdt;
pub(crate) mod utils;
pub(crate) mod websocket;

#[tokio::main]
async fn main() {
    let args = parse_args();

    match &args.command {
        Some(Commands::Init { name }) => {
            let config = init::config::SideNodeConfig {
                name: name.to_string(),
            };

            let _ = init::init(home(name), config);
        }
        Some(Commands::Run { name }) => {
            let side_dir = home(name);
            let (mut bft_crdt, keys) = list_transaction_crdt::new(side_dir);
            websocket::start(keys, &mut bft_crdt).await.unwrap();
        }
        None => println!("No command provided. Exiting. See --help for more information."),
    }
}

fn home(name: &String) -> std::path::PathBuf {
    let mut path = dirs::home_dir().unwrap();
    path.push(".side");
    path.push(name);
    path
}
**/
use async_trait::async_trait;
use ezsockets::ClientConfig;
use std::io::BufRead;

struct Client {}

#[async_trait]
impl ezsockets::ClientExt for Client {
    type Call = ();

    async fn on_text(&mut self, text: String) -> Result<(), ezsockets::Error> {
        tracing::info!("received message: {text}");
        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> {
        let () = call;
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();
    let config = ClientConfig::new("ws://localhost:8080/websocket");
    let (handle, future) = ezsockets::connect(|_client| Client {}, config).await;
    tokio::spawn(async move {
        future.await.unwrap();
    });
    let stdin = std::io::stdin();
    let lines = stdin.lock().lines();
    for line in lines {
        let line = line.unwrap();
        tracing::info!("sending {line}");
        handle.text(line).unwrap();
    }
}