use std::{
any::Any,
borrow::Cow,
fmt,
io::{self, Read, Write},
panic::{self, AssertUnwindSafe},
sync::Arc,
thread,
time::Instant,
};
use jsonx_lib::Parser;
use crate::{
config::{Cancellation, Config, Gate},
error::{CallError, Error},
error_object::{ErrorCode, ErrorObject, clip},
framing::{FrameError, Framing},
handles::{Peer, Responder},
id::Id,
limits::Limits,
link::{GateState, Link, Shared},
message::{
Entry, Incoming, Invalid, Message, Notification, Request, Response, decode, read_member_id,
},
raw::{Json, Raw},
router::{Context, Event, EventFn, Params, RequestHandler, Router},
sink::{Framed, Sink},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Flow {
Continue,
Stop,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum End {
Eof,
Stopped,
}
pub struct Endpoint<S, K: Sink> {
shared: Arc<Shared<K>>,
link: Arc<dyn Link>,
router: Router<S>,
state: S,
limits: Limits,
parser: Parser,
gate: Option<Gate>,
cancellation: Option<Cancellation>,
}
impl<S, K: Sink> Endpoint<S, K> {
#[must_use]
pub fn new(sink: K, router: Router<S>, state: S) -> Self {
let config = Config::new();
let shared = Shared::new(sink, &config);
let link: Arc<dyn Link> = Arc::clone(&shared) as Arc<dyn Link>;
Self {
shared,
link,
router,
state,
limits: config.limits,
parser: config.limits.parser(),
gate: config.gate,
cancellation: config.cancellation,
}
}
#[must_use]
pub fn with_config(mut self, config: Config) -> Self {
self.shared.lock().configure(&config);
self.limits = config.limits;
self.parser = config.limits.parser();
self.gate = config.gate;
self.cancellation = config.cancellation;
self
}
#[must_use]
pub fn peer(&self) -> Peer {
Peer::new(Arc::clone(&self.link))
}
#[inline]
#[must_use]
pub const fn state(&self) -> &S {
&self.state
}
#[inline]
pub fn state_mut(&mut self) -> &mut S {
&mut self.state
}
pub fn with_sink<R>(&self, f: impl FnOnce(&mut K) -> R) -> R {
f(self.shared.lock().sink_mut())
}
#[must_use]
pub fn is_closed(&self) -> bool {
self.shared.lock().is_closed()
}
pub fn close(&mut self) {
self.shared.lock().close();
}
#[must_use]
pub fn next_deadline(&self) -> Option<Instant> {
self.shared.lock().next_deadline()
}
pub fn expire(&self) {
self.shared.lock().expire();
}
pub fn handle(&mut self, body: &[u8]) -> Result<Flow, Error> {
self.begin_turn()?;
let mut stop = false;
match decode(body, &self.limits) {
Incoming::Single(entry) => self.dispatch(entry, None, &mut stop),
Incoming::Batch(entries) => {
let owed = entries.iter().filter(|entry| owes_response(entry)).count();
let batch = (owed > 0).then(|| self.shared.lock().open_batch(owed));
for entry in entries {
self.dispatch(entry, batch, &mut stop);
}
}
}
self.end_turn()?;
Ok(if stop { Flow::Stop } else { Flow::Continue })
}
pub fn run<R: Read>(&mut self, mut input: R, framing: Framing) -> Result<End, Error> {
let result = self.read_loop(&mut input, framing);
match result {
Ok(End::Stopped) => {}
_ => self.close(),
}
result
}
fn read_loop<R: Read>(&mut self, input: &mut R, framing: Framing) -> Result<End, Error> {
if self.is_closed() {
return Err(self.closed_error());
}
let mut decoder = framing.decoder(&self.limits);
loop {
loop {
let flow = match decoder.next_frame() {
Ok(Some(body)) => self.handle(body)?,
Ok(None) => break,
Err(error) if error.is_recoverable() => self.oversized(error)?,
Err(error) => return Err(Error::Frame(error)),
};
if flow == Flow::Stop {
return Ok(End::Stopped);
}
}
let space = decoder.space();
if space.is_empty() {
break;
}
let n = match input.read(space) {
Ok(0) => break,
Ok(n) => n,
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
Err(error) => return Err(Error::Io(error)),
};
decoder.commit(n);
}
loop {
let flow = match decoder.finish() {
Ok(Some(body)) => self.handle(body)?,
Ok(None) => return Ok(End::Eof),
Err(error) if error.is_recoverable() => self.oversized(error)?,
Err(error) => return Err(Error::Frame(error)),
};
if flow == Flow::Stop {
return Ok(End::Stopped);
}
}
}
fn oversized(&mut self, error: FrameError) -> Result<Flow, Error> {
self.begin_turn()?;
let answer = ErrorObject::invalid_request(format!("the message is too large: {error}"));
self.answer(None, None, &Err(&answer));
report(
&mut self.router.on_event,
&mut self.state,
&Event::Oversized { error },
);
self.end_turn()?;
Ok(Flow::Continue)
}
fn closed_error(&self) -> Error {
self.shared
.lock()
.take_broken()
.map_or(Error::Closed, Error::Io)
}
fn begin_turn(&self) -> Result<(), Error> {
let mut inner = self.shared.lock();
if inner.is_closed() {
return Err(inner.take_broken().map_or(Error::Closed, Error::Io));
}
inner.endpoint_thread = Some(thread::current().id());
inner.cork();
inner.expire();
Ok(())
}
fn end_turn(&self) -> Result<(), Error> {
let mut inner = self.shared.lock();
inner.uncork();
inner.endpoint_thread = None;
inner
.take_broken()
.map_or(Ok(()), |error| Err(Error::Io(error)))
}
fn answer(
&self,
id: Option<&Id<'_>>,
batch: Option<u64>,
result: &Result<&Json<'_>, &ErrorObject>,
) {
let _reported_at_turn_end = self.shared.lock().respond(id, batch, *result);
}
fn dispatch(&mut self, entry: Entry<'_>, batch: Option<u64>, stop: &mut bool) {
match entry {
Ok(Message::Request(request)) => self.on_request(request, batch, stop),
Ok(Message::Notification(notification)) => self.on_notification(notification, stop),
Ok(Message::Response(response)) => self.on_response(response),
Err(invalid) => self.on_invalid(&invalid, batch),
}
}
fn on_request(&mut self, request: Request<'_>, batch: Option<u64>, stop: &mut bool) {
let Request { id, method, params } = request;
if let Some(refusal) = self.admit(&id, &method, batch) {
self.answer(Some(&id), batch, &Err(&refusal));
return;
}
let Some(handler) = self.router.requests.get_mut(&*method) else {
let error = ErrorObject::method_not_found(&method);
let _reported = self.shared.lock().respond(Some(&id), batch, Err(&error));
return;
};
let params = Params::new(params, self.parser);
match handler {
RequestHandler::Now(handler) => {
let state = &mut self.state;
let mut cx = Context::new(&self.link, stop, Some(&id), &method);
let outcome = contain(|| handler(state, params, &mut cx));
let error;
let result = match &outcome {
Ok(Ok(value)) => Ok(value),
Ok(Err(refusal)) => Err(refusal),
Err(payload) => {
report(
&mut self.router.on_event,
&mut self.state,
&Event::Panicked {
method: &method,
message: &panic_message(payload.as_ref()),
},
);
error = ErrorObject::internal_error("the handler panicked");
Err(&error)
}
};
let _reported = self.shared.lock().respond(Some(&id), batch, result);
}
RequestHandler::Deferred(handler) => {
let owned = id.clone().into_owned();
let token = self.shared.lock().begin_deferred(owned.clone(), batch);
let Some(token) = token else {
let error = ErrorObject::new(
ErrorCode::SERVER_OVERLOADED,
"too many requests are already being answered",
);
let _reported = self.shared.lock().respond(Some(&id), batch, Err(&error));
return;
};
let responder = Responder::new(owned, token, Arc::clone(&self.link));
let state = &mut self.state;
let mut cx = Context::new(&self.link, stop, Some(&id), &method);
if let Err(payload) = contain(|| handler(state, params, &mut cx, responder)) {
report(
&mut self.router.on_event,
&mut self.state,
&Event::Panicked {
method: &method,
message: &panic_message(payload.as_ref()),
},
);
}
}
}
}
fn admit(&self, id: &Id<'_>, method: &str, batch: Option<u64>) -> Option<ErrorObject> {
let mut inner = self.shared.lock();
if inner.in_flight(id) {
return Some(ErrorObject::invalid_request(
"the id is already used by a request still being answered",
));
}
let gate = self.gate.as_ref()?;
let opening = method == gate.method;
match &inner.gate {
GateState::Open if opening => Some(ErrorObject::invalid_request(format!(
"`{}` was already received",
clip(method)
))),
GateState::Open => None,
GateState::Opening(_) if opening => Some(ErrorObject::invalid_request(format!(
"`{}` is already being answered",
clip(method)
))),
GateState::Opening(_) => Some(not_initialized(gate)),
GateState::Closed if !opening => Some(not_initialized(gate)),
GateState::Closed if batch.is_some() => Some(ErrorObject::invalid_request(format!(
"`{}` cannot be sent in a batch",
clip(method)
))),
GateState::Closed => {
inner.gate = GateState::Opening(id.clone().into_owned());
None
}
}
}
fn on_notification(&mut self, notification: Notification<'_>, stop: &mut bool) {
let Notification { method, params } = notification;
if let Some(cancellation) = &self.cancellation {
if *method == *cancellation.method {
let target = params.as_ref().and_then(|p| {
read_member_id(p.as_str(), &cancellation.id_member, &self.parser)
});
if let Some(target) = target {
if self.shared.lock().cancel_incoming(&target) {
report(
&mut self.router.on_event,
&mut self.state,
&Event::Cancelled { id: &target },
);
}
}
return;
}
}
if let Some(gate) = &self.gate {
if self.shared.lock().gate != GateState::Open && !gate.allows(&method) {
report(
&mut self.router.on_event,
&mut self.state,
&Event::Dropped { method: &method },
);
return;
}
}
let Some(handler) = self.router.notifications.get_mut(&*method) else {
report(
&mut self.router.on_event,
&mut self.state,
&Event::UnknownNotification { method: &method },
);
return;
};
let params = Params::new(params, self.parser);
let state = &mut self.state;
let mut cx = Context::new(&self.link, stop, None, &method);
if let Err(payload) = contain(|| handler(state, params, &mut cx)) {
report(
&mut self.router.on_event,
&mut self.state,
&Event::Panicked {
method: &method,
message: &panic_message(payload.as_ref()),
},
);
}
}
fn on_response(&mut self, response: Response<'_>) {
let Response { id, result } = response;
let Some(id) = id else {
if let Err(error) = &result {
report(
&mut self.router.on_event,
&mut self.state,
&Event::PeerError { error },
);
}
return;
};
let settled = match ours(&id) {
Some(number) => {
let outcome = result.map(Raw::into_owned).map_err(CallError::Rejected);
self.shared.lock().settle(number, outcome)
}
None => false,
};
if !settled {
report(
&mut self.router.on_event,
&mut self.state,
&Event::Unmatched { id: &id },
);
}
}
fn on_invalid(&mut self, invalid: &Invalid<'_>, batch: Option<u64>) {
let answered = !invalid.is_response();
if answered {
self.answer(invalid.id(), batch, &Err(invalid.error()));
} else if let Some(number) = invalid.id().and_then(ours) {
let outcome = Err(CallError::InvalidResponse(invalid.error().clone()));
let _settled = self.shared.lock().settle(number, outcome);
}
report(
&mut self.router.on_event,
&mut self.state,
&Event::Invalid {
error: invalid.error(),
answered,
},
);
}
}
impl<S, K: Sink> Drop for Endpoint<S, K> {
fn drop(&mut self) {
self.close();
}
}
impl<S, K: Sink> fmt::Debug for Endpoint<S, K> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Endpoint")
.field("router", &self.router)
.field("limits", &self.limits)
.field("gate", &self.gate)
.field("cancellation", &self.cancellation)
.finish_non_exhaustive()
}
}
pub fn serve<R, W>(input: R, output: W, framing: Framing, router: Router<()>) -> Result<End, Error>
where
R: Read,
W: Write + Send + 'static,
{
Endpoint::new(Framed::new(output, framing), router, ()).run(input, framing)
}
fn owes_response(entry: &Entry<'_>) -> bool {
match entry {
Ok(Message::Request(_)) => true,
Ok(_) => false,
Err(invalid) => !invalid.is_response(),
}
}
fn ours(id: &Id<'_>) -> Option<u64> {
id.as_i64()
.and_then(|n| u64::try_from(n).ok())
.filter(|&n| n > 0)
}
fn not_initialized(gate: &Gate) -> ErrorObject {
ErrorObject::new(
gate.code,
format!(
"`{}` must succeed before any other request",
clip(&gate.method)
),
)
}
fn contain<T>(f: impl FnOnce() -> T) -> Result<T, Box<dyn Any + Send>> {
panic::catch_unwind(AssertUnwindSafe(f))
}
fn panic_message(payload: &(dyn Any + Send)) -> Cow<'_, str> {
if let Some(text) = payload.downcast_ref::<&str>() {
clip(text)
} else if let Some(text) = payload.downcast_ref::<String>() {
clip(text)
} else {
Cow::Borrowed("(a panic payload that is not text)")
}
}
fn report<S>(hook: &mut Option<EventFn<S>>, state: &mut S, event: &Event<'_>) {
if let Some(hook) = hook {
let _ignored = contain(|| hook(state, event));
}
}