ws_server_example.rs

extern crate ws;

use std::sync::Arc;
use std::sync::Mutex;
use std::collections::HashMap;

use ws::*;
use ws::util::Token;

type Connections = Arc<Mutex<HashMap<Token, Arc<Mutex<Client>>>>>;

struct Client {
  // name of the connected client...
  name: Option<String>,
  sender: Sender,
  connections: Connections,
}

struct MyFactory {
  connections: Connections,
}

impl MyFactory {
    pub fn new() -> MyFactory {
        MyFactory {
            connections: Arc::new(Mutex::new(HashMap::new())),
        }
    }
}

impl Factory for MyFactory {
  type Handler = MyHandler;

  // client connects...
  fn connection_made(&mut self, ws: Sender) -> Self::Handler {
    let token = ws.token();

    let c = Arc::new(Mutex::new(Client {
      name: None,
      sender: ws,
      connections: self.connections.clone(),
    }));

    let mut connections = self.connections.lock().unwrap();

    println!("client connected: {:?}", token);

    connections.insert(token, c.clone());

    MyHandler::new(c)
  }

  // client disconnects...
  fn connection_lost(&mut self, handler: Self::Handler) {
    let data = handler.data.lock().unwrap();
    let mut connections = self.connections.lock().unwrap();

    let token = data.sender.token();

    println!("client disconnected: {:?}", token);

    connections.remove(&token);
  }
}

struct MyHandler {
  data: Arc<Mutex<Client>>,
}

impl MyHandler {
  pub fn new(data: Arc<Mutex<Client>>) -> MyHandler {
    MyHandler {
      data: data
    }
  }

  fn on_frame(&mut self, frame: Frame) {
    let data = self.data.lock().unwrap();
    let connections = data.connections.lock().unwrap();

    println!("frame received...: {:?}", frame);

    /* do something with connections... */
  }
}

impl Handler for MyHandler {
}

type Result<T> = ::std::result::Result<T, Error>;

fn entry() -> Result<()> {
    let factory = MyFactory::new();

    let w = WebSocket::new(factory)?;
    let w = w.listen("0.0.0.0:1234")?;
    let w = w.run()?;

    /* do something... */

    Ok(())
}

fn main() {
  if let Err(e) = entry() {
    println!("error = {:?}", e);
  }
}