use crate::envelope::{RawItem, StreamItem};
use crate::error::{ClientError, TransportError};
use crate::transport::{ItemStream, MethodRef, RawItemStream, Transport};
use futures_core::Stream;
use futures_util::{stream, StreamExt};
use serde_json::Value;
use std::future::Future;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
#[cfg(not(target_arch = "wasm32"))]
pub type BoxStream<'a, T> = Pin<Box<dyn Stream<Item = T> + Send + 'a>>;
#[cfg(target_arch = "wasm32")]
pub type BoxStream<'a, T> = Pin<Box<dyn Stream<Item = T> + 'a>>;
#[cfg(not(target_arch = "wasm32"))]
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
#[cfg(target_arch = "wasm32")]
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;
#[cfg(not(target_arch = "wasm32"))]
pub trait MaybeSend: Send {}
#[cfg(not(target_arch = "wasm32"))]
impl<T: Send> MaybeSend for T {}
#[cfg(target_arch = "wasm32")]
pub trait MaybeSend {}
#[cfg(target_arch = "wasm32")]
impl<T> MaybeSend for T {}
#[diagnostic::on_unimplemented(
message = "`{Self}` does not implement `plexus_client::FromClientError`",
label = "the event type of a trait emitted by `#[plexus_macros::activation]` must implement `plexus_client::FromClientError`",
note = "the client's implementation of the trait yields a client failure as `{Self}::from_client_error(err)`; implement `plexus_client::FromClientError` for `{Self}` (usually its in-band `Error {{ message }}` variant)"
)]
pub trait FromClientError {
fn from_client_error(error: ClientError) -> Self;
}
impl<T, E: FromClientError> FromClientError for Result<T, E> {
fn from_client_error(error: ClientError) -> Self {
Err(E::from_client_error(error))
}
}
impl<T: FromClientError, P> FromClientError for crate::progress::Progress<T, P> {
fn from_client_error(error: ClientError) -> Self {
crate::progress::Progress::Item(T::from_client_error(error))
}
}
impl FromClientError for String {
fn from_client_error(error: ClientError) -> Self {
error.to_string()
}
}
#[cfg(not(target_arch = "wasm32"))]
pub fn into_events<'a, E, S>(events: S) -> BoxStream<'a, E>
where
E: FromClientError + Send + 'a,
S: Stream<Item = Result<E, ClientError>> + Unpin + Send + 'a,
{
Box::pin(stream::unfold(Some(events), |state| async move {
let mut events = state?;
match events.next().await? {
Ok(e) => Some((e, Some(events))),
Err(err) => Some((E::from_client_error(err), None)),
}
}))
}
#[cfg(target_arch = "wasm32")]
pub fn into_events<'a, E, S>(events: S) -> BoxStream<'a, E>
where
E: FromClientError + 'a,
S: Stream<Item = Result<E, ClientError>> + Unpin + 'a,
{
Box::pin(stream::unfold(Some(events), |state| async move {
let mut events = state?;
match events.next().await? {
Ok(e) => Some((e, Some(events))),
Err(err) => Some((E::from_client_error(err), None)),
}
}))
}
pub fn error_events<'a, E>(error: ClientError) -> BoxStream<'a, E>
where
E: FromClientError + 'a,
{
Box::pin(stream::once(async move { E::from_client_error(error) }))
}
pub fn trait_one<T, I>(
transport: T,
method: MethodRef,
params: Result<Value, ClientError>,
item: crate::method_stream::Decoder<I>,
) -> BoxFuture<'static, I>
where
T: Transport + MaybeSend + Sync + 'static,
I: FromClientError + MaybeSend + 'static,
{
Box::pin(async move {
match crate::method_stream::call_one(&transport, method, params, item).await {
Ok(i) => i,
Err(e) => I::from_client_error(e),
}
})
}
pub fn trait_one_with_input<T, I>(
transport: T,
method: MethodRef,
params: Result<Value, ClientError>,
input: crate::transport::InputItems<'static>,
item: crate::method_stream::Decoder<I>,
) -> BoxFuture<'static, I>
where
T: Transport + MaybeSend + Sync + 'static,
I: FromClientError + MaybeSend + 'static,
{
Box::pin(async move {
match crate::method_stream::call_one_with_input(&transport, method, params, input, item).await {
Ok(i) => i,
Err(e) => I::from_client_error(e),
}
})
}
pub fn trait_many<I>(
items: Result<RawItemStream<'static>, ClientError>,
item: crate::method_stream::Decoder<I>,
) -> BoxStream<'static, I>
where
I: FromClientError + MaybeSend + 'static,
{
match items {
Ok(items) => fold(crate::method_stream::MethodStream::<'static, I>::new(items, item, std::convert::identity)),
Err(e) => Box::pin(stream::once(async move { I::from_client_error(e) })),
}
}
pub fn trait_progress<T, P>(
items: Result<RawItemStream<'static>, ClientError>,
item: crate::method_stream::Decoder<T>,
) -> BoxStream<'static, crate::progress::Progress<T, P>>
where
T: FromClientError + MaybeSend + 'static,
P: serde::de::DeserializeOwned + MaybeSend + 'static,
{
use crate::frame::Frame;
use crate::progress::Progress;
match items {
Ok(items) => fold(
crate::method_stream::MethodStream::<'static, T, P, T>::new(items, item, std::convert::identity)
.with_progress()
.map(|r| {
r.map(|f| match f {
Frame::Item(t) => Progress::Item(t),
Frame::Progress(p) => Progress::Update(p),
})
}),
),
Err(e) => Box::pin(stream::once(async move { Progress::Item(T::from_client_error(e)) })),
}
}
pub fn trait_result_progress<T, P, E>(
items: Result<RawItemStream<'static>, ClientError>,
item: crate::method_stream::Decoder<Result<T, E>>,
) -> BoxStream<'static, Result<crate::progress::Progress<T, P>, E>>
where
T: MaybeSend + 'static,
E: FromClientError + MaybeSend + 'static,
P: serde::de::DeserializeOwned + MaybeSend + 'static,
{
use crate::frame::Frame;
use crate::progress::Progress;
match items {
Ok(items) => fold(
crate::method_stream::MethodStream::<'static, Result<T, E>, P, Result<T, E>>::new(
items,
item,
std::convert::identity,
)
.with_progress()
.map(|r| {
r.map(|f| match f {
Frame::Item(Ok(t)) => Ok(Progress::Item(t)),
Frame::Item(Err(e)) => Err(e),
Frame::Progress(p) => Ok(Progress::Update(p)),
})
}),
),
Err(e) => Box::pin(stream::once(async move { Err(E::from_client_error(e)) })),
}
}
fn fold<I, S>(events: S) -> BoxStream<'static, I>
where
I: FromClientError + MaybeSend + 'static,
S: Stream<Item = Result<I, ClientError>> + Unpin + MaybeSend + 'static,
{
Box::pin(stream::unfold(Some(events), |state| async move {
let mut events = state?;
match events.next().await? {
Ok(e) => Some((e, Some(events))),
Err(err) => Some((I::from_client_error(err), None)),
}
}))
}
type Slot<I> = Arc<Mutex<Option<Result<I, TransportError>>>>;
#[cfg(not(target_arch = "wasm32"))]
type Driver = Pin<Box<dyn Future<Output = ()> + Send + 'static>>;
#[cfg(target_arch = "wasm32")]
type Driver = Pin<Box<dyn Future<Output = ()> + 'static>>;
#[cfg(not(target_arch = "wasm32"))]
pub fn owned_call<T>(transport: T, method: MethodRef, params: Value) -> ItemStream<'static>
where
T: Transport + Send + Sync + 'static,
{
let slot: Slot<StreamItem> = Arc::new(Mutex::new(None));
let tx = slot.clone();
let driver: Driver = Box::pin(async move {
let transport = transport;
let mut items = transport.call(method, params);
while let Some(item) = items.next().await {
*tx.lock().unwrap_or_else(|p| p.into_inner()) = Some(item);
HandOff(false).await;
}
});
Box::pin(Owned { driver: Some(driver), slot })
}
#[cfg(not(target_arch = "wasm32"))]
pub fn owned_call_raw<T>(transport: T, method: MethodRef, params: Value) -> RawItemStream<'static>
where
T: Transport + Send + Sync + 'static,
{
let slot: Slot<RawItem> = Arc::new(Mutex::new(None));
let tx = slot.clone();
let driver: Driver = Box::pin(async move {
let transport = transport;
let mut items = transport.call_raw(method, params);
while let Some(item) = items.next().await {
*tx.lock().unwrap_or_else(|p| p.into_inner()) = Some(item);
HandOff(false).await;
}
});
Box::pin(Owned { driver: Some(driver), slot })
}
#[cfg(target_arch = "wasm32")]
pub fn owned_call<T>(transport: T, method: MethodRef, params: Value) -> ItemStream<'static>
where
T: Transport + 'static,
{
let slot: Slot<StreamItem> = Arc::new(Mutex::new(None));
let tx = slot.clone();
let driver: Driver = Box::pin(async move {
let transport = transport;
let mut items = transport.call(method, params);
while let Some(item) = items.next().await {
*tx.lock().unwrap_or_else(|p| p.into_inner()) = Some(item);
HandOff(false).await;
}
});
Box::pin(Owned { driver: Some(driver), slot })
}
#[cfg(target_arch = "wasm32")]
pub fn owned_call_raw<T>(transport: T, method: MethodRef, params: Value) -> RawItemStream<'static>
where
T: Transport + 'static,
{
let slot: Slot<RawItem> = Arc::new(Mutex::new(None));
let tx = slot.clone();
let driver: Driver = Box::pin(async move {
let transport = transport;
let mut items = transport.call_raw(method, params);
while let Some(item) = items.next().await {
*tx.lock().unwrap_or_else(|p| p.into_inner()) = Some(item);
HandOff(false).await;
}
});
Box::pin(Owned { driver: Some(driver), slot })
}
#[cfg(not(target_arch = "wasm32"))]
pub fn owned_call_raw_with_input<T>(transport: T, method: MethodRef, params: Value, input: crate::transport::InputItems<'static>) -> RawItemStream<'static>
where
T: Transport + Send + Sync + 'static,
{
let slot: Slot<RawItem> = Arc::new(Mutex::new(None));
let tx = slot.clone();
let driver: Driver = Box::pin(async move {
let transport = transport;
let mut items = transport.call_raw_with_input(method, params, input);
while let Some(item) = items.next().await {
*tx.lock().unwrap_or_else(|p| p.into_inner()) = Some(item);
HandOff(false).await;
}
});
Box::pin(Owned { driver: Some(driver), slot })
}
#[cfg(target_arch = "wasm32")]
pub fn owned_call_raw_with_input<T>(transport: T, method: MethodRef, params: Value, input: crate::transport::InputItems<'static>) -> RawItemStream<'static>
where
T: Transport + 'static,
{
let slot: Slot<RawItem> = Arc::new(Mutex::new(None));
let tx = slot.clone();
let driver: Driver = Box::pin(async move {
let transport = transport;
let mut items = transport.call_raw_with_input(method, params, input);
while let Some(item) = items.next().await {
*tx.lock().unwrap_or_else(|p| p.into_inner()) = Some(item);
HandOff(false).await;
}
});
Box::pin(Owned { driver: Some(driver), slot })
}
struct HandOff(bool);
impl Future for HandOff {
type Output = ();
fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> {
if self.0 {
Poll::Ready(())
} else {
self.0 = true;
Poll::Pending
}
}
}
struct Owned<I> {
driver: Option<Driver>,
slot: Slot<I>,
}
impl<I> Owned<I> {
fn take_item(&self) -> Option<Result<I, TransportError>> {
self.slot.lock().unwrap_or_else(|p| p.into_inner()).take()
}
}
impl<I> Stream for Owned<I> {
type Item = Result<I, TransportError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let Some(driver) = self.driver.as_mut() else {
return Poll::Ready(None);
};
match driver.as_mut().poll(cx) {
Poll::Ready(()) => {
self.driver = None;
Poll::Ready(self.take_item())
}
Poll::Pending => match self.take_item() {
Some(item) => Poll::Ready(Some(item)),
None => Poll::Pending,
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::decode::decode;
use crate::memory::MemoryTransport;
#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
enum Ev {
N(u8),
Error(String),
}
impl FromClientError for Ev {
fn from_client_error(error: ClientError) -> Self {
Ev::Error(error.to_string())
}
}
const COUNT: MethodRef = MethodRef::new("demo", "count");
#[test]
fn an_owned_call_outlives_its_caller_and_ends_on_an_error() {
let t = MemoryTransport::new().script(
COUNT,
vec![
StreamItem::Data { metadata: None, content_type: None, content: serde_json::json!({"N": 1}) },
StreamItem::Progress { metadata: None, content_type: None, content: serde_json::json!({"message": "half", "percentage": 50.0}) },
StreamItem::Data { metadata: None, content_type: None, content: serde_json::json!({"N": 2}) },
StreamItem::Error {
metadata: None,
recoverable: false,
message: Some("no".into()),
code: None,
error: crate::RemoteError::Execution { message: "no".into() },
fields: Default::default(),
},
StreamItem::Data { metadata: None, content_type: None, content: serde_json::json!({"N": 3}) },
],
);
let s = into_events::<Ev, _>(decode::<Ev>(owned_call(Arc::new(t), COUNT, serde_json::json!({}))));
let got: Vec<Ev> = futures::executor::block_on(s.collect());
assert_eq!(got, vec![Ev::N(1), Ev::N(2), Ev::Error("remote error: no".into())]);
}
}