use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;
#[doc(hidden)]
pub struct RenderValue<T>(pub T);
#[doc(hidden)]
pub trait RenderViaDisplay {
fn render(&self) -> String;
}
impl<T: fmt::Display> RenderViaDisplay for RenderValue<T> {
fn render(&self) -> String {
self.0.to_string()
}
}
#[doc(hidden)]
pub trait RenderViaDebug {
fn render(&self) -> String;
}
impl<T: fmt::Debug> RenderViaDebug for &RenderValue<T> {
fn render(&self) -> String {
format!("{:?}", self.0)
}
}
#[doc(hidden)]
#[macro_export]
macro_rules! render_value {
($value:expr) => {{
#[allow(unused_imports)]
use $crate::monitor::{RenderViaDebug as _, RenderViaDisplay as _};
(&$crate::monitor::RenderValue($value)).render()
}};
}
pub fn decode_request<R>(payload: &[u8]) -> Option<String>
where
R: rkyv::Archive + std::fmt::Display,
<R as rkyv::Archive>::Archived:
rkyv::Deserialize<R, rkyv::rancor::Strategy<rkyv::de::Pool, rkyv::rancor::Error>>,
for<'a> <R as rkyv::Archive>::Archived:
rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'a, rkyv::rancor::Error>>,
{
crate::transport::decode_aligned::<R>(payload)
.ok()
.map(|value| value.to_string())
}
pub fn decode_response<T, E>(
payload: &[u8],
render_ok: impl Fn(&T) -> String,
render_err: impl Fn(&E) -> String,
) -> Option<String>
where
crate::types::WireEvent<T, E>: rkyv::Archive,
<crate::types::WireEvent<T, E> as rkyv::Archive>::Archived: rkyv::Deserialize<
crate::types::WireEvent<T, E>,
rkyv::rancor::Strategy<rkyv::de::Pool, rkyv::rancor::Error>,
>,
for<'a> <crate::types::WireEvent<T, E> as rkyv::Archive>::Archived:
rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'a, rkyv::rancor::Error>>,
{
use crate::types::WireEvent;
crate::transport::decode_aligned::<WireEvent<T, E>>(payload)
.ok()
.map(|event| match event {
WireEvent::Next(value) | WireEvent::CompleteWith(value) => render_ok(&value),
WireEvent::Complete => "complete".to_owned(),
WireEvent::Error(error) => format!("error: {}", render_err(&error)),
WireEvent::RpcError(error) => format!("rpc error: {error}"),
})
}
pub fn decode_response_unit<E>(payload: &[u8], render_err: impl Fn(&E) -> String) -> Option<String>
where
crate::types::WireEvent<(), E>: rkyv::Archive,
<crate::types::WireEvent<(), E> as rkyv::Archive>::Archived: rkyv::Deserialize<
crate::types::WireEvent<(), E>,
rkyv::rancor::Strategy<rkyv::de::Pool, rkyv::rancor::Error>,
>,
for<'a> <crate::types::WireEvent<(), E> as rkyv::Archive>::Archived:
rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'a, rkyv::rancor::Error>>,
{
use crate::types::WireEvent;
crate::transport::decode_aligned::<WireEvent<(), E>>(payload)
.ok()
.map(|event| match event {
WireEvent::Next(()) | WireEvent::CompleteWith(()) => "()".to_owned(),
WireEvent::Complete => "complete".to_owned(),
WireEvent::Error(error) => format!("error: {}", render_err(&error)),
WireEvent::RpcError(error) => format!("rpc error: {error}"),
})
}
pub trait ServiceDecoder: Send + Sync {
fn request(&self, method: &str, payload: &[u8]) -> Option<String>;
fn response(&self, method: &str, payload: &[u8]) -> Option<String>;
}
type Render = Box<dyn Fn(&str, &[u8]) -> Option<String> + Send + Sync>;
pub struct ClosureDecoder {
request: Render,
response: Render,
}
impl ClosureDecoder {
pub fn new(
request: impl Fn(&str, &[u8]) -> Option<String> + Send + Sync + 'static,
response: impl Fn(&str, &[u8]) -> Option<String> + Send + Sync + 'static,
) -> Self {
Self {
request: Box::new(request),
response: Box::new(response),
}
}
}
impl ServiceDecoder for ClosureDecoder {
fn request(&self, method: &str, payload: &[u8]) -> Option<String> {
(self.request)(method, payload)
}
fn response(&self, method: &str, payload: &[u8]) -> Option<String> {
(self.response)(method, payload)
}
}
#[derive(Default)]
pub struct Decoders {
services: HashMap<u32, Arc<dyn ServiceDecoder>>,
}
impl Decoders {
pub fn new() -> Self {
Self::default()
}
pub fn register(&mut self, service_id: u32, decoder: Arc<dyn ServiceDecoder>) -> &mut Self {
self.services.insert(service_id, decoder);
self
}
pub fn len(&self) -> usize {
self.services.len()
}
pub fn is_empty(&self) -> bool {
self.services.is_empty()
}
pub fn request(&self, service_id: u32, method: &str, payload: &[u8]) -> Option<String> {
self.services.get(&service_id)?.request(method, payload)
}
pub fn response(&self, service_id: u32, method: &str, payload: &[u8]) -> Option<String> {
self.services.get(&service_id)?.response(method, payload)
}
}
impl fmt::Debug for Decoders {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Decoders")
.field("services", &self.services.len())
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
use rkyv::{Archive, Deserialize, Serialize};
#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
struct Reply {
value: i32,
}
impl fmt::Display for Reply {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "value={}", self.value)
}
}
#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
enum DebugOnly {
Nok,
}
#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
enum Request {
Add { a: i32, b: i32 },
Echo { text: String },
Probe { status: DebugOnly },
}
impl fmt::Display for Request {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Request::Add { a, b } => {
write!(f, "add(a={}, b={})", render_value!(a), render_value!(b))
}
Request::Echo { text } => write!(f, "echo(text={})", render_value!(text)),
Request::Probe { status } => write!(f, "probe(status={})", render_value!(status)),
}
}
}
fn encode<T>(value: &T) -> Vec<u8>
where
T: for<'a> rkyv::Serialize<
rkyv::rancor::Strategy<
rkyv::ser::Serializer<
rkyv::util::AlignedVec,
rkyv::ser::allocator::ArenaHandle<'a>,
rkyv::ser::sharing::Share,
>,
rkyv::rancor::Error,
>,
>,
{
rkyv::to_bytes::<rkyv::rancor::Error>(value)
.expect("encode")
.to_vec()
}
#[test]
fn requests_and_responses_decode_through_display() {
let request = encode(&Request::Add { a: 1, b: 2 });
assert_eq!(
decode_request::<Request>(&request).as_deref(),
Some("add(a=1, b=2)")
);
let echo = encode(&Request::Echo {
text: String::from("hi"),
});
assert_eq!(
decode_request::<Request>(&echo).as_deref(),
Some("echo(text=hi)")
);
let probe = encode(&Request::Probe {
status: DebugOnly::Nok,
});
assert_eq!(
decode_request::<Request>(&probe).as_deref(),
Some("probe(status=Nok)")
);
let response = encode(&crate::types::WireEvent::<Reply, String>::Next(Reply {
value: 7,
}));
assert_eq!(
decode_response::<Reply, String>(
&response,
|value| render_value!(value),
|error| render_value!(error)
)
.as_deref(),
Some("value=7")
);
let unit = encode(&crate::types::WireEvent::<(), String>::Complete);
assert_eq!(
decode_response_unit::<String>(&unit, |error| render_value!(error)).as_deref(),
Some("complete")
);
}
#[test]
fn rendering_falls_back_to_debug_without_display() {
assert_eq!(render_value!(&DebugOnly::Nok), "Nok");
assert_eq!(render_value!(&Reply { value: 7 }), "value=7");
assert_eq!(render_value!(&String::from("hi")), "hi");
let next = encode(&crate::types::WireEvent::<DebugOnly, String>::Next(
DebugOnly::Nok,
));
assert_eq!(
decode_response::<DebugOnly, String>(
&next,
|value| render_value!(value),
|error| render_value!(error)
)
.as_deref(),
Some("Nok")
);
let response = encode(&crate::types::WireEvent::<DebugOnly, String>::Error(
String::from("boom"),
));
assert_eq!(
decode_response::<DebugOnly, String>(
&response,
|value| render_value!(value),
|error| render_value!(error)
)
.as_deref(),
Some("error: boom")
);
}
#[test]
fn garbage_does_not_decode() {
assert_eq!(decode_request::<Request>(&[0xff, 0x00]), None);
assert_eq!(
decode_response::<Reply, String>(
&[0xff, 0x00],
|value| render_value!(value),
|error| render_value!(error)
),
None
);
}
#[test]
fn a_registered_decoder_renders_both_directions() {
let mut decoders = Decoders::new();
decoders.register(
7,
Arc::new(ClosureDecoder::new(
|_method, payload| Some(String::from_utf8_lossy(payload).into_owned()),
|_method, payload| Some(format!("{} bytes", payload.len())),
)),
);
assert_eq!(decoders.request(7, "echo", b"hi").as_deref(), Some("hi"));
assert_eq!(
decoders.response(7, "echo", b"abcd").as_deref(),
Some("4 bytes")
);
assert_eq!(decoders.request(9, "echo", b"hi"), None);
}
}