use async_trait::async_trait;
use bytes::{Bytes, BytesMut};
use citadel_io::tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use citadel_io::tokio::sync::Mutex;
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::net::SocketAddr;
use std::sync::Arc;
#[async_trait]
pub trait ReliableOrderedStreamToTarget: Send + Sync {
async fn send_to_peer(&self, input: &[u8]) -> std::io::Result<()>;
async fn recv(&self) -> std::io::Result<Bytes>;
}
pub trait ConnAddr {
fn local_addr(&self) -> std::io::Result<SocketAddr>;
fn peer_addr(&self) -> std::io::Result<SocketAddr>;
}
pub trait ReliableOrderedConnectionToTarget: ConnAddr + ReliableOrderedStreamToTarget {}
impl<T: ConnAddr + ReliableOrderedStreamToTarget> ReliableOrderedConnectionToTarget for T {}
#[async_trait]
pub trait ReliableOrderedStreamToTargetExt: ReliableOrderedStreamToTarget {
async fn recv_serialized<T: DeserializeOwned + Send + Sync>(&self) -> std::io::Result<T> {
let packet = &self.recv().await?;
Ok(bincode::deserialize(packet)
.map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))?)
}
async fn recv_until_serialized<T: DeserializeOwned + Send + Sync, F: Fn(&T) -> bool + Send>(
&self,
f: F,
) -> std::io::Result<T> {
loop {
match self.recv_serialized().await {
Ok(packet) => {
if (f)(&packet) {
return Ok(packet);
}
}
Err(err) => {
log::warn!(target: "citadel", "Invalid packet type ... {err:?})");
}
}
}
}
async fn send_serialized<T: Serialize + Send + Sync>(&self, t: T) -> std::io::Result<()> {
let packet = &bincode::serialize(&t)
.map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))?;
self.send_to_peer(packet).await
}
}
impl<T: ReliableOrderedStreamToTarget> ReliableOrderedStreamToTargetExt for T {}
#[cfg(not(target_family = "wasm"))]
mod native_impls {
use super::*;
#[async_trait]
impl ReliableOrderedStreamToTarget for citadel_io::tokio::net::TcpStream {
async fn send_to_peer(&self, input: &[u8]) -> std::io::Result<()> {
loop {
self.writable().await?;
match self.try_write(input) {
Ok(_) => return Ok(()),
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e);
}
}
}
}
async fn recv(&self) -> std::io::Result<Bytes> {
let mut buf = BytesMut::with_capacity(4096);
loop {
self.readable().await?;
match self.try_read_buf(&mut buf) {
Ok(0) => return Ok(Bytes::new()),
Ok(len) => return Ok(buf.split_to(len).freeze()),
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e);
}
}
}
}
}
impl ConnAddr for citadel_io::tokio::net::TcpStream {
fn local_addr(&self) -> std::io::Result<SocketAddr> {
citadel_io::tokio::net::TcpStream::local_addr(self)
}
fn peer_addr(&self) -> std::io::Result<SocketAddr> {
citadel_io::tokio::net::TcpStream::peer_addr(self)
}
}
}
#[async_trait]
impl<T: ReliableOrderedStreamToTarget + ?Sized> ReliableOrderedStreamToTarget for Arc<T> {
async fn send_to_peer(&self, input: &[u8]) -> std::io::Result<()> {
T::send_to_peer(self, input).await
}
async fn recv(&self) -> std::io::Result<Bytes> {
T::recv(self).await
}
}
pub struct StreamWrapper<T> {
inner: Mutex<T>,
}
impl<T: AsyncRead + AsyncWrite + Send + Unpin> From<T> for StreamWrapper<T> {
fn from(this: T) -> Self {
StreamWrapper {
inner: Mutex::new(this),
}
}
}
#[async_trait]
impl<T: AsyncRead + AsyncWrite + Send + Unpin> ReliableOrderedStreamToTarget for StreamWrapper<T> {
async fn send_to_peer(&self, input: &[u8]) -> std::io::Result<()> {
self.inner.lock().await.write_all(input).await
}
async fn recv(&self) -> std::io::Result<Bytes> {
let mut buf = BytesMut::with_capacity(4096);
self.inner
.lock()
.await
.read_buf(&mut buf)
.await
.map(|r| buf.split_to(r).freeze())
}
}
#[cfg(not(target_family = "wasm"))]
pub mod simulator {
use crate::reliable_conn::{
ConnAddr, ReliableOrderedConnectionToTarget, ReliableOrderedStreamToTarget,
};
use async_trait::async_trait;
use bytes::Bytes;
use citadel_io::tokio::sync::mpsc::UnboundedSender;
use rand::Rng;
use std::net::SocketAddr;
use std::sync::Arc;
pub struct NetworkConnSimulator<T> {
inner: Arc<T>,
fwd: UnboundedSender<Vec<u8>>,
}
impl<T: ReliableOrderedConnectionToTarget + 'static> NetworkConnSimulator<T> {
#[cfg_attr(target_family = "wasm", allow(dead_code))]
pub(crate) fn new(min_lag: usize, inner: T) -> Self {
let inner = Arc::new(inner);
let inner_fwd = inner.clone();
let (fwd, mut rx) = citadel_io::tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
citadel_io::spawn(async move {
while let Some(packet) = rx.recv().await {
if min_lag != 0 {
let rnd = {
let mut rng = rand::thread_rng();
let max = 2 * min_lag;
rng.gen_range(min_lag..max) };
citadel_io::time::sleep(std::time::Duration::from_millis(rnd as u64)).await;
}
inner_fwd.send_to_peer(&packet).await.unwrap();
}
});
Self { inner, fwd }
}
}
#[async_trait]
impl<T: ReliableOrderedStreamToTarget + 'static> ReliableOrderedStreamToTarget
for NetworkConnSimulator<T>
{
async fn send_to_peer(&self, input: &[u8]) -> std::io::Result<()> {
let heap = input.to_vec();
self.fwd
.send(heap)
.map_err(|err| std::io::Error::new(std::io::ErrorKind::BrokenPipe, err.to_string()))
}
async fn recv(&self) -> std::io::Result<Bytes> {
self.inner.recv().await
}
}
impl<T: ReliableOrderedConnectionToTarget + 'static> ConnAddr for NetworkConnSimulator<T> {
fn local_addr(&self) -> std::io::Result<SocketAddr> {
self.inner.local_addr()
}
fn peer_addr(&self) -> std::io::Result<SocketAddr> {
self.inner.peer_addr()
}
}
}