Struct WSWriter

pub struct WSWriter { /* private fields */ }

Implementations

impl WSWriter

pub fn new(writer: Arc<Mutex<Writer>>) -> Self

pub async fn close_connection(&mut self) -> Result<(), Error>

pub async fn send_message(&mut self, message: Message) -> Result<(), Error>

Examples found in repository

examples/simple_server_tls.rs (line 43)

async fn run_server(port: u16, config: Arc<ServerConfig>) {
    match start_server(8080, Some(config)).await {
        Ok(mut event_receiver) => {
            let mut clients: HashMap<ID, WSWriter> = HashMap::new();
            info!("Server started on address 127.0.0.1:{}", port);
            while let Some(event) = event_receiver.next().await {
                match event {
                    Event::NewClient(id, client_conn) => {
                        info!("New client {} connected", id);
                        clients.insert(id, client_conn);
                    }
                    Event::NewMessage(client_id, message) => {
                        info!("Message from client {}: {:?}", client_id, message);
                        let ws_writer = clients.get_mut(&client_id).unwrap();
                        ws_writer.send_message(message).await.unwrap();
                    }
                    Event::Disconnect(client_id) => {
                        info!("Client {} disconnected", client_id);
                        clients.remove(&client_id);
                    }
                    Event::Error(client_id, error) => {
                        error!("Error occurred for client {}: {:?}", client_id, error);
                    }
                }
            }
        }
        Err(err) => {
            eprintln!("Could not start the server due to: {:?}", err);
        }
    }
}

examples/simple_server.rs (line 26)

async fn main() {
    env_logger::init();

    let port: u16 = 8080;
    match start_server(port, None).await {
        Ok(mut event_receiver) => {
            let mut clients: HashMap<ID, WSWriter> = HashMap::new();
            info!("Server started on address 127.0.0.1:{}", port);
            while let Some(event) = event_receiver.next().await {
                match event {
                    Event::NewClient(id, client_conn) => {
                        info!("New client {} connected", id);
                        clients.insert(id, client_conn);
                    }
                    Event::NewMessage(client_id, message) => {
                        info!("Message from client {}: {:?}", client_id, message);
                        let ws_writer = clients.get_mut(&client_id).unwrap();
                        ws_writer.send_message(message).await.unwrap();
                    }
                    Event::Disconnect(client_id) => {
                        info!("Client {} disconnected", client_id);
                        clients.remove(&client_id);
                    }
                    Event::Error(client_id, error) => {
                        error!("Error occurred for client {}: {:?}", client_id, error);
                    }
                }
            }
        }
        Err(err) => {
            eprintln!("Could not start the server due to: {:?}", err);
        }
    }
}

pub async fn send(&mut self, data: Vec<u8>) -> Result<(), Error>

pub async fn send_as_binary(&mut self, data: Vec<u8>) -> Result<(), Error>

pub async fn send_ping(&mut self) -> Result<(), Error>

pub async fn send_large_data_fragmented( &mut self, data: Vec<u8>, ) -> Result<(), Error>

Trait Implementations

impl Clone for WSWriter

fn clone(&self) -> WSWriter

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.