1 use slab;

     2 use mio::tcp::*;

     3 use mio::*;

     4 use std::io::Write;

     5 use std::io;

     6 use netbuf;

     7 

     8 use utils;

     9 

    10 type Slab<T> = slab::Slab<T, Token>;

    11 

    12 pub struct HWServer {

    13     listener: TcpListener,

    14     clients: Slab<HWClient>,

    15     rooms: Slab<HWRoom>

    16 }

    17 

    18 impl HWServer {

    19     pub fn new(listener: TcpListener, clients_limit: usize, rooms_limit: usize) -> HWServer {

    20         HWServer {

    21             listener: listener,

    22             clients: Slab::with_capacity(clients_limit),

    23             rooms: Slab::with_capacity(rooms_limit),

    24         }

    25     }

    26 

    27     pub fn register(&self, poll: &Poll) -> io::Result<()> {

    28         poll.register(&self.listener, utils::SERVER, Ready::readable(),

    29                       PollOpt::edge())

    30     }

    31 

    32     pub fn accept(&mut self, poll: &Poll) -> io::Result<()> {

    33         let (sock, addr) = self.listener.accept().unwrap();

    34         println!("Connected: {}", addr);

    35 

    36         let client = HWClient::new(sock);

    37         let token = self.clients.insert(client)

    38             .ok().expect("could not add connection to slab");

    39 

    40         self.clients[token].send_raw_msg(

    41             format!("CONNECTED\nHedgewars server http://www.hedgewars.org/\n{}\n\n"

    42             , utils::PROTOCOL_VERSION).as_bytes());

    43         self.clients[token].register(poll, token);

    44 

    45         Ok(())

    46     }

    47 

    48     pub fn client_readable(&mut self, poll: &Poll,

    49                            token: Token) -> io::Result<()> {

    50         self.clients[token].readable(poll)

    51     }

    52 

    53     pub fn client_writable(&mut self, poll: &Poll,

    54                            token: Token) -> io::Result<()> {

    55         self.clients[token].writable(poll)

    56     }

    57 }

    58 

    59 

    60 struct HWClient {

    61     sock: TcpStream,

    62     buf_in: netbuf::Buf,

    63     buf_out: netbuf::Buf

    64 }

    65 

    66 impl HWClient {

    67     fn new(sock: TcpStream) -> HWClient {

    68         HWClient {

    69             sock: sock,

    70             buf_in: netbuf::Buf::new(),

    71             buf_out: netbuf::Buf::new(),

    72         }

    73     }

    74 

    75     fn register(&self, poll: &Poll, token: Token) {

    76         poll.register(&self.sock, token, Ready::readable(),

    77                       PollOpt::edge())

    78             .ok().expect("could not register socket with event loop");

    79     }

    80 

    81     fn send_raw_msg(&mut self, msg: &[u8]) {

    82         self.buf_out.write(msg).unwrap();

    83         self.flush();

    84     }

    85 

    86     fn flush(&mut self) {

    87         self.buf_out.write_to(&mut self.sock).unwrap();

    88         self.sock.flush();

    89     }

    90 

    91     fn readable(&mut self, poll: &Poll) -> io::Result<()> {

    92         self.buf_in.read_from(&mut self.sock)?;

    93         println!("Incoming buffer size: {}", self.buf_in.len());

    94         Ok(())

    95     }

    96 

    97     fn writable(&mut self, poll: &Poll) -> io::Result<()> {

    98         self.buf_out.write_to(&mut self.sock)?;

    99         Ok(())

   100     }

   101 }

   102 

   103 struct HWRoom {

   104     name: String

   105 }