use std::cell::RefCell;
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use iceoryx2::prelude::*;
use rkyv::api::high::to_bytes_in;
use rkyv::util::AlignedVec;
use super::notify::Coalescer;
use super::open::{open_event_service, open_service, OpenMode};
use super::publish::{publish_until_delivered, try_publish};
use super::{
shared_node, transport_error, IoxEvent, IoxListener, IoxNotifier, IoxPubSub, IoxPublisher,
IoxSubscriber, MAX_LOANED_SAMPLES, MAX_SLICE_LEN, PROVIDER_WAIT_DEFAULT, REQUEST_NOTIFY_SUFFIX,
REQUEST_SUFFIX, RESPONSE_NOTIFY_SUFFIX, RESPONSE_SUFFIX,
};
use crate::global::Locked;
use crate::sync::lock;
use crate::types::{
fmt_correlation_id, normalize_wire_event, unbounded_channel, CallContext, Event, EventKind,
Observable, ObservableError, RpcError, RpcHeader, ServiceRef, TraceContext, WireEvent,
CORRELATION_ID_LEN,
};
type ResponseHandler = Arc<dyn Fn(EventKind, &[u8]) + Send + Sync>;
type HandlerMap = HashMap<[u8; CORRELATION_ID_LEN], ResponseHandler>;
fn release_handler(ports: &ConsumerPorts, cid: &[u8; CORRELATION_ID_LEN]) -> bool {
lock(&ports.handlers).remove(cid).is_some()
}
fn publish_cancel(ports: &ConsumerPorts, request: &RpcHeader) {
let header =
RpcHeader::cancel_from(request).with_seq(ports.seq.fetch_add(1, Ordering::Relaxed));
log::debug!(
"[transport] cancelling call {}",
fmt_correlation_id(&header.correlation_id)
);
publish_best_effort(ports, header);
if ports.last_request_notify.should_notify() {
let _ = ports
.request_notifier
.notify_with_custom_event_id(EventId::new(0));
}
}
fn publish_best_effort(ports: &ConsumerPorts, header: RpcHeader) {
match try_publish(&ports.publisher, header, &[]) {
Ok(_) => {}
Err(e) => log::debug!("[transport] best-effort sample not published: {e}"),
}
}
struct ConsumerPorts {
request_service: IoxPubSub,
_response_service: IoxPubSub,
_request_notify: IoxEvent,
_response_notify: IoxEvent,
subscriber: IoxSubscriber,
listener: IoxListener,
publisher: IoxPublisher,
request_notifier: IoxNotifier,
handlers: Mutex<HandlerMap>,
last_request_notify: Coalescer,
seq: AtomicU64,
}
fn consumer_cache() -> &'static Locked<HashMap<String, Arc<ConsumerPorts>>> {
static CACHE: Locked<HashMap<String, Arc<ConsumerPorts>>> = Locked::new();
&CACHE
}
pub(super) fn release_consumer_ports() -> usize {
consumer_cache().with(|cache| {
let count = cache.len();
cache.clear();
count
})
}
fn provider_wait_timeout() -> Duration {
std::env::var("ICE_RPC_PROVIDER_WAIT_MS")
.ok()
.and_then(|v| v.parse::<u64>().ok())
.map(Duration::from_millis)
.unwrap_or(PROVIDER_WAIT_DEFAULT)
}
fn consumer_ports(channel: &str) -> Result<Arc<ConsumerPorts>, RpcError> {
consumer_cache().with(|cache| {
if let Some(ports) = cache.get(channel) {
return Ok(ports.clone());
}
let ports = open_consumer_ports(channel)?;
cache.insert(channel.to_owned(), ports.clone());
Ok(ports)
})
}
fn open_consumer_ports(channel: &str) -> Result<Arc<ConsumerPorts>, RpcError> {
let node = shared_node()?;
let request_service = open_service(&node, channel, REQUEST_SUFFIX, OpenMode::CreateOrOpen)?;
let response_service = open_service(&node, channel, RESPONSE_SUFFIX, OpenMode::CreateOrOpen)?;
let request_notify = open_event_service(
&node,
channel,
REQUEST_NOTIFY_SUFFIX,
OpenMode::CreateOrOpen,
)?;
let response_notify = open_event_service(
&node,
channel,
RESPONSE_NOTIFY_SUFFIX,
OpenMode::CreateOrOpen,
)?;
let publisher = request_service
.publisher_builder()
.initial_max_slice_len(MAX_SLICE_LEN)
.max_loaned_samples(MAX_LOANED_SAMPLES)
.create()
.map_err(|e| transport_error("request publisher", e))?;
let request_notifier = request_notify
.notifier_builder()
.create()
.map_err(|e| transport_error("request notifier", e))?;
let subscriber = response_service
.subscriber_builder()
.create()
.map_err(|e| transport_error("response subscriber", e))?;
let listener = response_notify
.listener_builder()
.create()
.map_err(|e| transport_error("response listener", e))?;
let ports = Arc::new(ConsumerPorts {
request_service,
_response_service: response_service,
_request_notify: request_notify,
_response_notify: response_notify,
subscriber,
listener,
publisher,
request_notifier,
handlers: Mutex::new(HashMap::new()),
last_request_notify: Coalescer::new(),
seq: AtomicU64::new(0),
});
spawn_response_dispatcher(channel.to_owned(), Arc::clone(&ports));
Ok(ports)
}
fn spawn_response_dispatcher(channel: String, ports: Arc<ConsumerPorts>) {
let handle = crate::rt::spawn_blocking(move || {
let cancel = crate::global_cancel_token().clone();
super::pump::run_receive_loop(
&channel,
"response",
&ports.subscriber,
&ports.listener,
|| cancel.is_cancelled(),
|header, payload| {
let handler = lock(&ports.handlers).get(&header.correlation_id).cloned();
if let Some(handler) = handler {
handler(header.event_kind(), payload);
}
},
);
log::debug!("[transport] response dispatcher for '{channel}' stopped");
});
crate::locator::ServiceLocator::global().register_shutdown_handle(handle);
}
pub fn native_call<T, E>(
channel: &str,
service: ServiceRef,
method: &str,
payload: &[u8],
) -> Result<Observable<T, E>, RpcError>
where
T: Send + 'static,
E: Send + 'static,
WireEvent<T, E>: rkyv::Archive,
<WireEvent<T, E> as rkyv::Archive>::Archived: rkyv::Deserialize<
WireEvent<T, E>,
rkyv::rancor::Strategy<rkyv::de::Pool, rkyv::rancor::Error>,
>,
for<'a> <WireEvent<T, E> as rkyv::Archive>::Archived:
rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'a, rkyv::rancor::Error>>,
{
let ports = consumer_ports(channel)?;
let trace = match CallContext::current() {
Some(ctx) => ctx.child_trace(),
None => TraceContext::new_root(),
};
let header = RpcHeader::request(method, service.id, service.version)
.with_trace(trace)
.with_seq(ports.seq.fetch_add(1, Ordering::Relaxed));
let cid = header.correlation_id;
let (tx, rx) = unbounded_channel::<T, E>();
let handler_ports = Arc::clone(&ports);
let handler: ResponseHandler = Arc::new(move |kind: EventKind, bytes: &[u8]| {
if kind == EventKind::RpcError {
let error = match super::decode_aligned::<RpcError>(bytes) {
Ok(err) => err,
Err(e) => transport_error("decode rpc error", e),
};
let _ = tx.try_send_event(Event::Error(ObservableError::Technical(error)));
release_handler(&handler_ports, &cid);
return;
}
match super::decode_aligned::<WireEvent<T, E>>(bytes) {
Ok(wire) => {
let terminal = wire.is_terminal();
let (event, follow_up) = normalize_wire_event(wire);
if tx.try_send_event(event).is_err() {
release_handler(&handler_ports, &cid);
return;
}
if let Some(next) = follow_up {
let _ = tx.try_send_event(next);
}
if terminal {
release_handler(&handler_ports, &cid);
}
}
Err(e) => {
let _ = tx.try_send_event(Event::Error(ObservableError::Technical(
transport_error("decode response", e),
)));
release_handler(&handler_ports, &cid);
}
}
});
lock(&ports.handlers).insert(cid, handler);
if let Err(e) = publish_until_delivered(
&ports.publisher,
&ports.request_service,
header,
payload,
provider_wait_timeout(),
) {
release_handler(&ports, &cid);
return Err(e);
}
if ports.last_request_notify.should_notify() {
let _ = ports
.request_notifier
.notify_with_custom_event_id(EventId::new(0));
}
let cleanup_ports = Arc::clone(&ports);
Ok(rx.with_cleanup(move |terminated| {
let in_flight = release_handler(&cleanup_ports, &cid);
if !terminated && in_flight {
publish_cancel(&cleanup_ports, &header);
}
}))
}
thread_local! {
static REQUEST_SCRATCH: RefCell<AlignedVec<16>> =
RefCell::new(AlignedVec::<16>::with_capacity(256));
}
pub fn serialize_and_call<T, E, V>(
channel: &str,
service: ServiceRef,
method: &str,
request: &V,
) -> Result<Observable<T, E>, RpcError>
where
T: Send + 'static,
E: Send + 'static,
WireEvent<T, E>: rkyv::Archive,
<WireEvent<T, E> as rkyv::Archive>::Archived: rkyv::Deserialize<
WireEvent<T, E>,
rkyv::rancor::Strategy<rkyv::de::Pool, rkyv::rancor::Error>,
>,
for<'a> <WireEvent<T, E> as rkyv::Archive>::Archived:
rkyv::bytecheck::CheckBytes<rkyv::api::high::HighValidator<'a, rkyv::rancor::Error>>,
for<'a> V: rkyv::Serialize<
rkyv::rancor::Strategy<
rkyv::ser::Serializer<
rkyv::util::AlignedVec,
rkyv::ser::allocator::ArenaHandle<'a>,
rkyv::ser::sharing::Share,
>,
rkyv::rancor::Error,
>,
>,
{
REQUEST_SCRATCH.with(|cell| {
let mut buffer = match cell.try_borrow_mut() {
Ok(mut guard) => std::mem::replace(&mut *guard, AlignedVec::<16>::with_capacity(0)),
Err(_) => AlignedVec::<16>::with_capacity(256),
};
buffer.clear();
let encoded: Result<AlignedVec<16>, rkyv::rancor::Error> = to_bytes_in(request, buffer);
let bytes = match encoded {
Ok(bytes) => bytes,
Err(e) => {
log::error!("[ice-rpc] request serialization failed: {e:?}");
return Err(RpcError::SerializationError);
}
};
let call = native_call::<T, E>(channel, service, method, &bytes);
if let Ok(mut guard) = cell.try_borrow_mut() {
*guard = bytes;
}
call
})
}