mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-25 00:00:18 +02:00
Carl Lerche
8a7e57786a
In an effort to reach API stability, the `tokio` crate is shedding its
_public_ dependencies on crates that are either a) do not provide a
stable (1.0+) release with longevity guarantees or b) match the `tokio`
release cadence. Of course, implementing `std` traits fits the
requirements.
The on exception, for now, is the `Stream` trait found in `futures_core`.
It is expected that this trait will not change much and be moved into `std.
Since Tokio is not yet going reaching 1.0, I feel that it is acceptable to maintain
a dependency on this trait given how foundational it is.
Since the `Stream` implementation is optional, types that are logically
streams provide `async fn next_*` functions to obtain the next value.
Avoiding the `next()` name prevents fn conflicts with `StreamExt::next()`.
Additionally, some misc cleanup is also done:
- `tokio::io::io` -> `tokio::io::util`.
- `delay` -> `delay_until`.
- `Timeout::new` -> `timeout(...)`.
- `signal::ctrl_c()` returns a future instead of a stream.
- `{tcp,unix}::Incoming` is removed (due to lack of `Stream` trait).
- `time::Throttle` is removed (due to lack of `Stream` trait).
- Fix: `mpsc::UnboundedSender::send(&self)` (no more conflict with `Sink` fns).
80 lines
2.0 KiB
Rust
80 lines
2.0 KiB
Rust
use tokio::net::UdpSocket;
|
|
use tokio_util::codec::{Decoder, Encoder};
|
|
use tokio_util::udp::UdpFramed;
|
|
|
|
use bytes::{BufMut, BytesMut};
|
|
use futures::future::try_join;
|
|
use futures::future::FutureExt;
|
|
use futures::sink::SinkExt;
|
|
use futures::stream::StreamExt;
|
|
use std::io;
|
|
|
|
#[tokio::test]
|
|
async fn send_framed() -> 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".to_vec();
|
|
|
|
let send = a.send((msg.clone(), 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();
|
|
}
|
|
|
|
// 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"".to_vec();
|
|
|
|
let send = a.send((msg.clone(), 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 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(())
|
|
}
|
|
}
|