mirror of
https://github.com/tokio-rs/tokio.git
synced 2025-09-25 12:00:35 +00:00
a0557840eb
This refactors I/O registration in a few ways: - Cleans up the cached readiness in `PollEvented`. This cache used to be helpful when readiness was a linked list of `*mut Node`s in `Registration`. Previous refactors have turned `Registration` into just an `AtomicUsize` holding the current readiness, so the cache is just extra work and complexity. Gone. - Polling the `Registration` for readiness now gives a `ReadyEvent`, which includes the driver tick. This event must be passed back into `clear_readiness`, so that the readiness is only cleared from `Registration` if the tick hasn't changed. Previously, it was possible to clear the readiness even though another thread had *just* polled the driver and found the socket ready again. - Registration now also contains an `async fn readiness`, which stores wakers in an instrusive linked list. This allows an unbounded number of tasks to register for readiness (previously, only 1 per direction (read and write)). By using the intrusive linked list, there is no concern of leaking the storage of the wakers, since they are stored inside the `async fn` and released when the future is dropped. - Registration retains a `poll_readiness(Direction)` method, to support `AsyncRead` and `AsyncWrite`. They aren't able to use `async fn`s, and so there are 2 reserved slots for those methods. - IO types where it makes sense to have multiple tasks waiting on them now take advantage of this new `async fn readiness`, such as `UdpSocket` and `UnixDatagram`. Additionally, this makes the `io-driver` "feature" internal-only (no longer documented, not part of public API), and adds a second internal-only feature, `io-readiness`, to group together linked list part of registration that is only used by some of the IO types. After a bit of discussion, changing stream-based transports (like `TcpStream`) to have `async fn read(&self)` is punted, since that is likely too easy of a footgun to activate. Refs: #2779, #2728
105 lines
2.8 KiB
Rust
105 lines
2.8 KiB
Rust
/*
|
|
#![warn(rust_2018_idioms)]
|
|
|
|
use tokio::{net::UdpSocket, stream::StreamExt};
|
|
use tokio_util::codec::{Decoder, Encoder, LinesCodec};
|
|
use tokio_util::udp::UdpFramed;
|
|
|
|
use bytes::{BufMut, BytesMut};
|
|
use futures::future::try_join;
|
|
use futures::future::FutureExt;
|
|
use futures::sink::SinkExt;
|
|
use std::io;
|
|
|
|
#[cfg_attr(any(target_os = "macos", target_os = "ios"), allow(unused_assignments))]
|
|
#[tokio::test]
|
|
async fn send_framed_byte_codec() -> std::io::Result<()> {
|
|
let mut a_soc = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let mut b_soc = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
|
let a_addr = a_soc.local_addr()?;
|
|
let b_addr = b_soc.local_addr()?;
|
|
|
|
// test sending & receiving bytes
|
|
{
|
|
let mut a = UdpFramed::new(a_soc, ByteCodec);
|
|
let mut b = UdpFramed::new(b_soc, ByteCodec);
|
|
|
|
let msg = b"4567";
|
|
|
|
let send = a.send((msg, b_addr));
|
|
let recv = b.next().map(|e| e.unwrap());
|
|
let (_, received) = try_join(send, recv).await.unwrap();
|
|
|
|
let (data, addr) = received;
|
|
assert_eq!(msg, &*data);
|
|
assert_eq!(a_addr, addr);
|
|
|
|
a_soc = a.into_inner();
|
|
b_soc = b.into_inner();
|
|
}
|
|
|
|
#[cfg(not(any(target_os = "macos", target_os = "ios")))]
|
|
// test sending & receiving an empty message
|
|
{
|
|
let mut a = UdpFramed::new(a_soc, ByteCodec);
|
|
let mut b = UdpFramed::new(b_soc, ByteCodec);
|
|
|
|
let msg = b"";
|
|
|
|
let send = a.send((msg, b_addr));
|
|
let recv = b.next().map(|e| e.unwrap());
|
|
let (_, received) = try_join(send, recv).await.unwrap();
|
|
|
|
let (data, addr) = received;
|
|
assert_eq!(msg, &*data);
|
|
assert_eq!(a_addr, addr);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
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<&[u8]> for ByteCodec {
|
|
type Error = io::Error;
|
|
|
|
fn encode(&mut self, data: &[u8], buf: &mut BytesMut) -> Result<(), io::Error> {
|
|
buf.reserve(data.len());
|
|
buf.put_slice(data);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_framed_lines_codec() -> std::io::Result<()> {
|
|
let a_soc = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let b_soc = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
|
let a_addr = a_soc.local_addr()?;
|
|
let b_addr = b_soc.local_addr()?;
|
|
|
|
let mut a = UdpFramed::new(a_soc, ByteCodec);
|
|
let mut b = UdpFramed::new(b_soc, LinesCodec::new());
|
|
|
|
let msg = b"1\r\n2\r\n3\r\n".to_vec();
|
|
a.send((&msg, b_addr)).await?;
|
|
|
|
assert_eq!(b.next().await.unwrap().unwrap(), ("1".to_string(), a_addr));
|
|
assert_eq!(b.next().await.unwrap().unwrap(), ("2".to_string(), a_addr));
|
|
assert_eq!(b.next().await.unwrap().unwrap(), ("3".to_string(), a_addr));
|
|
|
|
Ok(())
|
|
}
|
|
*/
|