use std::io;
use std::io::{ MemWriter, Acceptor, Listener, TcpStream, IoResult, IoError, EndOfFile };
use std::io::net::tcp::{ TcpAcceptor, TcpListener };
+use std::thread::Thread;
use packet;
use packet::{ Packet, ReadingResult, PacketType };
use packet::PacketType::{ Command, Answer, Error };
+use utils::from_elem;
// Default timeout when waiting data on a stream (for instance: 'TcpStream::read').
static DEFAULT_TIMEOUT: Option<u64> = Some(500); // [ms].
acceptor: acceptor.clone()
};
- spawn(proc() {
+ Thread::spawn(move || {
loop {
for stream in acceptor.incoming() {
match stream {
- Ok(stream) => spawn(proc() {
- Server::handle_client(EndPoint::new(stream, variant));
- }),
+ Ok(stream) =>
+ Thread::spawn(move || {
+ Server::handle_client(EndPoint::new(stream, variant));
+ }).detach(),
_ => return
}
}
}
- });
+ }).detach();
Ok(server)
}
let mut m = MemWriter::new();
match (Packet { t: Command(Packet::random_packet_data(&[42])), timestamp: timestamp }).write(&mut m, packet::Variant::Weak) {
Err(_) => vec!(),
- _ => m.unwrap()
+ _ => m.into_inner()
}
}
// 5)
|client: &mut Client| -> bool {
println!("Sending a packet with too small data...");
- let command = Command(Packet::new_packet_data(0, Vec::from_elem(6, 0x00)));
+ let command = Command(Packet::new_packet_data(0, from_elem(6, 0x00)));
match client.end_point.send_with_result(command) {
Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
other => {
// 6)
|client: &mut Client| -> bool {
println!("Sending a packet with too large data...");
- let command = Command(Packet::new_packet_data(0, Vec::from_elem(40, 0x00)));
+ let command = Command(Packet::new_packet_data(0, from_elem(40, 0x00)));
match client.end_point.send_with_result(command) {
Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
other => {
let mut m = MemWriter::new();
let raw_packet = match (Packet { t: Command(Packet::random_packet_data(&[42])), timestamp: client.end_point.current_timestamp }).write_with_padding_fun(&mut m, packet::Variant::Weak, |_, _| -> u8 { 0 }) {
Err(_) => vec!(),
- _ => m.unwrap()
+ _ => m.into_inner()
};
match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
let mut nb_test_passed = 0;
for (i, test) in range(1, tests.len()+1).zip(tests.iter_mut()) {
- println!("===== Test case #{}:", i)
+ println!("===== Test case #{}:", i);
if execute(test) {
nb_test_passed += 1;
println!("===== Test passed");
fn read(&mut self) -> ReadingResult {
fn send_error(ep: &mut EndPoint, error_type: packet::ErrorType) {
- match ep.send(Error(error_type)) {
- Err(e) => println!("Unable to send error packet: {}", e),
- Ok(_) => ()
- };
+ if let Err(e) = ep.send(Error(error_type)) {
+ println!("Unable to send error packet: {}", e)
+ }
};
self.socket.set_timeout(DEFAULT_TIMEOUT);