use std::{
fmt::{Debug, Display},
marker::PhantomData,
pin::Pin,
task::{Context, Poll},
};
use futures::{stream::FusedStream, Sink, SinkExt, Stream, StreamExt};
use native_tls::TlsConnector;
use pin_project::pin_project;
use serde::Serialize;
use tokio::net::TcpStream;
use tokio_tungstenite::{
connect_async_tls_with_config, Connector, MaybeTlsStream, WebSocketStream,
};
use tungstenite::Message;
use crate::{Decode, Encode};
#[derive(Debug)]
pub enum Error<SerializationError, DeserializationError> {
SerializationError(SerializationError),
DeserializationError(DeserializationError),
TlsConnectorError(native_tls::Error),
TungsteniteError(tungstenite::Error),
}
impl<SerializationError, DeserializationError> Display
for Error<SerializationError, DeserializationError>
where
SerializationError: Display,
DeserializationError: Display,
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::SerializationError(error) => write!(f, "failed to serialize message: {error}"),
Error::DeserializationError(error) => {
write!(f, "failed to deserialize message: {error}")
}
Error::TlsConnectorError(error) => {
write!(f, "failed to create TLS connector: {error}")
}
Error::TungsteniteError(error) => write!(f, "tungstenite error occurred: {error}"),
}
}
}
impl<SerializationError, DeserializationError> std::error::Error
for Error<SerializationError, DeserializationError>
where
SerializationError: Debug + Display,
DeserializationError: Debug + Display,
{
}
#[pin_project]
pub struct WebSocketTransport<T, Codec, Incoming, Outgoing>
where
T: Sink<Message, Error = tungstenite::Error>
+ Stream<Item = Result<Message, tungstenite::Error>>
+ Unpin,
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
#[pin]
inner: T,
codec: Codec,
terminated: bool,
#[cfg(feature = "logging")]
logger: dnet_base::Logger,
_incoming: PhantomData<Incoming>,
_outgoing: PhantomData<Outgoing>,
}
impl<T, Codec, Incoming, Outgoing> WebSocketTransport<T, Codec, Incoming, Outgoing>
where
T: Sink<Message, Error = tungstenite::Error>
+ Stream<Item = Result<Message, tungstenite::Error>>
+ Unpin,
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
pub fn new(web_socket: T, codec: Codec) -> Self {
WebSocketTransport {
inner: web_socket,
codec,
terminated: false,
#[cfg(feature = "logging")]
logger: dnet_base::Logger::new::<Self>(),
_incoming: PhantomData,
_outgoing: PhantomData,
}
}
#[allow(clippy::type_complexity)]
fn send_inner(
&mut self,
message: Outgoing,
message_length: &mut usize,
) -> Result<(), crate::Error<Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>> {
let mut buffer = vec![];
self.codec
.encode(&mut buffer, &message)
.map_err(Error::SerializationError)
.map_err(crate::Error::Other)?;
*message_length = buffer.len();
let message = Message::binary(buffer);
self.inner.start_send_unpin(message).map_err(map_error)
}
}
impl<Codec, Incoming, Outgoing>
WebSocketTransport<WebSocketStream<MaybeTlsStream<TcpStream>>, Codec, Incoming, Outgoing>
where
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
pub async fn new_with_address(
url: &str,
codec: Codec,
) -> Result<Self, Error<<Codec as Encode>::Error, <Codec as Decode>::Error>> {
let connector = TlsConnector::new().map_err(Error::TlsConnectorError)?;
let connector = Connector::NativeTls(connector);
let (web_socket, _) = connect_async_tls_with_config(url, None, false, Some(connector))
.await
.map_err(Error::TungsteniteError)?;
Ok(WebSocketTransport::new(web_socket, codec))
}
}
impl<T, Codec, Incoming, Outgoing> Sink<Outgoing>
for WebSocketTransport<T, Codec, Incoming, Outgoing>
where
T: Sink<Message, Error = tungstenite::Error>
+ Stream<Item = Result<Message, tungstenite::Error>>
+ Unpin,
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
type Error = crate::Error<Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>;
fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let result = self.inner.poll_ready_unpin(cx).map_err(map_error);
#[cfg(feature = "logging")]
self.logger.log_ready(&result);
result
}
fn start_send(mut self: Pin<&mut Self>, item: Outgoing) -> Result<(), Self::Error> {
let mut message_length = 0;
let result = self.send_inner(item, &mut message_length);
#[cfg(feature = "logging")]
self.logger
.log_sending::<Outgoing, _>(&result, Some(message_length));
result
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let result = self.inner.poll_flush_unpin(cx).map_err(map_error);
#[cfg(feature = "logging")]
self.logger.log_flush(&result);
result
}
fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let result = self.inner.poll_close_unpin(cx).map_err(map_error);
#[cfg(feature = "logging")]
self.logger.log_close(&result);
result
}
}
impl<T, Codec, Incoming, Outgoing> Stream for WebSocketTransport<T, Codec, Incoming, Outgoing>
where
T: Sink<Message, Error = tungstenite::Error>
+ Stream<Item = Result<Message, tungstenite::Error>>
+ Unpin,
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
type Item = Result<Incoming, Error<<Codec as Encode>::Error, <Codec as Decode>::Error>>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let mut message_length = 0;
let result = match self.inner.poll_next_unpin(cx) {
Poll::Ready(item) => {
if let Some(item) = item {
match item {
Ok(message) => match message {
Message::Binary(message) => {
message_length = message.len();
let result: Result<Incoming, _> = self.codec.decode(&message[..]);
match result {
Ok(message) => Poll::Ready(Some(Ok(message))),
Err(error) => {
Poll::Ready(Some(Err(Error::DeserializationError(error))))
}
}
}
Message::Close(_) => {
self.terminated = true;
Poll::Ready(None)
}
_ => Poll::Pending,
},
Err(error) => match &error {
tungstenite::Error::Protocol(
tungstenite::error::ProtocolError::ResetWithoutClosingHandshake,
) => {
self.terminated = true;
Poll::Ready(None)
}
_ => Poll::Ready(Some(Err(Error::TungsteniteError(error)))),
},
}
} else {
self.terminated = true;
Poll::Ready(None)
}
}
Poll::Pending => Poll::Pending,
};
#[cfg(not(feature = "logging"))]
let _ = message_length;
#[cfg(feature = "logging")]
self.logger.log_receiving(&result, Some(message_length));
result
}
}
impl<T, Codec, Incoming, Outgoing> FusedStream for WebSocketTransport<T, Codec, Incoming, Outgoing>
where
T: Sink<Message, Error = tungstenite::Error>
+ Stream<Item = Result<Message, tungstenite::Error>>
+ Unpin,
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
fn is_terminated(&self) -> bool {
self.terminated
}
}
#[cfg(feature = "logging")]
impl<T, Codec, Incoming, Outgoing> dnet_base::Logging
for WebSocketTransport<T, Codec, Incoming, Outgoing>
where
T: Sink<Message, Error = tungstenite::Error>
+ Stream<Item = Result<Message, tungstenite::Error>>
+ Unpin,
Codec: crate::Codec,
for<'de> Incoming: serde::de::Deserialize<'de>,
Outgoing: Serialize,
{
const KIND: &'static str = "WebSocket";
fn with_logger<F, R>(&self, f: F) -> R
where
F: FnOnce(&dnet_base::Logger) -> R,
{
f(&self.logger)
}
fn with_logger_mut<F, R>(&mut self, f: F) -> R
where
F: FnOnce(&mut dnet_base::Logger) -> R,
{
f(&mut self.logger)
}
}
fn map_error<SerializationError, DeserializationError>(
tungstenite_error: tungstenite::Error,
) -> crate::Error<Error<SerializationError, DeserializationError>> {
if matches!(
tungstenite_error,
tungstenite::Error::ConnectionClosed | tungstenite::Error::AlreadyClosed
) {
crate::Error::Closed
} else {
crate::Error::Other(self::Error::TungsteniteError(tungstenite_error))
}
}
#[cfg(test)]
mod tests {
use futures::channel::oneshot;
use serde::{Deserialize, Serialize};
use tokio::{
net::{TcpListener, TcpStream},
spawn,
};
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
use crate::codecs::JsonCodec;
use super::WebSocketTransport;
async fn create_transports<I, O>(
port: u16,
) -> (
WebSocketTransport<WebSocketStream<TcpStream>, JsonCodec, I, O>,
WebSocketTransport<WebSocketStream<MaybeTlsStream<TcpStream>>, JsonCodec, O, I>,
)
where
I: Serialize,
for<'de> I: Deserialize<'de>,
O: Serialize,
for<'de> O: Deserialize<'de>,
{
let (tx, rx) = oneshot::channel();
spawn(async move {
let address = format!("127.0.0.1:{port}");
let left = TcpListener::bind(&address).await.unwrap();
let (left, _) = left.accept().await.unwrap();
let left = tokio_tungstenite::accept_async(left).await.unwrap();
tx.send(left).unwrap();
});
let (right, _) = tokio_tungstenite::connect_async(format!("ws://localhost:{port}/"))
.await
.unwrap();
let left = rx.await.unwrap();
let left = WebSocketTransport::new(left, JsonCodec::default());
let right = WebSocketTransport::new(right, JsonCodec::default());
(left, right)
}
#[tokio::test]
async fn test_transport() {
let (left, right) = create_transports(8100).await;
dnet_tests::test_transport(left, right).await;
}
#[tokio::test]
async fn test_unit_message() {
let (left, right) = create_transports(8101).await;
dnet_tests::test_unit_message(left, right).await;
}
#[tokio::test]
async fn test_stream() {
let (left, right) = create_transports(8102).await;
dnet_tests::test_stream(left, right).await;
}
}