From 407f094306eab77b8ab94175ec40a28ac4e80a00 Mon Sep 17 00:00:00 2001 From: Titouan Rigoudy Date: Sun, 1 May 2016 14:09:43 +0200 Subject: [PATCH] Remove useless result module. --- src/handler.rs | 88 +++++++++++++++++++------------------- src/main.rs | 1 - src/result.rs | 113 ------------------------------------------------- 3 files changed, 43 insertions(+), 159 deletions(-) delete mode 100644 src/result.rs diff --git a/src/handler.rs b/src/handler.rs index 0d164d6..3a96a33 100644 --- a/src/handler.rs +++ b/src/handler.rs @@ -6,9 +6,8 @@ use std::sync::mpsc::Sender; use mio::{EventLoop, EventSet, Handler, PollOpt, Token}; use mio::tcp::TcpStream; -use proto::{Packet, PacketStream, ReadFromPacket, Request, Response}; +use proto::{Packet, PacketStream, Request, Response}; use proto::server::*; -use result; struct TokenCounter { counter: usize, @@ -81,61 +80,56 @@ impl ConnectionHandler { fn read_server(&mut self) { loop { - match self.read_server_once() { - Ok(true) => (), - Ok(false) => break, - Err(e) => { - error!("Error reading server: {}", e); - break; + let mut packet = match self.server_stream.try_read() { + Ok(Some(packet)) => packet, + Ok(None) => break, + Err(err) => { + error!("Error reading server: {}", err); + break + } + }; + + debug!("Read packet with size {}", packet.bytes_remaining()); + + let response = match packet.read_value() { + Ok(resp) => { + debug!("Received server response: {:?}", resp); + Response::ServerResponse(resp) + }, + Err(err) => { + error!("Error parsing server packet: {}", err); + break } + }; + + if let Err(err) = self.client_tx.send(response) { + error!("Error sending server response to client: {}", err); + break } } } fn write_server(&mut self) { loop { - match self.write_server_once() { - Ok(true) => (), - Ok(false) => break, + let mut packet = match self.server_queue.pop_front() { + Some(packet) => packet, + None => break + }; + + match self.server_stream.try_write(&mut packet) { + Ok(Some(())) => (), // continue looping + Ok(None) => { + self.server_queue.push_front(packet); + break + }, Err(e) => { - error!("Error writing server: {}", e); - break; + error!("Error writing server stream: {}", e); + break } } } } - fn read_server_once(&mut self) -> result::Result { - let mut packet = match try!(self.server_stream.try_read()) { - Some(packet) => packet, - None => return Ok(false), - }; - - debug!("Read packet with size {}", packet.bytes_remaining()); - let server_response = try!( - ServerResponse::read_from_packet(&mut packet) - ); - debug!("Received server response: {:?}", server_response); - - try!(self.client_tx.send(Response::ServerResponse(server_response))); - Ok(true) - } - - fn write_server_once(&mut self) -> io::Result { - let mut packet = match self.server_queue.pop_front() { - Some(packet) => packet, - None => return Ok(false), - }; - - match try!(self.server_stream.try_write(&mut packet)) { - Some(()) => Ok(true), - None => { - self.server_queue.push_front(packet); - Ok(false) - } - } - } - fn notify_server(&mut self, request: ServerRequest) -> io::Result<()> { debug!("Sending server request: {:?}", request); let packet = try!(request.to_packet()); @@ -143,15 +137,19 @@ impl ConnectionHandler { Ok(()) } + /// Re-register the server socket with the event loop. fn reregister_server(&mut self, event_loop: &mut EventLoop) { let event_set = if self.server_queue.len() > 0 { EventSet::readable() | EventSet::writable() } else { EventSet::readable() }; + let poll_opt = PollOpt::edge() | PollOpt::oneshot(); + self.server_stream.reregister( - event_loop, self.server_token, event_set, poll_opt).unwrap(); + event_loop, self.server_token, event_set, poll_opt + ).unwrap(); } } diff --git a/src/main.rs b/src/main.rs index 41b5031..77899df 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,7 +3,6 @@ mod client; mod config; mod control; -mod result; mod handler; mod proto; mod room; diff --git a/src/result.rs b/src/result.rs deleted file mode 100644 index a968c75..0000000 --- a/src/result.rs +++ /dev/null @@ -1,113 +0,0 @@ -use std::fmt; -use std::io; -use std::result; -use std::error; -use std::str; -use std::sync::mpsc; - -use rustc_serialize::json; - -use control; -use proto; - -#[derive(Debug)] -pub enum Error { - IOError(io::Error), - JSONEncoderError(json::EncoderError), - JSONDecoderError(json::DecoderError), - PacketReadError(proto::PacketReadError), - SendControlRequestError(mpsc::SendError), - SendProtoResponseError(mpsc::SendError), - Utf8Error(str::Utf8Error), -} - -impl fmt::Display for Error { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - match *self { - Error::IOError(ref err) => - write!(fmt, "IOError: {}", err), - Error::JSONEncoderError(ref err) => - write!(fmt, "JSONEncoderError: {}", err), - Error::JSONDecoderError(ref err) => - write!(fmt, "JSONDecoderError: {}", err), - Error::PacketReadError(ref err) => - write!(fmt, "PacketReadError: {}", err), - Error::SendControlRequestError(ref err) => - write!(fmt, "SendControlRequestError: {}", err), - Error::SendProtoResponseError(ref err) => - write!(fmt, "SendProtoResponseError: {}", err), - Error::Utf8Error(ref err) => - write!(fmt, "Utf8Error: {}", err), - } - } -} - -impl error::Error for Error { - fn description(&self) -> &str { - match *self { - Error::IOError(_) => "IOError", - Error::JSONEncoderError(_) => "JSONEncoderError", - Error::JSONDecoderError(_) => "JSONDecoderError", - Error::PacketReadError(_) => "PacketReadError", - Error::SendControlRequestError(_) => "SendControlRequestError", - Error::SendProtoResponseError(_) => "SendProtoResponseError", - Error::Utf8Error(_) => "Utf8Error", - } - } - - fn cause(&self) -> Option<&error::Error> { - match *self { - Error::IOError(ref err) => Some(err), - Error::JSONEncoderError(ref err) => Some(err), - Error::JSONDecoderError(ref err) => Some(err), - Error::PacketReadError(ref err) => Some(err), - Error::SendControlRequestError(ref err) => Some(err), - Error::SendProtoResponseError(ref err) => Some(err), - Error::Utf8Error(ref err) => Some(err), - } - } -} - -impl From for Error { - fn from(err: io::Error) -> Self { - Error::IOError(err) - } -} - -impl From for Error { - fn from(err: json::EncoderError) -> Self { - Error::JSONEncoderError(err) - } -} - -impl From for Error { - fn from(err: json::DecoderError) -> Self { - Error::JSONDecoderError(err) - } -} - -impl From for Error { - fn from(err: proto::PacketReadError) -> Self { - Error::PacketReadError(err) - } -} - -impl From> for Error { - fn from(err: mpsc::SendError) -> Self { - Error::SendControlRequestError(err) - } -} - -impl From> for Error { - fn from(err: mpsc::SendError) -> Self { - Error::SendProtoResponseError(err) - } -} - -impl From for Error { - fn from(err: str::Utf8Error) -> Self { - Error::Utf8Error(err) - } -} - -pub type Result = result::Result;