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 } |
|