use std::time::{Duration, Instant};
use iceoryx2::prelude::*;
use iceoryx2_bb_posix::signal::SignalHandler;
use super::{IoxPubSub, IoxPublisher, PUBLISH_RETRY_SLEEP, PUBLISH_SPIN_ATTEMPTS, transport_error};
use crate::types::{RpcError, RpcHeader};
pub(super) fn publish_until_delivered(
publisher: &IoxPublisher,
service: &IoxPubSub,
header: RpcHeader,
payload: &[u8],
timeout: Duration,
) -> Result<(), RpcError> {
let deadline = Instant::now() + timeout;
let mut attempts: u32 = 0;
loop {
if shutdown_requested() {
return Err(RpcError::Cancelled);
}
if service.dynamic_config().number_of_subscribers() == 0 {
if Instant::now() >= deadline {
return Err(RpcError::TransportError(
"no subscriber connected (is the provider running?)".to_string(),
));
}
backoff(&mut attempts)?;
continue;
}
if try_publish(publisher, header, payload)? {
return Ok(());
}
if Instant::now() >= deadline {
return Err(RpcError::TransportError(
"delivery refused: the subscriber buffer stayed full".to_string(),
));
}
backoff(&mut attempts)?;
}
}
fn shutdown_requested() -> bool {
crate::global_cancel_token().is_cancelled() || crate::registry_cancel_token().is_cancelled()
}
fn backoff(attempts: &mut u32) -> Result<(), RpcError> {
if *attempts < PUBLISH_SPIN_ATTEMPTS {
*attempts += 1;
std::thread::yield_now();
return Ok(());
}
if SignalHandler::termination_requested() {
crate::request_shutdown();
return Err(RpcError::Cancelled);
}
std::thread::sleep(PUBLISH_RETRY_SLEEP);
Ok(())
}
pub(super) fn try_publish(
publisher: &IoxPublisher,
header: RpcHeader,
payload: &[u8],
) -> Result<bool, RpcError> {
const EMPTY: [u8; 1] = [0];
let payload = if payload.is_empty() {
&EMPTY[..]
} else {
payload
};
let sample = publisher
.loan_slice_uninit(payload.len())
.map_err(|e| transport_error("loan sample", e))?;
let mut sample = sample.write_from_slice(payload);
*sample.user_header_mut() = header;
let delivered = sample
.send()
.map_err(|e| transport_error("send sample", e))?;
Ok(delivered > 0)
}
#[cfg(test)]
mod tests {
use super::super::open::{OpenMode, open_service};
use super::super::{DEFAULT_MAX_SLICE_LEN, REQUEST_SUFFIX, shared_node};
use super::*;
#[test]
fn try_publish_reports_whether_anyone_received_the_sample() {
let node = shared_node().expect("the process node");
let channel = format!("UnitPublish{}", std::process::id());
let service = open_service(&node, &channel, REQUEST_SUFFIX, OpenMode::CreateOrOpen)
.expect("the channel is created");
let publisher = service
.publisher_builder()
.initial_max_slice_len(DEFAULT_MAX_SLICE_LEN)
.create()
.expect("a publisher");
let header = RpcHeader::default();
assert!(!try_publish(&publisher, header, b"data").expect("publish a sample"));
assert!(!try_publish(&publisher, header, b"").expect("publish an empty sample"));
let _subscriber = service.subscriber_builder().create().expect("a subscriber");
assert!(try_publish(&publisher, header, b"data").expect("publish a sample"));
}
}