use super::registry::Registry;
use crate::error::TransportError;
use futures_channel::mpsc;
use futures_util::{SinkExt, StreamExt};
use std::sync::Arc;
use tokio_tungstenite::tungstenite::Message;
#[derive(Debug)]
enum Out {
Frame(String),
Close,
}
#[derive(Debug, Clone)]
pub(crate) struct Conn {
outbound: mpsc::UnboundedSender<Out>,
}
impl Conn {
pub(crate) fn send(&self, text: String) -> Result<(), TransportError> {
self.outbound
.unbounded_send(Out::Frame(text))
.map_err(|_| TransportError::closed("websocket connection is closed"))
}
pub(crate) fn close(&self) {
let _ = self.outbound.unbounded_send(Out::Close);
}
}
pub(crate) async fn connect(url: &str, registry: Arc<Registry>) -> Result<Conn, TransportError> {
connect_with_headers(url, &[], registry).await
}
pub(crate) async fn connect_with_headers(
url: &str,
headers: &[(String, String)],
registry: Arc<Registry>,
) -> Result<Conn, TransportError> {
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::http::{HeaderName, HeaderValue};
let mut request = url
.into_client_request()
.map_err(|e| TransportError::connect(format!("{url}: {e}")))?;
for (name, value) in headers {
let name = HeaderName::from_bytes(name.as_bytes())
.map_err(|e| TransportError::connect(format!("header {name}: {e}")))?;
let value = HeaderValue::from_str(value)
.map_err(|_| TransportError::connect(format!("header {name}: not a header value")))?;
request.headers_mut().insert(name, value);
}
let (socket, _response) = tokio_tungstenite::connect_async(request).await.map_err(|e| match e {
tokio_tungstenite::tungstenite::Error::Http(response) => {
let status = response.status();
TransportError::http(status.as_u16(), format!("{url}: the upgrade was refused with {status}"))
}
e => TransportError::connect(format!("{url}: {e}")),
})?;
let (mut sink, mut source) = socket.split();
let (outbound, mut queue) = mpsc::unbounded::<Out>();
tokio::spawn(async move {
while let Some(out) = queue.next().await {
match out {
Out::Frame(text) => {
if sink.send(Message::text(text)).await.is_err() {
break;
}
}
Out::Close => break,
}
}
let _ = sink.close().await;
});
let reader_outbound = outbound.clone();
tokio::spawn(async move {
let write_back = |frame: Option<String>| {
if let Some(frame) = frame {
super::trace("→", &frame);
let _ = reader_outbound.unbounded_send(Out::Frame(frame));
}
};
loop {
match source.next().await {
Some(Ok(Message::Text(text))) => {
super::trace("←", text.as_str());
write_back(registry.on_text(text.as_str()));
}
Some(Ok(Message::Binary(bytes))) => {
if let Ok(text) = std::str::from_utf8(&bytes) {
super::trace("←", text);
write_back(registry.on_text(text));
}
}
Some(Ok(Message::Close(_))) | None => {
registry.on_close("websocket closed by the peer");
return;
}
Some(Ok(_)) => {}
Some(Err(e)) => {
registry.on_close(format!("websocket read failed: {e}"));
return;
}
}
}
});
Ok(Conn { outbound })
}