mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-26 00:00:16 +02:00
Move tokio::net module into tokio tcp/udp crates (#224)
This commit is contained in:
Sam Rijs
@@ -1,49 +0,0 @@
|
||||
extern crate futures;
|
||||
extern crate tokio;
|
||||
extern crate tokio_io;
|
||||
|
||||
use std::net::TcpStream;
|
||||
use std::thread;
|
||||
use std::io::{Write, Read};
|
||||
|
||||
use futures::Future;
|
||||
use futures::stream::Stream;
|
||||
use tokio_io::io::read_to_end;
|
||||
use tokio::net::TcpListener;
|
||||
|
||||
macro_rules! t {
|
||||
($e:expr) => (match $e {
|
||||
Ok(e) => e,
|
||||
Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_clients() {
|
||||
let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
|
||||
let addr = t!(srv.local_addr());
|
||||
|
||||
let t = thread::spawn(move || {
|
||||
let mut s1 = TcpStream::connect(&addr).unwrap();
|
||||
s1.write_all(b"foo ").unwrap();
|
||||
let mut s2 = TcpStream::connect(&addr).unwrap();
|
||||
s2.write_all(b"bar ").unwrap();
|
||||
let mut s3 = TcpStream::connect(&addr).unwrap();
|
||||
s3.write_all(b"baz").unwrap();
|
||||
});
|
||||
|
||||
let clients = srv.incoming().take(3);
|
||||
let copied = clients.collect().and_then(|clients| {
|
||||
let mut clients = clients.into_iter();
|
||||
let a = clients.next().unwrap();
|
||||
let b = clients.next().unwrap();
|
||||
let c = clients.next().unwrap();
|
||||
|
||||
read_to_end(a.chain(b).chain(c), Vec::new())
|
||||
});
|
||||
|
||||
let (_, data) = t!(copied.wait());
|
||||
t.join().unwrap();
|
||||
|
||||
assert_eq!(data, b"foo bar baz");
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
extern crate env_logger;
|
||||
extern crate futures;
|
||||
extern crate tokio;
|
||||
extern crate tokio_io;
|
||||
|
||||
use std::io::{Read, Write};
|
||||
use std::net::TcpStream;
|
||||
use std::thread;
|
||||
|
||||
use futures::Future;
|
||||
use futures::stream::Stream;
|
||||
use tokio::net::TcpListener;
|
||||
use tokio_io::AsyncRead;
|
||||
use tokio_io::io::copy;
|
||||
|
||||
macro_rules! t {
|
||||
($e:expr) => (match $e {
|
||||
Ok(e) => e,
|
||||
Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn echo_server() {
|
||||
drop(env_logger::init());
|
||||
|
||||
let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
|
||||
let addr = t!(srv.local_addr());
|
||||
|
||||
let msg = "foo bar baz";
|
||||
let t = thread::spawn(move || {
|
||||
let mut s = TcpStream::connect(&addr).unwrap();
|
||||
|
||||
for _i in 0..1024 {
|
||||
assert_eq!(t!(s.write(msg.as_bytes())), msg.len());
|
||||
let mut buf = [0; 1024];
|
||||
assert_eq!(t!(s.read(&mut buf)), msg.len());
|
||||
assert_eq!(&buf[..msg.len()], msg.as_bytes());
|
||||
}
|
||||
});
|
||||
|
||||
let clients = srv.incoming();
|
||||
let client = clients.into_future().map(|e| e.0.unwrap()).map_err(|e| e.0);
|
||||
let halves = client.map(|s| s.split());
|
||||
let copied = halves.and_then(|(a, b)| copy(a, b));
|
||||
|
||||
let (amt, _, _) = t!(copied.wait());
|
||||
t.join().unwrap();
|
||||
|
||||
assert_eq!(amt, msg.len() as u64 * 1024);
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
extern crate futures;
|
||||
extern crate tokio;
|
||||
extern crate tokio_io;
|
||||
|
||||
use std::net::TcpStream;
|
||||
use std::thread;
|
||||
use std::io::{Write, Read};
|
||||
|
||||
use futures::Future;
|
||||
use futures::stream::Stream;
|
||||
use tokio_io::io::read_to_end;
|
||||
use tokio::net::TcpListener;
|
||||
|
||||
macro_rules! t {
|
||||
($e:expr) => (match $e {
|
||||
Ok(e) => e,
|
||||
Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limit() {
|
||||
let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
|
||||
let addr = t!(srv.local_addr());
|
||||
|
||||
let t = thread::spawn(move || {
|
||||
let mut s1 = TcpStream::connect(&addr).unwrap();
|
||||
s1.write_all(b"foo bar baz").unwrap();
|
||||
});
|
||||
|
||||
let clients = srv.incoming().take(1);
|
||||
let copied = clients.collect().and_then(|clients| {
|
||||
let mut clients = clients.into_iter();
|
||||
let a = clients.next().unwrap();
|
||||
|
||||
read_to_end(a.take(4), Vec::new())
|
||||
});
|
||||
|
||||
let (_, data) = t!(copied.wait());
|
||||
t.join().unwrap();
|
||||
|
||||
assert_eq!(data, b"foo ");
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
extern crate env_logger;
|
||||
extern crate futures;
|
||||
extern crate tokio;
|
||||
extern crate tokio_io;
|
||||
|
||||
use std::io::{Read, Write};
|
||||
use std::net::TcpStream;
|
||||
use std::thread;
|
||||
|
||||
use futures::Future;
|
||||
use futures::stream::Stream;
|
||||
use tokio_io::io::copy;
|
||||
use tokio_io::AsyncRead;
|
||||
use tokio::net::TcpListener;
|
||||
|
||||
macro_rules! t {
|
||||
($e:expr) => (match $e {
|
||||
Ok(e) => e,
|
||||
Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn echo_server() {
|
||||
drop(env_logger::init());
|
||||
|
||||
let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
|
||||
let addr = t!(srv.local_addr());
|
||||
|
||||
let t = thread::spawn(move || {
|
||||
let mut s1 = t!(TcpStream::connect(&addr));
|
||||
let mut s2 = t!(TcpStream::connect(&addr));
|
||||
|
||||
let msg = b"foo";
|
||||
assert_eq!(t!(s1.write(msg)), msg.len());
|
||||
assert_eq!(t!(s2.write(msg)), msg.len());
|
||||
let mut buf = [0; 1024];
|
||||
assert_eq!(t!(s1.read(&mut buf)), msg.len());
|
||||
assert_eq!(&buf[..msg.len()], msg);
|
||||
assert_eq!(t!(s2.read(&mut buf)), msg.len());
|
||||
assert_eq!(&buf[..msg.len()], msg);
|
||||
});
|
||||
|
||||
let future = srv.incoming()
|
||||
.map(|s| s.split())
|
||||
.map(|(a, b)| copy(a, b).map(|_| ()))
|
||||
.buffered(10)
|
||||
.take(2)
|
||||
.collect();
|
||||
|
||||
t!(future.wait());
|
||||
|
||||
t.join().unwrap();
|
||||
}
|
||||
-130
@@ -1,130 +0,0 @@
|
||||
extern crate env_logger;
|
||||
extern crate tokio;
|
||||
extern crate mio;
|
||||
extern crate futures;
|
||||
|
||||
use std::{net, thread};
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
use tokio::net::{TcpListener, TcpStream};
|
||||
use tokio::prelude::*;
|
||||
|
||||
|
||||
macro_rules! t {
|
||||
($e:expr) => (match $e {
|
||||
Ok(e) => e,
|
||||
Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connect() {
|
||||
drop(env_logger::init());
|
||||
let srv = t!(net::TcpListener::bind("127.0.0.1:0"));
|
||||
let addr = t!(srv.local_addr());
|
||||
let t = thread::spawn(move || {
|
||||
t!(srv.accept()).0
|
||||
});
|
||||
|
||||
let stream = TcpStream::connect(&addr);
|
||||
let mine = t!(stream.wait());
|
||||
let theirs = t.join().unwrap();
|
||||
|
||||
assert_eq!(t!(mine.local_addr()), t!(theirs.peer_addr()));
|
||||
assert_eq!(t!(theirs.local_addr()), t!(mine.peer_addr()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accept() {
|
||||
drop(env_logger::init());
|
||||
let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
|
||||
let addr = t!(srv.local_addr());
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let client = srv.incoming().map(move |t| {
|
||||
tx.send(()).unwrap();
|
||||
t
|
||||
}).into_future().map_err(|e| e.0);
|
||||
assert!(rx.try_recv().is_err());
|
||||
let t = thread::spawn(move || {
|
||||
net::TcpStream::connect(&addr).unwrap()
|
||||
});
|
||||
|
||||
let (mine, _remaining) = t!(client.wait());
|
||||
let mine = mine.unwrap();
|
||||
let theirs = t.join().unwrap();
|
||||
|
||||
assert_eq!(t!(mine.local_addr()), t!(theirs.peer_addr()));
|
||||
assert_eq!(t!(theirs.local_addr()), t!(mine.peer_addr()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accept2() {
|
||||
drop(env_logger::init());
|
||||
let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
|
||||
let addr = t!(srv.local_addr());
|
||||
|
||||
let t = thread::spawn(move || {
|
||||
net::TcpStream::connect(&addr).unwrap()
|
||||
});
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let client = srv.incoming().map(move |t| {
|
||||
tx.send(()).unwrap();
|
||||
t
|
||||
}).into_future().map_err(|e| e.0);
|
||||
assert!(rx.try_recv().is_err());
|
||||
|
||||
let (mine, _remaining) = t!(client.wait());
|
||||
mine.unwrap();
|
||||
t.join().unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
mod unix {
|
||||
use tokio::net::TcpStream;
|
||||
use tokio::prelude::*;
|
||||
|
||||
use env_logger;
|
||||
use futures::future;
|
||||
use mio::unix::UnixReady;
|
||||
|
||||
use std::{net, thread};
|
||||
use std::time::Duration;
|
||||
|
||||
#[test]
|
||||
fn poll_hup() {
|
||||
drop(env_logger::init());
|
||||
|
||||
let srv = t!(net::TcpListener::bind("127.0.0.1:0"));
|
||||
let addr = t!(srv.local_addr());
|
||||
let t = thread::spawn(move || {
|
||||
let mut client = t!(srv.accept()).0;
|
||||
client.write(b"hello world").unwrap();
|
||||
thread::sleep(Duration::from_millis(200));
|
||||
});
|
||||
|
||||
let mut stream = t!(TcpStream::connect(&addr).wait());
|
||||
|
||||
// Poll for HUP before reading.
|
||||
future::poll_fn(|| {
|
||||
stream.poll_read_ready(UnixReady::hup().into())
|
||||
}).wait().unwrap();
|
||||
|
||||
// Same for write half
|
||||
future::poll_fn(|| {
|
||||
stream.poll_write_ready()
|
||||
}).wait().unwrap();
|
||||
|
||||
let mut buf = vec![0; 11];
|
||||
|
||||
// Read the data
|
||||
future::poll_fn(|| {
|
||||
stream.poll_read(&mut buf)
|
||||
}).wait().unwrap();
|
||||
|
||||
assert_eq!(b"hello world", &buf[..]);
|
||||
|
||||
t.join().unwrap();
|
||||
}
|
||||
}
|
||||
-261
@@ -1,261 +0,0 @@
|
||||
#![allow(deprecated)]
|
||||
|
||||
extern crate futures;
|
||||
extern crate tokio;
|
||||
#[macro_use]
|
||||
extern crate tokio_io;
|
||||
extern crate bytes;
|
||||
extern crate env_logger;
|
||||
|
||||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use futures::{Future, Poll, Stream, Sink};
|
||||
|
||||
use tokio::net::{UdpSocket, UdpFramed};
|
||||
use tokio_io::codec::{Encoder, Decoder};
|
||||
use bytes::{BytesMut, BufMut};
|
||||
|
||||
macro_rules! t {
|
||||
($e:expr) => (match $e {
|
||||
Ok(e) => e,
|
||||
Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
|
||||
})
|
||||
}
|
||||
|
||||
fn send_messages<S: SendFn + Clone, R: RecvFn + Clone>(send: S, recv: R) {
|
||||
let mut a = t!(UdpSocket::bind(&([127, 0, 0, 1], 0).into()));
|
||||
let mut b = t!(UdpSocket::bind(&([127, 0, 0, 1], 0).into()));
|
||||
let a_addr = t!(a.local_addr());
|
||||
let b_addr = t!(b.local_addr());
|
||||
|
||||
{
|
||||
let send = SendMessage::new(a, send.clone(), b_addr, b"1234");
|
||||
let recv = RecvMessage::new(b, recv.clone(), a_addr, b"1234");
|
||||
let (sendt, received) = t!(send.join(recv).wait());
|
||||
a = sendt;
|
||||
b = received;
|
||||
}
|
||||
|
||||
{
|
||||
let send = SendMessage::new(a, send, b_addr, b"");
|
||||
let recv = RecvMessage::new(b, recv, a_addr, b"");
|
||||
t!(send.join(recv).wait());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_to_and_recv_from() {
|
||||
send_messages(SendTo {}, RecvFrom {});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_and_recv() {
|
||||
send_messages(Send {}, Recv {});
|
||||
}
|
||||
|
||||
trait SendFn {
|
||||
fn send(&self, &mut UdpSocket, &[u8], &SocketAddr) -> Result<usize, io::Error>;
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct SendTo {}
|
||||
|
||||
impl SendFn for SendTo {
|
||||
fn send(&self, socket: &mut UdpSocket, buf: &[u8], addr: &SocketAddr) -> Result<usize, io::Error> {
|
||||
socket.send_to(buf, addr)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct Send {}
|
||||
|
||||
impl SendFn for Send {
|
||||
fn send(&self, socket: &mut UdpSocket, buf: &[u8], addr: &SocketAddr) -> Result<usize, io::Error> {
|
||||
socket.connect(addr).expect("could not connect");
|
||||
socket.send(buf)
|
||||
}
|
||||
}
|
||||
|
||||
struct SendMessage<S> {
|
||||
socket: Option<UdpSocket>,
|
||||
send: S,
|
||||
addr: SocketAddr,
|
||||
data: &'static [u8],
|
||||
}
|
||||
|
||||
impl<S: SendFn> SendMessage<S> {
|
||||
fn new(socket: UdpSocket, send: S, addr: SocketAddr, data: &'static [u8]) -> SendMessage<S> {
|
||||
SendMessage {
|
||||
socket: Some(socket),
|
||||
send: send,
|
||||
addr: addr,
|
||||
data: data,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: SendFn> Future for SendMessage<S> {
|
||||
type Item = UdpSocket;
|
||||
type Error = io::Error;
|
||||
|
||||
fn poll(&mut self) -> Poll<UdpSocket, io::Error> {
|
||||
let n = try_nb!(self.send.send(self.socket.as_mut().unwrap(), &self.data[..], &self.addr));
|
||||
|
||||
assert_eq!(n, self.data.len());
|
||||
|
||||
Ok(self.socket.take().unwrap().into())
|
||||
}
|
||||
}
|
||||
|
||||
trait RecvFn {
|
||||
fn recv(&self, &mut UdpSocket, &mut [u8], &SocketAddr) -> Result<usize, io::Error>;
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct RecvFrom {}
|
||||
|
||||
impl RecvFn for RecvFrom {
|
||||
fn recv(&self, socket: &mut UdpSocket, buf: &mut [u8],
|
||||
expected_addr: &SocketAddr) -> Result<usize, io::Error> {
|
||||
socket.recv_from(buf).map(|(s, addr)| {
|
||||
assert_eq!(addr, *expected_addr);
|
||||
s
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct Recv {}
|
||||
|
||||
impl RecvFn for Recv {
|
||||
fn recv(&self, socket: &mut UdpSocket, buf: &mut [u8], _: &SocketAddr) -> Result<usize, io::Error> {
|
||||
socket.recv(buf)
|
||||
}
|
||||
}
|
||||
|
||||
struct RecvMessage<R> {
|
||||
socket: Option<UdpSocket>,
|
||||
recv: R,
|
||||
expected_addr: SocketAddr,
|
||||
expected_data: &'static [u8],
|
||||
}
|
||||
|
||||
impl<R: RecvFn> RecvMessage<R> {
|
||||
fn new(socket: UdpSocket, recv: R, expected_addr: SocketAddr,
|
||||
expected_data: &'static [u8]) -> RecvMessage<R> {
|
||||
RecvMessage {
|
||||
socket: Some(socket),
|
||||
recv: recv,
|
||||
expected_addr: expected_addr,
|
||||
expected_data: expected_data,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: RecvFn> Future for RecvMessage<R> {
|
||||
type Item = UdpSocket;
|
||||
type Error = io::Error;
|
||||
|
||||
fn poll(&mut self) -> Poll<UdpSocket, io::Error> {
|
||||
let mut buf = vec![0u8; 10 + self.expected_data.len() * 10];
|
||||
let n = try_nb!(self.recv.recv(&mut self.socket.as_mut().unwrap(), &mut buf[..],
|
||||
&self.expected_addr));
|
||||
|
||||
assert_eq!(n, self.expected_data.len());
|
||||
assert_eq!(&buf[..self.expected_data.len()], &self.expected_data[..]);
|
||||
|
||||
Ok(self.socket.take().unwrap().into())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_dgrams() {
|
||||
let mut a = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
|
||||
let mut b = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
|
||||
let mut buf = [0u8; 50];
|
||||
let b_addr = t!(b.local_addr());
|
||||
|
||||
{
|
||||
let send = a.send_dgram(&b"4321"[..], &b_addr);
|
||||
let recv = b.recv_dgram(&mut buf[..]);
|
||||
let (sendt, received) = t!(send.join(recv).wait());
|
||||
assert_eq!(received.2, 4);
|
||||
assert_eq!(&received.1[..4], b"4321");
|
||||
a = sendt.0;
|
||||
b = received.0;
|
||||
}
|
||||
|
||||
{
|
||||
let send = a.send_dgram(&b""[..], &b_addr);
|
||||
let recv = b.recv_dgram(&mut buf[..]);
|
||||
let received = t!(send.join(recv).wait()).1;
|
||||
assert_eq!(received.2, 0);
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ByteCodec;
|
||||
|
||||
impl Decoder for ByteCodec {
|
||||
type Item = Vec<u8>;
|
||||
type Error = io::Error;
|
||||
|
||||
fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Vec<u8>>, io::Error> {
|
||||
let len = buf.len();
|
||||
Ok(Some(buf.split_to(len).to_vec()))
|
||||
}
|
||||
}
|
||||
|
||||
impl Encoder for ByteCodec {
|
||||
type Item = Vec<u8>;
|
||||
type Error = io::Error;
|
||||
|
||||
fn encode(&mut self, data: Vec<u8>, buf: &mut BytesMut) -> Result<(), io::Error> {
|
||||
buf.reserve(data.len());
|
||||
buf.put(data);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_framed() {
|
||||
drop(env_logger::init());
|
||||
|
||||
let mut a_soc = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
|
||||
let mut b_soc = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
|
||||
let a_addr = t!(a_soc.local_addr());
|
||||
let b_addr = t!(b_soc.local_addr());
|
||||
|
||||
{
|
||||
let a = UdpFramed::new(a_soc, ByteCodec);
|
||||
let b = UdpFramed::new(b_soc, ByteCodec);
|
||||
|
||||
let msg = b"4567".to_vec();
|
||||
|
||||
let send = a.send((msg.clone(), b_addr));
|
||||
let recv = b.into_future().map_err(|e| e.0);
|
||||
let (sendt, received) = t!(send.join(recv).wait());
|
||||
|
||||
let (data, addr) = received.0.unwrap();
|
||||
assert_eq!(msg, data);
|
||||
assert_eq!(a_addr, addr);
|
||||
|
||||
a_soc = sendt.into_inner();
|
||||
b_soc = received.1.into_inner();
|
||||
}
|
||||
|
||||
{
|
||||
let a = UdpFramed::new(a_soc, ByteCodec);
|
||||
let b = UdpFramed::new(b_soc, ByteCodec);
|
||||
|
||||
let msg = b"".to_vec();
|
||||
|
||||
let send = a.send((msg.clone(), b_addr));
|
||||
let recv = b.into_future().map_err(|e| e.0);
|
||||
let received = t!(send.join(recv).wait()).1;
|
||||
|
||||
let (data, addr) = received.0.unwrap();
|
||||
assert_eq!(msg, data);
|
||||
assert_eq!(a_addr, addr);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user