From f78448d3e8237f50fda354c7a14a643a9ca39564 Mon Sep 17 00:00:00 2001 From: Titouan Rigoudy Date: Sat, 18 May 2019 19:21:23 +0000 Subject: [PATCH] Upgrade to Rust 2018 edition. --- Cargo.toml | 1 + src/client.rs | 14 +-- src/control/response.rs | 4 +- src/control/ws.rs | 6 +- src/proto/codec.rs | 2 +- src/proto/handler.rs | 26 ++--- src/proto/packet.rs | 32 +++--- src/proto/peer/message.rs | 34 +++--- src/proto/server/request.rs | 90 ++++++++-------- src/proto/server/response.rs | 196 +++++++++++++++++------------------ src/proto/stream.rs | 6 +- src/proto/transport.rs | 4 +- src/proto/user.rs | 6 +- src/room.rs | 18 ++-- src/user.rs | 2 +- 15 files changed, 221 insertions(+), 220 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2f07e36..5b3b74b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,6 +2,7 @@ name = "solstice" version = "0.1.0" authors = ["letitz"] +edition = "2018" [dependencies] byteorder = "^0.5.1" diff --git a/src/client.rs b/src/client.rs index d489f5f..53b3418 100644 --- a/src/client.rs +++ b/src/client.rs @@ -4,13 +4,13 @@ use std::sync::mpsc; use mio; use slab; -use config; -use control; -use proto; -use proto::peer; -use proto::server; -use room; -use user; +use crate::config; +use crate::control; +use crate::proto; +use crate::proto::peer; +use crate::proto::server; +use crate::room; +use crate::user; #[derive(Debug)] enum IncomingMessage { diff --git a/src/control/response.rs b/src/control/response.rs index db16386..a0588e0 100644 --- a/src/control/response.rs +++ b/src/control/response.rs @@ -1,5 +1,5 @@ -use proto::User; -use room; +use crate::proto::User; +use crate::room; /// This enumeration is the list of possible control responses from the client /// to the controller. diff --git a/src/control/ws.rs b/src/control/ws.rs index 83d5c20..4bda16a 100644 --- a/src/control/ws.rs +++ b/src/control/ws.rs @@ -5,7 +5,7 @@ use std::sync::mpsc; use rustc_serialize::json; use ws; -use config; +use crate::config; use super::request::*; use super::response::*; @@ -82,8 +82,8 @@ pub struct Sender { impl Sender { /// Queues up a control response to be sent to the controller. pub fn send(&mut self, response: Response) -> Result<(), SendError> { - let encoded = try!(json::encode(&response)); - try!(self.sender.send(encoded)); + let encoded = json::encode(&response)?; + self.sender.send(encoded)?; Ok(()) } } diff --git a/src/proto/codec.rs b/src/proto/codec.rs index f85afd2..ffb2654 100644 --- a/src/proto/codec.rs +++ b/src/proto/codec.rs @@ -123,7 +123,7 @@ mod tests { use bytes::BytesMut; use tokio_codec::{Decoder, Encoder}; - use proto::ProtoEncode; + use crate::proto::ProtoEncode; use super::{LengthPrefixedDecoder, LengthPrefixedEncoder}; diff --git a/src/proto/handler.rs b/src/proto/handler.rs index 315c5d5..6f2fa77 100644 --- a/src/proto/handler.rs +++ b/src/proto/handler.rs @@ -7,7 +7,7 @@ use std::sync::mpsc; use mio; use slab; -use config; +use crate::config; use super::peer; use super::server::*; @@ -104,7 +104,7 @@ fn listener_bind(addr_spec: U) -> io::Result where U: ToSocketAddrs + fmt::Debug, { - for socket_addr in try!(addr_spec.to_socket_addrs()) { + for socket_addr in addr_spec.to_socket_addrs()? { if let Ok(listener) = mio::tcp::TcpListener::bind(&socket_addr) { return Ok(listener); } @@ -122,33 +122,33 @@ impl Handler { ) -> io::Result { let host = config::SERVER_HOST; let port = config::SERVER_PORT; - let server_stream = try!(Stream::new( + let server_stream = Stream::new( (host, port), ServerResponseSender(client_tx.clone()), - )); + )?; info!("Connected to server at {}:{}", host, port); - let listener = try!(listener_bind((config::LISTEN_HOST, config::LISTEN_PORT))); + let listener = listener_bind((config::LISTEN_HOST, config::LISTEN_PORT))?; info!( "Listening for connections on {}:{}", config::LISTEN_HOST, config::LISTEN_PORT ); - try!(event_loop.register( + event_loop.register( server_stream.evented(), mio::Token(SERVER_TOKEN), mio::Ready::all(), mio::PollOpt::edge() | mio::PollOpt::oneshot(), - )); + )?; - try!(event_loop.register( + event_loop.register( &listener, mio::Token(LISTEN_TOKEN), mio::Ready::all(), mio::PollOpt::edge() | mio::PollOpt::oneshot(), - )); + )?; Ok(Handler { server_stream: server_stream, @@ -171,7 +171,7 @@ impl Handler { let vacant_entry = match self.peer_streams.entry(peer_id) { None => return Err("id out of range".to_string()), - Some(slab::Entry::Occupied(occupied_entry)) => { + Some(slab::Entry::Occupied(_occupied_entry)) => { return Err("id already taken".to_string()) } @@ -270,7 +270,7 @@ impl mio::deprecated::Handler for Handler { if event_set.is_readable() { // A peer wants to connect to us. match self.listener.accept() { - Ok((sock, addr)) => { + Ok((_sock, addr)) => { // TODO add it to peer streams info!("Peer connection accepted from {}", addr); } @@ -351,10 +351,10 @@ pub struct Agent { impl Agent { pub fn new(client_tx: mpsc::Sender) -> io::Result { // Create the event loop. - let mut event_loop = try!(mio::deprecated::EventLoop::new()); + let mut event_loop = mio::deprecated::EventLoop::new()?; // Create the handler for the event loop and register the handler's // sockets with the event loop. - let handler = try!(Handler::new(client_tx, &mut event_loop)); + let handler = Handler::new(client_tx, &mut event_loop)?; Ok(Agent { event_loop: event_loop, diff --git a/src/proto/packet.rs b/src/proto/packet.rs index af6d9a7..d4e9417 100644 --- a/src/proto/packet.rs +++ b/src/proto/packet.rs @@ -28,7 +28,7 @@ impl io::Read for Packet { fn read(&mut self, buf: &mut [u8]) -> io::Result { let bytes_read = { let mut slice = &self.bytes[self.cursor..]; - try!(slice.read(buf)) + slice.read(buf)? }; self.cursor += bytes_read; Ok(bytes_read) @@ -179,27 +179,27 @@ impl From for PacketReadError { /// This trait is implemented by types that can be deserialized from binary /// Packets. pub trait ReadFromPacket: Sized { - fn read_from_packet(&mut Packet) -> Result; + fn read_from_packet(_: &mut Packet) -> Result; } /// 32-bit integers are serialized in 4 bytes, little-endian. impl ReadFromPacket for u32 { fn read_from_packet(packet: &mut Packet) -> Result { - Ok(try!(packet.read_u32::())) + Ok(packet.read_u32::()?) } } /// For convenience, usize's are deserialized as u32's then casted. impl ReadFromPacket for usize { fn read_from_packet(packet: &mut Packet) -> Result { - Ok(try!(u32::read_from_packet(packet)) as usize) + Ok(u32::read_from_packet(packet)? as usize) } } /// Booleans are serialized as single bytes, containing either 0 or 1. impl ReadFromPacket for bool { fn read_from_packet(packet: &mut Packet) -> Result { - match try!(packet.read_u8()) { + match packet.read_u8()? { 0 => Ok(false), 1 => Ok(true), n => Err(PacketReadError::InvalidBoolError(n)), @@ -210,7 +210,7 @@ impl ReadFromPacket for bool { /// 16-bit integers are serialized as 32-bit integers. impl ReadFromPacket for u16 { fn read_from_packet(packet: &mut Packet) -> Result { - let n = try!(u32::read_from_packet(packet)); + let n = u32::read_from_packet(packet)?; if n > MAX_PORT { return Err(PacketReadError::InvalidU16Error(n)); } @@ -221,7 +221,7 @@ impl ReadFromPacket for u16 { /// IPv4 addresses are serialized directly as 32-bit integers. impl ReadFromPacket for net::Ipv4Addr { fn read_from_packet(packet: &mut Packet) -> Result { - let ip = try!(u32::read_from_packet(packet)); + let ip = u32::read_from_packet(packet)?; Ok(net::Ipv4Addr::from(ip)) } } @@ -230,10 +230,10 @@ impl ReadFromPacket for net::Ipv4Addr { /// characters. impl ReadFromPacket for String { fn read_from_packet(packet: &mut Packet) -> Result { - let len = try!(usize::read_from_packet(packet)); + let len = usize::read_from_packet(packet)?; let mut buffer = vec![0; len]; - try!(packet.read_exact(&mut buffer)); + packet.read_exact(&mut buffer)?; match ISO_8859_1.decode(&buffer, DecoderTrap::Strict) { Ok(string) => Ok(string), @@ -245,11 +245,11 @@ impl ReadFromPacket for String { /// Vectors are serialized as length-prefixed arrays of values. impl ReadFromPacket for Vec { fn read_from_packet(packet: &mut Packet) -> Result { - let len = try!(usize::read_from_packet(packet)); + let len = usize::read_from_packet(packet)?; let mut vec = Vec::new(); for _ in 0..len { - vec.push(try!(T::read_from_packet(packet))); + vec.push(T::read_from_packet(packet)?); } Ok(vec) @@ -263,7 +263,7 @@ impl ReadFromPacket for Vec { /// This trait is implemented by types that can be serialized to a binary /// MutPacket. pub trait WriteToPacket { - fn write_to_packet(&self, &mut MutPacket) -> io::Result<()>; + fn write_to_packet(&self, _: &mut MutPacket) -> io::Result<()>; } /// 32-bit integers are serialized in 4 bytes, little-endian. @@ -276,7 +276,7 @@ impl WriteToPacket for u32 { /// Booleans are serialized as single bytes, containing either 0 or 1. impl WriteToPacket for bool { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_u8(*self as u8)); + packet.write_u8(*self as u8)?; Ok(()) } } @@ -301,8 +301,8 @@ impl WriteToPacket for str { } }; // Then write the bytes to the packet. - try!((bytes.len() as u32).write_to_packet(packet)); - try!(packet.write(&bytes)); + (bytes.len() as u32).write_to_packet(packet)?; + packet.write(&bytes)?; Ok(()) } } @@ -361,7 +361,7 @@ impl Parser { // Try to read as many bytes as we currently need from the underlying // byte stream. let offset = self.buffer.len() - self.num_bytes_left; - match try!(stream.try_read(&mut self.buffer[offset..])) { + match stream.try_read(&mut self.buffer[offset..])? { None => (), Some(num_bytes_read) => { diff --git a/src/proto/peer/message.rs b/src/proto/peer/message.rs index 83197e8..fb1d4b9 100644 --- a/src/proto/peer/message.rs +++ b/src/proto/peer/message.rs @@ -1,7 +1,7 @@ use std::io; -use proto::peer::constants::*; -use proto::{ +use crate::proto::peer::constants::*; +use crate::proto::{ MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ReadFromPacket, WriteToPacket, }; @@ -20,11 +20,11 @@ pub enum Message { impl ReadFromPacket for Message { fn read_from_packet(packet: &mut Packet) -> Result { - let code: u32 = try!(packet.read_value()); + let code: u32 = packet.read_value()?; let message = match code { - CODE_PIERCE_FIREWALL => Message::PierceFirewall(try!(packet.read_value())), + CODE_PIERCE_FIREWALL => Message::PierceFirewall(packet.read_value()?), - CODE_PEER_INIT => Message::PeerInit(try!(packet.read_value())), + CODE_PEER_INIT => Message::PeerInit(packet.read_value()?), code => Message::Unknown(code), }; @@ -85,13 +85,13 @@ impl WriteToPacket for Message { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { match *self { Message::PierceFirewall(ref token) => { - try!(packet.write_value(&CODE_PIERCE_FIREWALL)); - try!(packet.write_value(token)); + packet.write_value(&CODE_PIERCE_FIREWALL)?; + packet.write_value(token)?; } Message::PeerInit(ref request) => { - try!(packet.write_value(&CODE_PEER_INIT)); - try!(packet.write_value(request)); + packet.write_value(&CODE_PEER_INIT)?; + packet.write_value(request)?; } Message::Unknown(_) => unreachable!(), @@ -109,9 +109,9 @@ pub struct PeerInit { impl ReadFromPacket for PeerInit { fn read_from_packet(packet: &mut Packet) -> Result { - let user_name = try!(packet.read_value()); - let connection_type = try!(packet.read_value()); - let token = try!(packet.read_value()); + let user_name = packet.read_value()?; + let connection_type = packet.read_value()?; + let token = packet.read_value()?; Ok(PeerInit { user_name, connection_type, @@ -122,9 +122,9 @@ impl ReadFromPacket for PeerInit { impl WriteToPacket for PeerInit { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.user_name)); - try!(packet.write_value(&self.connection_type)); - try!(packet.write_value(&self.token)); + packet.write_value(&self.user_name)?; + packet.write_value(&self.connection_type)?; + packet.write_value(&self.token)?; Ok(()) } } @@ -157,8 +157,8 @@ mod tests { use bytes::BytesMut; - use proto::base_codec::tests::{expect_io_error, roundtrip}; - use proto::ProtoDecoder; + use crate::proto::base_codec::tests::{expect_io_error, roundtrip}; + use crate::proto::ProtoDecoder; use super::*; diff --git a/src/proto/server/request.rs b/src/proto/server/request.rs index 656ef3a..7afe1d0 100644 --- a/src/proto/server/request.rs +++ b/src/proto/server/request.rs @@ -3,9 +3,9 @@ use std::io; use crypto::digest::Digest; use crypto::md5::Md5; -use proto::packet::{MutPacket, WriteToPacket}; -use proto::server::constants::*; -use proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder}; +use crate::proto::packet::{MutPacket, WriteToPacket}; +use crate::proto::server::constants::*; +use crate::proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder}; /* ------- * * Helpers * @@ -40,57 +40,57 @@ impl WriteToPacket for ServerRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { match *self { ServerRequest::CannotConnectRequest(ref request) => { - try!(packet.write_value(&CODE_CANNOT_CONNECT)); - try!(packet.write_value(request)); + packet.write_value(&CODE_CANNOT_CONNECT)?; + packet.write_value(request)?; } ServerRequest::ConnectToPeerRequest(ref request) => { - try!(packet.write_value(&CODE_CONNECT_TO_PEER)); - try!(packet.write_value(request)); + packet.write_value(&CODE_CONNECT_TO_PEER)?; + packet.write_value(request)?; } ServerRequest::FileSearchRequest(ref request) => { - try!(packet.write_value(&CODE_FILE_SEARCH)); - try!(packet.write_value(request)); + packet.write_value(&CODE_FILE_SEARCH)?; + packet.write_value(request)?; } ServerRequest::LoginRequest(ref request) => { - try!(packet.write_value(&CODE_LOGIN)); - try!(packet.write_value(request)); + packet.write_value(&CODE_LOGIN)?; + packet.write_value(request)?; } ServerRequest::PeerAddressRequest(ref request) => { - try!(packet.write_value(&CODE_PEER_ADDRESS)); - try!(packet.write_value(request)); + packet.write_value(&CODE_PEER_ADDRESS)?; + packet.write_value(request)?; } ServerRequest::RoomJoinRequest(ref request) => { - try!(packet.write_value(&CODE_ROOM_JOIN)); - try!(packet.write_value(request)); + packet.write_value(&CODE_ROOM_JOIN)?; + packet.write_value(request)?; } ServerRequest::RoomLeaveRequest(ref request) => { - try!(packet.write_value(&CODE_ROOM_LEAVE)); - try!(packet.write_value(request)); + packet.write_value(&CODE_ROOM_LEAVE)?; + packet.write_value(request)?; } ServerRequest::RoomListRequest => { - try!(packet.write_value(&CODE_ROOM_LIST)); + packet.write_value(&CODE_ROOM_LIST)?; } ServerRequest::RoomMessageRequest(ref request) => { - try!(packet.write_value(&CODE_ROOM_MESSAGE)); - try!(packet.write_value(request)); + packet.write_value(&CODE_ROOM_MESSAGE)?; + packet.write_value(request)?; } ServerRequest::SetListenPortRequest(ref request) => { - try!(packet.write_value(&CODE_SET_LISTEN_PORT)); - try!(packet.write_value(request)); + packet.write_value(&CODE_SET_LISTEN_PORT)?; + packet.write_value(request)?; } ServerRequest::UserStatusRequest(ref request) => { - try!(packet.write_value(&CODE_USER_STATUS)); - try!(packet.write_value(request)); + packet.write_value(&CODE_USER_STATUS)?; + packet.write_value(request)?; } } Ok(()) @@ -216,8 +216,8 @@ pub struct CannotConnectRequest { impl WriteToPacket for CannotConnectRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.token)); - try!(packet.write_value(&self.user_name)); + packet.write_value(&self.token)?; + packet.write_value(&self.user_name)?; Ok(()) } } @@ -250,9 +250,9 @@ pub struct ConnectToPeerRequest { impl WriteToPacket for ConnectToPeerRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.token)); - try!(packet.write_value(&self.user_name)); - try!(packet.write_value(&self.connection_type)); + packet.write_value(&self.token)?; + packet.write_value(&self.user_name)?; + packet.write_value(&self.connection_type)?; Ok(()) } } @@ -290,8 +290,8 @@ pub struct FileSearchRequest { impl WriteToPacket for FileSearchRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.ticket)); - try!(packet.write_value(&self.query)); + packet.write_value(&self.ticket)?; + packet.write_value(&self.query)?; Ok(()) } } @@ -356,11 +356,11 @@ impl LoginRequest { impl WriteToPacket for LoginRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.username)); - try!(packet.write_value(&self.password)); - try!(packet.write_value(&self.major)); - try!(packet.write_value(&self.digest)); - try!(packet.write_value(&self.minor)); + packet.write_value(&self.username)?; + packet.write_value(&self.password)?; + packet.write_value(&self.major)?; + packet.write_value(&self.digest)?; + packet.write_value(&self.minor)?; Ok(()) } } @@ -403,7 +403,7 @@ pub struct PeerAddressRequest { impl WriteToPacket for PeerAddressRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.username)); + packet.write_value(&self.username)?; Ok(()) } } @@ -432,7 +432,7 @@ pub struct RoomJoinRequest { impl WriteToPacket for RoomJoinRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.room_name)); + packet.write_value(&self.room_name)?; Ok(()) } } @@ -463,7 +463,7 @@ pub struct RoomLeaveRequest { impl WriteToPacket for RoomLeaveRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.room_name)); + packet.write_value(&self.room_name)?; Ok(()) } } @@ -495,8 +495,8 @@ pub struct RoomMessageRequest { impl WriteToPacket for RoomMessageRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.room_name)); - try!(packet.write_value(&self.message)); + packet.write_value(&self.room_name)?; + packet.write_value(&self.message)?; Ok(()) } } @@ -527,7 +527,7 @@ pub struct SetListenPortRequest { impl WriteToPacket for SetListenPortRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.port)); + packet.write_value(&self.port)?; Ok(()) } } @@ -556,7 +556,7 @@ pub struct UserStatusRequest { impl WriteToPacket for UserStatusRequest { fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> { - try!(packet.write_value(&self.user_name)); + packet.write_value(&self.user_name)?; Ok(()) } } @@ -586,8 +586,8 @@ mod tests { use bytes::BytesMut; - use proto::base_codec::tests::{expect_io_error, roundtrip}; - use proto::ProtoDecoder; + use crate::proto::base_codec::tests::{expect_io_error, roundtrip}; + use crate::proto::ProtoDecoder; use super::*; diff --git a/src/proto/server/response.rs b/src/proto/server/response.rs index 6065498..368c72a 100644 --- a/src/proto/server/response.rs +++ b/src/proto/server/response.rs @@ -1,9 +1,9 @@ use std::io; use std::net; -use proto::packet::{Packet, PacketReadError, ReadFromPacket}; -use proto::server::constants::*; -use proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, User, UserStatus}; +use crate::proto::packet::{Packet, PacketReadError, ReadFromPacket}; +use crate::proto::server::constants::*; +use crate::proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, User, UserStatus}; /*=================* * SERVER RESPONSE * @@ -36,52 +36,52 @@ pub enum ServerResponse { impl ReadFromPacket for ServerResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let code: u32 = try!(packet.read_value()); + let code: u32 = packet.read_value()?; let resp = match code { CODE_CONNECT_TO_PEER => { - ServerResponse::ConnectToPeerResponse(try!(packet.read_value())) + ServerResponse::ConnectToPeerResponse(packet.read_value()?) } - CODE_FILE_SEARCH => ServerResponse::FileSearchResponse(try!(packet.read_value())), + CODE_FILE_SEARCH => ServerResponse::FileSearchResponse(packet.read_value()?), - CODE_LOGIN => ServerResponse::LoginResponse(try!(packet.read_value())), + CODE_LOGIN => ServerResponse::LoginResponse(packet.read_value()?), - CODE_PEER_ADDRESS => ServerResponse::PeerAddressResponse(try!(packet.read_value())), + CODE_PEER_ADDRESS => ServerResponse::PeerAddressResponse(packet.read_value()?), CODE_PRIVILEGED_USERS => { - ServerResponse::PrivilegedUsersResponse(try!(packet.read_value())) + ServerResponse::PrivilegedUsersResponse(packet.read_value()?) } - CODE_ROOM_JOIN => ServerResponse::RoomJoinResponse(try!(packet.read_value())), + CODE_ROOM_JOIN => ServerResponse::RoomJoinResponse(packet.read_value()?), - CODE_ROOM_LEAVE => ServerResponse::RoomLeaveResponse(try!(packet.read_value())), + CODE_ROOM_LEAVE => ServerResponse::RoomLeaveResponse(packet.read_value()?), - CODE_ROOM_LIST => ServerResponse::RoomListResponse(try!(packet.read_value())), + CODE_ROOM_LIST => ServerResponse::RoomListResponse(packet.read_value()?), - CODE_ROOM_MESSAGE => ServerResponse::RoomMessageResponse(try!(packet.read_value())), + CODE_ROOM_MESSAGE => ServerResponse::RoomMessageResponse(packet.read_value()?), - CODE_ROOM_TICKERS => ServerResponse::RoomTickersResponse(try!(packet.read_value())), + CODE_ROOM_TICKERS => ServerResponse::RoomTickersResponse(packet.read_value()?), CODE_ROOM_USER_JOINED => { - ServerResponse::RoomUserJoinedResponse(try!(packet.read_value())) + ServerResponse::RoomUserJoinedResponse(packet.read_value()?) } - CODE_ROOM_USER_LEFT => ServerResponse::RoomUserLeftResponse(try!(packet.read_value())), + CODE_ROOM_USER_LEFT => ServerResponse::RoomUserLeftResponse(packet.read_value()?), - CODE_USER_INFO => ServerResponse::UserInfoResponse(try!(packet.read_value())), + CODE_USER_INFO => ServerResponse::UserInfoResponse(packet.read_value()?), - CODE_USER_STATUS => ServerResponse::UserStatusResponse(try!(packet.read_value())), + CODE_USER_STATUS => ServerResponse::UserStatusResponse(packet.read_value()?), CODE_WISHLIST_INTERVAL => { - ServerResponse::WishlistIntervalResponse(try!(packet.read_value())) + ServerResponse::WishlistIntervalResponse(packet.read_value()?) } CODE_PARENT_MIN_SPEED => { - ServerResponse::ParentMinSpeedResponse(try!(packet.read_value())) + ServerResponse::ParentMinSpeedResponse(packet.read_value()?) } CODE_PARENT_SPEED_RATIO => { - ServerResponse::ParentSpeedRatioResponse(try!(packet.read_value())) + ServerResponse::ParentSpeedRatioResponse(packet.read_value()?) } code => ServerResponse::UnknownResponse(code), @@ -275,12 +275,12 @@ pub struct ConnectToPeerResponse { impl ReadFromPacket for ConnectToPeerResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let user_name = try!(packet.read_value()); - let connection_type = try!(packet.read_value()); - let ip = try!(packet.read_value()); - let port = try!(packet.read_value()); - let token = try!(packet.read_value()); - let is_privileged = try!(packet.read_value()); + let user_name = packet.read_value()?; + let connection_type = packet.read_value()?; + let ip = packet.read_value()?; + let port = packet.read_value()?; + let token = packet.read_value()?; + let is_privileged = packet.read_value()?; Ok(ConnectToPeerResponse { user_name, @@ -337,9 +337,9 @@ pub struct FileSearchResponse { impl ReadFromPacket for FileSearchResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let user_name = try!(packet.read_value()); - let ticket = try!(packet.read_value()); - let query = try!(packet.read_value()); + let user_name = packet.read_value()?; + let ticket = packet.read_value()?; + let query = packet.read_value()?; Ok(FileSearchResponse { user_name, @@ -389,10 +389,10 @@ pub enum LoginResponse { impl ReadFromPacket for LoginResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let ok = try!(packet.read_value()); + let ok = packet.read_value()?; if ok { - let motd = try!(packet.read_value()); - let ip = try!(packet.read_value()); + let motd = packet.read_value()?; + let ip = packet.read_value()?; match packet.read_value::() { Ok(value) => debug!("LoginResponse last field: {}", value), @@ -406,7 +406,7 @@ impl ReadFromPacket for LoginResponse { }) } else { Ok(LoginResponse::LoginFail { - reason: try!(packet.read_value()), + reason: packet.read_value()?, }) } } @@ -469,7 +469,7 @@ pub struct ParentMinSpeedResponse { impl ReadFromPacket for ParentMinSpeedResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let value = try!(packet.read_value()); + let value = packet.read_value()?; Ok(ParentMinSpeedResponse { value }) } } @@ -498,7 +498,7 @@ pub struct ParentSpeedRatioResponse { impl ReadFromPacket for ParentSpeedRatioResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let value = try!(packet.read_value()); + let value = packet.read_value()?; Ok(ParentSpeedRatioResponse { value }) } } @@ -529,9 +529,9 @@ pub struct PeerAddressResponse { impl ReadFromPacket for PeerAddressResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let username = try!(packet.read_value()); - let ip = try!(packet.read_value()); - let port = try!(packet.read_value()); + let username = packet.read_value()?; + let ip = packet.read_value()?; + let port = packet.read_value()?; Ok(PeerAddressResponse { username, ip, port }) } @@ -565,7 +565,7 @@ pub struct PrivilegedUsersResponse { impl ReadFromPacket for PrivilegedUsersResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let users = try!(packet.read_value()); + let users = packet.read_value()?; Ok(PrivilegedUsersResponse { users }) } } @@ -598,15 +598,15 @@ pub struct RoomJoinResponse { impl ReadFromPacket for RoomJoinResponse { fn read_from_packet(packet: &mut Packet) -> Result { let mut response = RoomJoinResponse { - room_name: try!(packet.read_value()), + room_name: packet.read_value()?, users: Vec::new(), owner: None, operators: Vec::new(), }; - let num_users: usize = try!(packet.read_value()); + let num_users: usize = packet.read_value()?; for _ in 0..num_users { - let name: String = try!(packet.read_value()); + let name: String = packet.read_value()?; let user = User { name, status: UserStatus::Offline, @@ -621,14 +621,14 @@ impl ReadFromPacket for RoomJoinResponse { response.users.push(user); } - try!(response.read_user_infos(packet)); + response.read_user_infos(packet)?; if packet.bytes_remaining() > 0 { - response.owner = Some(try!(packet.read_value())); + response.owner = Some(packet.read_value()?); - let num_operators: usize = try!(packet.read_value()); + let num_operators: usize = packet.read_value()?; for _ in 0..num_operators { - response.operators.push(try!(packet.read_value())); + response.operators.push(packet.read_value()?); } } @@ -638,35 +638,35 @@ impl ReadFromPacket for RoomJoinResponse { impl RoomJoinResponse { fn read_user_infos(&mut self, packet: &mut Packet) -> Result<(), PacketReadError> { - let num_statuses: usize = try!(packet.read_value()); + let num_statuses: usize = packet.read_value()?; for i in 0..num_statuses { if let Some(user) = self.users.get_mut(i) { - user.status = try!(packet.read_value()); + user.status = packet.read_value()?; } } - let num_infos: usize = try!(packet.read_value()); + let num_infos: usize = packet.read_value()?; for i in 0..num_infos { if let Some(user) = self.users.get_mut(i) { - user.average_speed = try!(packet.read_value()); - user.num_downloads = try!(packet.read_value()); - user.unknown = try!(packet.read_value()); - user.num_files = try!(packet.read_value()); - user.num_folders = try!(packet.read_value()); + user.average_speed = packet.read_value()?; + user.num_downloads = packet.read_value()?; + user.unknown = packet.read_value()?; + user.num_files = packet.read_value()?; + user.num_folders = packet.read_value()?; } } - let num_free_slots: usize = try!(packet.read_value()); + let num_free_slots: usize = packet.read_value()?; for i in 0..num_free_slots { if let Some(user) = self.users.get_mut(i) { - user.num_free_slots = try!(packet.read_value()); + user.num_free_slots = packet.read_value()?; } } - let num_countries: usize = try!(packet.read_value()); + let num_countries: usize = packet.read_value()?; for i in 0..num_countries { if let Some(user) = self.users.get_mut(i) { - user.country = try!(packet.read_value()); + user.country = packet.read_value()?; } } @@ -861,7 +861,7 @@ pub struct RoomLeaveResponse { impl ReadFromPacket for RoomLeaveResponse { fn read_from_packet(packet: &mut Packet) -> Result { Ok(RoomLeaveResponse { - room_name: try!(packet.read_value()), + room_name: packet.read_value()?, }) } } @@ -893,10 +893,10 @@ pub struct RoomListResponse { impl ReadFromPacket for RoomListResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let rooms = try!(Self::read_rooms(packet)); - let owned_private_rooms = try!(Self::read_rooms(packet)); - let other_private_rooms = try!(Self::read_rooms(packet)); - let operated_private_room_names = try!(packet.read_value()); + let rooms = Self::read_rooms(packet)?; + let owned_private_rooms = Self::read_rooms(packet)?; + let other_private_rooms = Self::read_rooms(packet)?; + let operated_private_room_names = packet.read_value()?; Ok(RoomListResponse { rooms, owned_private_rooms, @@ -908,17 +908,17 @@ impl ReadFromPacket for RoomListResponse { impl RoomListResponse { fn read_rooms(packet: &mut Packet) -> Result, PacketReadError> { - let num_rooms: usize = try!(packet.read_value()); + let num_rooms: usize = packet.read_value()?; let mut rooms = Vec::new(); for _ in 0..num_rooms { - let room_name = try!(packet.read_value()); + let room_name = packet.read_value()?; rooms.push((room_name, 0)); } - let num_user_counts: usize = try!(packet.read_value()); + let num_user_counts: usize = packet.read_value()?; for i in 0..num_user_counts { if let Some(&mut (_, ref mut count)) = rooms.get_mut(i) { - *count = try!(packet.read_value()); + *count = packet.read_value()?; } } @@ -1019,9 +1019,9 @@ pub struct RoomMessageResponse { impl ReadFromPacket for RoomMessageResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let room_name = try!(packet.read_value()); - let user_name = try!(packet.read_value()); - let message = try!(packet.read_value()); + let room_name = packet.read_value()?; + let user_name = packet.read_value()?; + let message = packet.read_value()?; Ok(RoomMessageResponse { room_name, user_name, @@ -1063,13 +1063,13 @@ pub struct RoomTickersResponse { impl ReadFromPacket for RoomTickersResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let room_name = try!(packet.read_value()); + let room_name = packet.read_value()?; - let num_tickers: usize = try!(packet.read_value()); + let num_tickers: usize = packet.read_value()?; let mut tickers = Vec::new(); for _ in 0..num_tickers { - let user_name = try!(packet.read_value()); - let message = try!(packet.read_value()); + let user_name = packet.read_value()?; + let message = packet.read_value()?; tickers.push((user_name, message)) } @@ -1104,19 +1104,19 @@ pub struct RoomUserJoinedResponse { impl ReadFromPacket for RoomUserJoinedResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let room_name = try!(packet.read_value()); - let user_name = try!(packet.read_value()); + let room_name = packet.read_value()?; + let user_name = packet.read_value()?; - let status = try!(packet.read_value()); + let status = packet.read_value()?; - let average_speed = try!(packet.read_value()); - let num_downloads = try!(packet.read_value()); - let unknown = try!(packet.read_value()); - let num_files = try!(packet.read_value()); - let num_folders = try!(packet.read_value()); - let num_free_slots = try!(packet.read_value()); + let average_speed = packet.read_value()?; + let num_downloads = packet.read_value()?; + let unknown = packet.read_value()?; + let num_files = packet.read_value()?; + let num_folders = packet.read_value()?; + let num_free_slots = packet.read_value()?; - let country = try!(packet.read_value()); + let country = packet.read_value()?; Ok(RoomUserJoinedResponse { room_name, @@ -1173,8 +1173,8 @@ pub struct RoomUserLeftResponse { impl ReadFromPacket for RoomUserLeftResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let room_name = try!(packet.read_value()); - let user_name = try!(packet.read_value()); + let room_name = packet.read_value()?; + let user_name = packet.read_value()?; Ok(RoomUserLeftResponse { room_name, user_name, @@ -1215,11 +1215,11 @@ pub struct UserInfoResponse { impl ReadFromPacket for UserInfoResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let user_name = try!(packet.read_value()); - let average_speed = try!(packet.read_value()); - let num_downloads = try!(packet.read_value()); - let num_files = try!(packet.read_value()); - let num_folders = try!(packet.read_value()); + let user_name = packet.read_value()?; + let average_speed = packet.read_value()?; + let num_downloads = packet.read_value()?; + let num_files = packet.read_value()?; + let num_folders = packet.read_value()?; Ok(UserInfoResponse { user_name, average_speed, @@ -1270,9 +1270,9 @@ pub struct UserStatusResponse { impl ReadFromPacket for UserStatusResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let user_name = try!(packet.read_value()); - let status = try!(packet.read_value()); - let is_privileged = try!(packet.read_value()); + let user_name = packet.read_value()?; + let status = packet.read_value()?; + let is_privileged = packet.read_value()?; Ok(UserStatusResponse { user_name, status, @@ -1313,7 +1313,7 @@ pub struct WishlistIntervalResponse { impl ReadFromPacket for WishlistIntervalResponse { fn read_from_packet(packet: &mut Packet) -> Result { - let seconds = try!(packet.read_value()); + let seconds = packet.read_value()?; Ok(WishlistIntervalResponse { seconds }) } } @@ -1342,8 +1342,8 @@ mod tests { use bytes::BytesMut; - use proto::base_codec::tests::{expect_io_error, roundtrip}; - use proto::ProtoDecoder; + use crate::proto::base_codec::tests::{expect_io_error, roundtrip}; + use crate::proto::ProtoDecoder; use super::*; diff --git a/src/proto/stream.rs b/src/proto/stream.rs index 691b720..bd33e1a 100644 --- a/src/proto/stream.rs +++ b/src/proto/stream.rs @@ -61,7 +61,7 @@ pub trait SendPacket { type Value: ReadFromPacket; type Error: error::Error; - fn send_packet(&mut self, Self::Value) -> Result<(), Self::Error>; + fn send_packet(&mut self, _: Self::Value) -> Result<(), Self::Error>; fn notify_open(&mut self) -> Result<(), Self::Error>; } @@ -97,7 +97,7 @@ impl Stream { where U: ToSocketAddrs + fmt::Debug, { - for sock_addr in try!(addr_spec.to_socket_addrs()) { + for sock_addr in addr_spec.to_socket_addrs()? { if let Ok(stream) = mio::tcp::TcpStream::connect(&sock_addr) { return Ok(Stream { parser: Parser::new(), @@ -148,7 +148,7 @@ impl Stream { None => break, }; - let option = try!(outbuf.try_write_to(&mut self.stream)); + let option = outbuf.try_write_to(&mut self.stream)?; match option { Some(_) => { if outbuf.has_remaining() { diff --git a/src/proto/transport.rs b/src/proto/transport.rs index 31f0515..262eb1e 100644 --- a/src/proto/transport.rs +++ b/src/proto/transport.rs @@ -5,8 +5,8 @@ use bytes::BytesMut; use tokio_io::codec::length_delimited::{Builder, Framed}; use tokio_io::{AsyncRead, AsyncWrite}; -use proto::peer; -use proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ServerRequest, ServerResponse}; +use crate::proto::peer; +use crate::proto::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ServerRequest, ServerResponse}; fn decode_frame<'a, T>(frame_type: &str, bytes: &'a mut BytesMut) -> io::Result where diff --git a/src/proto/user.rs b/src/proto/user.rs index ab7759e..c1b8273 100644 --- a/src/proto/user.rs +++ b/src/proto/user.rs @@ -1,6 +1,6 @@ use std::io; -use proto::{ +use crate::proto::{ MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, ReadFromPacket, WriteToPacket, }; @@ -22,7 +22,7 @@ pub enum UserStatus { impl ReadFromPacket for UserStatus { fn read_from_packet(packet: &mut Packet) -> Result { - let n: u32 = try!(packet.read_value()); + let n: u32 = packet.read_value()?; match n { STATUS_OFFLINE => Ok(UserStatus::Offline), STATUS_AWAY => Ok(UserStatus::Away), @@ -39,7 +39,7 @@ impl WriteToPacket for UserStatus { UserStatus::Away => STATUS_AWAY, UserStatus::Online => STATUS_ONLINE, }; - try!(packet.write_value(&n)); + packet.write_value(&n)?; Ok(()) } } diff --git a/src/room.rs b/src/room.rs index 951c53c..5b6aab2 100644 --- a/src/room.rs +++ b/src/room.rs @@ -3,7 +3,7 @@ use std::error; use std::fmt; use std::mem; -use proto::{server, User}; +use crate::proto::{server, User}; /// This enumeration is the list of possible membership states for a chat room. #[derive(Clone, Copy, Debug, RustcDecodable, RustcEncodable)] @@ -211,7 +211,7 @@ impl RoomMap { /// If the room is not found, or if its membership is not `NonMember`, /// returns an error. pub fn start_joining(&mut self, room_name: &str) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; match room.membership { Membership::NonMember => { @@ -236,7 +236,7 @@ impl RoomMap { members: &[User], ) -> Result<(), Error> { // First look up the room struct. - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; // Log what's happening. if let Membership::Joining = room.membership { @@ -270,7 +270,7 @@ impl RoomMap { /// If the room is not found, or if its membership status is not `Member`, /// returns an error. pub fn start_leaving(&mut self, room_name: &str) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; match room.membership { Membership::Member => { @@ -287,7 +287,7 @@ impl RoomMap { /// Records that we have now left the given room. pub fn leave(&mut self, room_name: &str) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; match room.membership { Membership::Leaving => info!("Left room {:?}", room_name), @@ -304,7 +304,7 @@ impl RoomMap { /// Saves the given message as the last one in the given room. pub fn add_message(&mut self, room_name: &str, message: Message) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; room.messages.push(message); Ok(()) } @@ -312,7 +312,7 @@ impl RoomMap { /// Inserts the given user in the given room's set of members. /// Returns an error if the room is not found. pub fn insert_member(&mut self, room_name: &str, user_name: String) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; room.members.insert(user_name); Ok(()) } @@ -320,7 +320,7 @@ impl RoomMap { /// Removes the given user from the given room's set of members. /// Returns an error if the room is not found. pub fn remove_member(&mut self, room_name: &str, user_name: &str) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; room.members.remove(user_name); Ok(()) } @@ -334,7 +334,7 @@ impl RoomMap { room_name: &str, tickers: Vec<(String, String)>, ) -> Result<(), Error> { - let room = try!(self.get_mut_strict(room_name)); + let room = self.get_mut_strict(room_name)?; room.tickers = tickers; Ok(()) } diff --git a/src/user.rs b/src/user.rs index 169e312..fdf1ae7 100644 --- a/src/user.rs +++ b/src/user.rs @@ -2,7 +2,7 @@ use std::collections; use std::error; use std::fmt; -use proto::{User, UserStatus}; +use crate::proto::{User, UserStatus}; /// The error returned when a user name was not found in the user map. #[derive(Debug)]