use std::time::{Duration, Instant};
use iceoryx2::prelude::*;
use iceoryx2_bb_posix::signal::SignalHandler;
use super::{transport_error, IoxPubSub, IoxPublisher, PUBLISH_RETRY_SLEEP, PUBLISH_SPIN_ATTEMPTS};
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> {
let len = payload.len().max(1);
let sample = publisher
.loan_slice_uninit(len)
.map_err(|e| transport_error("loan sample", e))?;
let mut sample = sample.write_from_fn(|i| payload.get(i).copied().unwrap_or(0));
*sample.user_header_mut() = header;
let delivered = sample
.send()
.map_err(|e| transport_error("send sample", e))?;
Ok(delivered > 0)
}