use futures::StreamExt;
use plexus_client::{ItemStream, MethodRef, StreamItem, StreamMetadata, Transport, TransportError};
use serde_json::Value;
use super::auth::AuthContext;
use super::plexus::Activation;
use super::types::PlexusStreamItem;
#[derive(Debug, Clone)]
pub struct InProcessTransport<A> {
activation: A,
auth: Option<AuthContext>,
}
impl<A: Activation> InProcessTransport<A> {
pub fn new(activation: A) -> Self {
Self {
activation,
auth: None,
}
}
pub fn with_auth(activation: A, auth: AuthContext) -> Self {
Self {
activation,
auth: Some(auth),
}
}
pub fn activation(&self) -> &A {
&self.activation
}
}
pub(crate) fn to_client_item(item: PlexusStreamItem) -> StreamItem {
fn meta(m: super::types::StreamMetadata) -> Option<StreamMetadata> {
Some(StreamMetadata {
provenance: m.provenance,
plexus_hash: m.plexus_hash,
timestamp: m.timestamp,
})
}
match item {
PlexusStreamItem::Data {
metadata,
content_type,
content,
} => StreamItem::Data {
metadata: meta(std::sync::Arc::unwrap_or_clone(metadata)),
content_type: Some(content_type.into_owned()),
content: content.into_value(),
},
PlexusStreamItem::Progress {
metadata,
message,
percentage,
} => StreamItem::Progress {
metadata: meta(metadata),
message,
percentage,
},
PlexusStreamItem::Error {
metadata,
message,
code,
recoverable,
..
} => StreamItem::Error {
metadata: meta(metadata),
message,
code,
recoverable,
},
PlexusStreamItem::Request {
request_id,
request_data,
timeout_ms,
} => StreamItem::Request {
request_id,
request_data,
timeout_ms,
},
PlexusStreamItem::Done { metadata } => StreamItem::Done {
metadata: meta(metadata),
},
}
}
impl<A: Activation> Transport for InProcessTransport<A> {
fn call(&self, method: MethodRef, params: Value) -> ItemStream<'_> {
if method.namespace() != self.activation.namespace() {
let msg = format!(
"InProcessTransport is bound to activation `{}`, but the call is for `{}`",
self.activation.namespace(),
method,
);
return Box::pin(futures::stream::once(async move {
Err(TransportError::protocol(msg))
}));
}
Box::pin(
futures::stream::once(async move {
match self
.activation
.call(method.method(), params, self.auth.as_ref(), None)
.await
{
Ok(stream) => stream.map(|item| Ok(to_client_item(item))).left_stream(),
Err(e) => futures::stream::once(async move {
Err(TransportError::other(e.to_string()))
})
.right_stream(),
}
})
.flatten(),
)
}
}