use std::{
collections::{HashMap, HashSet},
sync::{Arc, Mutex, MutexGuard, PoisonError},
time::Duration,
};
use futures::{Stream, StreamExt as _};
use gql::{Response, ast::OperationKind};
use serde::Deserialize;
use serde_json::Value as JsonValue;
use tokio::{sync::mpsc, task::AbortHandle};
use crate::{
Context, GraphQLRequest, Server,
error::{ErrorKind, ResponseMeta},
};
pub const GRAPHQL_TRANSPORT_WS: &str = "graphql-transport-ws";
pub const CLOSE_BAD_REQUEST: u16 = 4400;
pub const CLOSE_UNAUTHORIZED: u16 = 4401;
pub const CLOSE_FORBIDDEN: u16 = 4403;
pub const CLOSE_INIT_TIMEOUT: u16 = 4408;
pub const CLOSE_SUBSCRIBER_EXISTS: u16 = 4409;
pub const CLOSE_TOO_MANY_INIT: u16 = 4429;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WsInput {
Text(String),
Close,
Invalid(String),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WsOutput {
Text(String),
Close {
code: u16,
reason: String,
},
}
#[derive(Clone, Debug)]
pub struct WsConfig {
pub connection_init_timeout: Option<Duration>,
pub max_operations: usize,
pub max_message_bytes: Option<usize>,
}
impl Default for WsConfig {
fn default() -> Self {
Self {
connection_init_timeout: Some(Duration::from_secs(10)),
max_operations: 32,
max_message_bytes: None,
}
}
}
impl WsConfig {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn connection_init_timeout(mut self, timeout: Option<Duration>) -> Self {
self.connection_init_timeout = timeout;
self
}
#[must_use]
pub fn max_operations(mut self, operations: usize) -> Self {
self.max_operations = operations;
self
}
#[must_use]
pub fn max_message_bytes(mut self, bytes: usize) -> Self {
self.max_message_bytes = Some(bytes);
self
}
}
#[derive(Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
enum ClientMessage {
ConnectionInit,
Ping { payload: Option<JsonValue> },
Pong,
Subscribe { id: String, payload: GraphQLRequest },
Complete { id: String },
}
pub async fn serve<S>(
server: Server,
config: WsConfig,
context: Context,
mut incoming: S,
outgoing: mpsc::Sender<WsOutput>,
) where
S: Stream<Item = WsInput> + Unpin + Send + 'static,
{
let max_message_bytes = config
.max_message_bytes
.unwrap_or_else(|| server.max_body_bytes_limit());
let initialised = match config.connection_init_timeout {
Some(timeout) => match tokio::time::timeout(
timeout,
await_connection_init(&mut incoming, max_message_bytes, &outgoing),
)
.await
{
Ok(result) => result,
Err(_) => {
close(
&outgoing,
CLOSE_INIT_TIMEOUT,
"Connection initialisation timeout",
)
.await;
return;
}
},
None => await_connection_init(&mut incoming, max_message_bytes, &outgoing).await,
};
match initialised {
Ok(true) => {}
Ok(false) | Err(()) => return,
}
if !send_text(&outgoing, CONNECTION_ACK.to_owned()).await {
return;
}
run_connection(
server,
config,
context,
incoming,
outgoing,
max_message_bytes,
)
.await;
}
async fn await_connection_init<S>(
incoming: &mut S,
max_message_bytes: usize,
outgoing: &mpsc::Sender<WsOutput>,
) -> Result<bool, ()>
where
S: Stream<Item = WsInput> + Unpin,
{
loop {
let Some(input) = incoming.next().await else {
return Ok(false);
};
let text = match input {
WsInput::Close => return Ok(false),
WsInput::Invalid(reason) => {
close(outgoing, CLOSE_BAD_REQUEST, &reason).await;
return Err(());
}
WsInput::Text(text) => text,
};
if too_large(&text, max_message_bytes) {
close(
outgoing,
CLOSE_BAD_REQUEST,
"Protocol message exceeds the configured size limit",
)
.await;
return Err(());
}
let message = match parse_message(&text) {
Ok(message) => message,
Err(()) => {
close(outgoing, CLOSE_BAD_REQUEST, "Invalid protocol message").await;
return Err(());
}
};
match message {
ClientMessage::ConnectionInit => return Ok(true),
ClientMessage::Ping { payload } => send_pong(outgoing, payload).await,
ClientMessage::Pong => {}
ClientMessage::Subscribe { .. } => {
close(
outgoing,
CLOSE_UNAUTHORIZED,
"Connection has not been acknowledged",
)
.await;
return Err(());
}
ClientMessage::Complete { .. } => {}
}
}
}
struct ActiveOperation {
sequence: u64,
handle: AbortHandle,
}
struct Done {
id: String,
sequence: u64,
}
async fn run_connection<S>(
server: Server,
config: WsConfig,
context: Context,
mut incoming: S,
outgoing: mpsc::Sender<WsOutput>,
max_message_bytes: usize,
) where
S: Stream<Item = WsInput> + Unpin + Send + 'static,
{
let active_ids: Arc<Mutex<HashSet<String>>> = Arc::new(Mutex::new(HashSet::new()));
let mut tasks: HashMap<String, ActiveOperation> = HashMap::new();
let (done_tx, mut done_rx) = mpsc::unbounded_channel::<Done>();
let mut sequence = 0u64;
loop {
tokio::select! {
biased;
done = done_rx.recv() => {
if let Some(done) = done {
if tasks
.get(&done.id)
.is_some_and(|active| active.sequence == done.sequence)
{
tasks.remove(&done.id);
}
}
}
input = incoming.next() => {
let Some(input) = input else {
break;
};
let text = match input {
WsInput::Close => break,
WsInput::Invalid(reason) => {
close(&outgoing, CLOSE_BAD_REQUEST, &reason).await;
break;
}
WsInput::Text(text) => text,
};
if too_large(&text, max_message_bytes) {
close(
&outgoing,
CLOSE_BAD_REQUEST,
"Protocol message exceeds the configured size limit",
)
.await;
break;
}
let message = match parse_message(&text) {
Ok(message) => message,
Err(()) => {
close(&outgoing, CLOSE_BAD_REQUEST, "Invalid protocol message").await;
break;
}
};
match message {
ClientMessage::ConnectionInit => {
close(
&outgoing,
CLOSE_TOO_MANY_INIT,
"Too many initialisation requests",
)
.await;
break;
}
ClientMessage::Ping { payload } => send_pong(&outgoing, payload).await,
ClientMessage::Pong => {}
ClientMessage::Subscribe { id, payload } => {
if id.is_empty() {
close(&outgoing, CLOSE_BAD_REQUEST, "Operation id must not be empty")
.await;
break;
}
let admitted = {
let mut ids = lock_ids(&active_ids);
if ids.contains(&id) {
None
} else if config.max_operations != 0
&& ids.len() >= config.max_operations
{
Some(false)
} else {
ids.insert(id.clone());
Some(true)
}
};
match admitted {
None => {
close(
&outgoing,
CLOSE_SUBSCRIBER_EXISTS,
"Subscriber for this id already exists",
)
.await;
break;
}
Some(false) => {
let mut response = Response::error(gql::GraphQLError::new(format!(
"The connection already has {} active operations.",
config.max_operations
)));
server.format_response(
&mut response,
ResponseMeta::none(),
ErrorKind::Request,
);
send_error(&outgoing, &id, &response).await;
}
Some(true) => {
sequence += 1;
let sequence = sequence;
let handle = tokio::spawn(run_operation(
OperationTask {
server: server.clone(),
request: payload,
context: context.clone(),
id: id.clone(),
sequence,
outgoing: outgoing.clone(),
done: done_tx.clone(),
active: Arc::clone(&active_ids),
},
));
tasks.insert(
id,
ActiveOperation {
sequence,
handle: handle.abort_handle(),
},
);
}
}
}
ClientMessage::Complete { id } => {
if let Some(active) = tasks.remove(&id) {
active.handle.abort();
}
lock_ids(&active_ids).remove(&id);
}
}
}
}
}
for active in tasks.into_values() {
active.handle.abort();
}
}
struct OperationTask {
server: Server,
request: GraphQLRequest,
context: Context,
id: String,
sequence: u64,
outgoing: mpsc::Sender<WsOutput>,
done: mpsc::UnboundedSender<Done>,
active: Arc<Mutex<HashSet<String>>>,
}
struct FinishGuard {
id: String,
sequence: u64,
outgoing: mpsc::Sender<WsOutput>,
done: mpsc::UnboundedSender<Done>,
active: Arc<Mutex<HashSet<String>>>,
removed: bool,
finished: bool,
}
impl FinishGuard {
fn new(task: &OperationTask) -> Self {
Self {
id: task.id.clone(),
sequence: task.sequence,
outgoing: task.outgoing.clone(),
done: task.done.clone(),
active: Arc::clone(&task.active),
removed: false,
finished: false,
}
}
fn remove_id(&mut self) {
if !self.removed {
lock_ids(&self.active).remove(&self.id);
self.removed = true;
}
}
async fn finish(mut self, final_message: Option<String>) {
self.remove_id();
if let Some(message) = final_message {
let _ = self.outgoing.send(WsOutput::Text(message)).await;
}
self.finished = true;
let _ = self.done.send(Done {
id: self.id.clone(),
sequence: self.sequence,
});
}
}
impl Drop for FinishGuard {
fn drop(&mut self) {
if self.finished {
return;
}
self.remove_id();
let _ = self.done.send(Done {
id: self.id.clone(),
sequence: self.sequence,
});
}
}
async fn run_operation(task: OperationTask) {
let guard = FinishGuard::new(&task);
let OperationTask {
server,
request,
context,
id,
outgoing,
..
} = task;
let kind = match server.operation_kind(&request) {
Ok(kind) => kind,
Err(error) => {
let mut response = Response::error(error);
server.format_response(
&mut response,
ResponseMeta::from_request(&request),
ErrorKind::Request,
);
let message = error_message(&id, &response);
guard.finish(Some(message)).await;
return;
}
};
if matches!(kind, Some(OperationKind::Subscription)) {
match server.subscribe(&request, context).await {
Ok(subscription) => {
let mut stream = subscription.stream;
while let Some(response) = stream.next().await {
let message = next_message(&id, &response);
if outgoing.send(WsOutput::Text(message)).await.is_err() {
return;
}
}
guard.finish(Some(complete_message(&id))).await;
}
Err(response) => {
let message = error_message(&id, &response);
guard.finish(Some(message)).await;
}
}
return;
}
let response = server.execute(&request, context).await;
if is_request_error(&response) {
let message = error_message(&id, &response);
guard.finish(Some(message)).await;
} else {
if outgoing
.send(WsOutput::Text(next_message(&id, &response)))
.await
.is_err()
{
return;
}
guard.finish(Some(complete_message(&id))).await;
}
}
fn is_request_error(response: &Response) -> bool {
response.data.is_none()
&& response.has_errors()
&& response.errors.iter().all(|error| error.path().is_none())
}
fn parse_message(text: &str) -> Result<ClientMessage, ()> {
serde_json::from_str(text).map_err(|_| ())
}
fn too_large(text: &str, max_message_bytes: usize) -> bool {
max_message_bytes != 0 && text.len() > max_message_bytes
}
#[derive(serde::Serialize)]
struct Message<'a, T> {
id: &'a str,
#[serde(rename = "type")]
kind: &'static str,
payload: T,
}
#[derive(serde::Serialize)]
struct IdMessage<'a> {
id: &'a str,
#[serde(rename = "type")]
kind: &'static str,
}
#[derive(serde::Serialize)]
struct Pong<'a> {
#[serde(rename = "type")]
kind: &'static str,
payload: &'a JsonValue,
}
const CONNECTION_ACK: &str = r#"{"type":"connection_ack"}"#;
const PONG: &str = r#"{"type":"pong"}"#;
fn next_message(id: &str, response: &Response) -> String {
match serde_json::to_string(&Message {
id,
kind: "next",
payload: response,
}) {
Ok(message) => message,
Err(error) => serde_json::to_string(&Message {
id,
kind: "next",
payload: crate::response::serialization_error(error),
})
.unwrap_or_default(),
}
}
fn error_message(id: &str, response: &Response) -> String {
match serde_json::to_string(&Message {
id,
kind: "error",
payload: &response.errors,
}) {
Ok(message) => message,
Err(_) => serde_json::to_string(&Message {
id,
kind: "error",
payload: &[] as &[gql::GraphQLError],
})
.unwrap_or_default(),
}
}
async fn send_error(outgoing: &mpsc::Sender<WsOutput>, id: &str, response: &Response) {
let _ = outgoing
.send(WsOutput::Text(error_message(id, response)))
.await;
}
fn complete_message(id: &str) -> String {
serde_json::to_string(&IdMessage {
id,
kind: "complete",
})
.unwrap_or_default()
}
async fn send_pong(outgoing: &mpsc::Sender<WsOutput>, payload: Option<JsonValue>) {
let message = match payload.filter(|payload| !payload.is_null()) {
Some(payload) => serde_json::to_string(&Pong {
kind: "pong",
payload: &payload,
})
.unwrap_or_default(),
None => PONG.to_owned(),
};
let _ = outgoing.send(WsOutput::Text(message)).await;
}
async fn send_text(outgoing: &mpsc::Sender<WsOutput>, message: String) -> bool {
outgoing.send(WsOutput::Text(message)).await.is_ok()
}
async fn close(outgoing: &mpsc::Sender<WsOutput>, code: u16, reason: &str) {
let _ = outgoing
.send(WsOutput::Close {
code,
reason: reason.to_owned(),
})
.await;
}
fn lock_ids(ids: &Mutex<HashSet<String>>) -> MutexGuard<'_, HashSet<String>> {
ids.lock().unwrap_or_else(PoisonError::into_inner)
}
#[cfg(feature = "ws")]
pub(crate) async fn serve_axum(
server: Server,
config: WsConfig,
context: Context,
socket: ::axum::extract::ws::WebSocket,
) {
use ::axum::extract::ws::{CloseFrame, Message};
use futures::{SinkExt as _, StreamExt as _};
let (mut sink, stream) = socket.split();
let (outgoing, mut receiver) = mpsc::channel::<WsOutput>(64);
let writer = tokio::spawn(async move {
while let Some(output) = receiver.recv().await {
match output {
WsOutput::Text(text) => {
if sink.send(Message::Text(text.into())).await.is_err() {
break;
}
}
WsOutput::Close { code, reason } => {
let frame = CloseFrame {
code,
reason: reason.into(),
};
let _ = sink.send(Message::Close(Some(frame))).await;
let _ = sink.close().await;
break;
}
}
}
});
let incoming = stream
.filter_map(|message| async move {
match message {
Ok(Message::Text(text)) => Some(WsInput::Text(text.to_string())),
Ok(Message::Binary(_)) => Some(WsInput::Invalid(
"Binary messages are not supported".to_owned(),
)),
Ok(Message::Close(_)) | Err(_) => Some(WsInput::Close),
Ok(Message::Ping(_)) | Ok(Message::Pong(_)) => None,
}
})
.boxed();
serve(server, config, context, incoming, outgoing).await;
let _ = writer.await;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_unknown_message_types() {
assert!(parse_message(r#"{"type":"nope"}"#).is_err());
}
#[test]
fn parses_a_subscribe_payload() {
let message = parse_message(
r#"{"id":"1","type":"subscribe","payload":{"query":"{ hello }","variables":{"x":1}}}"#,
)
.expect("message");
match message {
ClientMessage::Subscribe { id, payload } => {
assert_eq!(id, "1");
assert_eq!(payload.query, "{ hello }");
}
_ => panic!("expected subscribe"),
}
}
}