src/server.rs

   1 use std::io::{ TcpListener, TcpStream, Acceptor, Listener, IoError, IoResult, EndOfFile };
   2 use std::io::net::tcp::{ TcpAcceptor };
   3 use packet::{ Packet, IOReadError };
   4
   5 pub struct Server {
   6    acceptor: TcpAcceptor
   7 }
   8
   9 impl Server {
  10    pub fn new(port: u16) -> IoResult<Server> {
  11       let mut acceptor = try!(TcpListener::bind("127.0.0.1", port).listen());
  12
  13       let server = Server {
  14          acceptor: acceptor.clone()
  15       };
  16
  17       spawn(proc() {
  18          loop {
  19             for stream in acceptor.incoming() {
  20                match stream {
  21                   Err(_) => return,
  22                   Ok(stream) => spawn(proc() {
  23                      Server::handle_client(stream);
  24                   })
  25                }
  26             }
  27          }
  28       });
  29
  30       Ok(server)
  31    }
  32
  33    pub fn close(&mut self) -> IoResult<()> {
  34       self.acceptor.close_accept()
  35    }
  36
  37    fn handle_client(mut stream: TcpStream) {
  38       let mut current_timestamp = 0u64;
  39
  40       loop {
  41          // stream.set_timeout(Some(1000000000));
  42          match Packet::read(&mut stream) {
  43             Ok(packet) => {
  44                if packet.timestamp <= current_timestamp {
  45                   println!("Error, timestamp mismatch, current timestamp: {}, packet received: {}", current_timestamp, packet);
  46                } else {
  47                   current_timestamp += 1;
  48                   println!("Receive packet: {}", packet);
  49                }
  50             },
  51             // Socket has been closed.
  52             Err(IOReadError(IoError { kind: EndOfFile, .. })) => {
  53                return;
  54             },
  55             Err(e) => {
  56                println!("Read error: {}", e)
  57             }
  58          }
  59       }
  60    }
  61 }