gistfile1.rs

#![feature(globs)]
extern crate mio; 

use mio::*;
use mio::net::*;
use mio::net::tcp::*;

const SERVER: Token = Token(0);

struct Server {
  pub acceptor: TcpAcceptor,
  pub clients: Vec<NonBlock<TcpSocket>>
}

impl Server {
  pub fn new(listening_socket: TcpAcceptor) -> Server {
    Server {
      acceptor: listening_socket,
      clients: Vec::new()
    }
  }
}

struct ServerHandler {
  pub server: Server
}

impl ServerHandler {
  fn new(server: Server) -> ServerHandler {
    ServerHandler{
      server: server
    }
  }
}

impl Handler<uint, ()> for ServerHandler {
  fn readable(&mut self, event_loop: &mut EventLoop<uint, ()>, token: Token, hint: ReadHint) {
    loop {
      match self.server.acceptor.accept() {
         Ok(client) => {
           if client.would_block() {
             break
           } else {
             self.server.clients.push(client);
             println!("{} clients", self.server.clients.len());
           }
         },
         Err(error) => {
          println!("Couldn't connect: {}", error);
         }
      }
    }
  }
}

pub fn main() {

  let mut event_loop = EventLoop::configured(EventLoopConfig{
    io_poll_timeout_ms: 1_000,
    notify_capacity: 8_192,
    messages_per_tick: 1_024,
    timer_wheel_size: 1_024,
    timer_tick_ms: 100,
    timer_capacity: 65_536
  }).unwrap();

  let addr = SockAddr::parse("0.0.0.0:44444")
                      .expect("could not parse InetAddr");

  let srv = TcpSocket::v4().unwrap();
  srv.set_reuseaddr(true).unwrap();
  let srv = srv.bind(&addr).unwrap()
               .listen(256u).unwrap();

  event_loop.register(&srv, SERVER).unwrap();
  let server = Server::new(srv);

  event_loop.run(ServerHandler::new(server))
            .ok()
            .expect("failed to execute event loop");
}