use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use crate::entry::TaskEnvelope;
use crate::queue::{
channel, ConsumerPoll, Reservation, ReserveError, SequencedReceiver, SequencedSender,
};
use crate::route::TaskType;
pub(crate) struct NonStrictTunnel {
id: u64,
runner_id: u64,
generation: u64,
source: u32,
target: u32,
task_type: TaskType,
sender: SequencedSender<Arc<TaskEnvelope>>,
receiver: Mutex<SequencedReceiver<Arc<TaskEnvelope>>>,
accepting: AtomicBool,
depth: AtomicUsize,
lease_nanos: u64,
expires_at_nanos: AtomicU64,
clock_origin: Instant,
}
impl NonStrictTunnel {
pub(crate) fn new(
id: u64,
runner_id: u64,
generation: u64,
source: u32,
target: u32,
task_type: TaskType,
lease: Duration,
) -> Arc<Self> {
let (sender, receiver) = channel();
let lease_nanos = u64::try_from(lease.as_nanos()).unwrap_or(u64::MAX);
Arc::new(Self {
id,
runner_id,
generation,
source,
target,
task_type,
sender,
receiver: Mutex::new(receiver),
accepting: AtomicBool::new(true),
depth: AtomicUsize::new(0),
lease_nanos,
expires_at_nanos: AtomicU64::new(lease_nanos),
clock_origin: Instant::now(),
})
}
pub(crate) fn id(&self) -> u64 {
self.id
}
pub(crate) fn runner_id(&self) -> u64 {
self.runner_id
}
pub(crate) fn generation(&self) -> u64 {
self.generation
}
pub(crate) fn source(&self) -> u32 {
self.source
}
pub(crate) fn target(&self) -> u32 {
self.target
}
pub(crate) fn task_type(&self) -> TaskType {
self.task_type
}
pub(crate) fn accepting(&self) -> bool {
self.accepting.load(Ordering::Acquire) && !self.expired()
}
pub(crate) fn reserve(&self) -> Result<Reservation<Arc<TaskEnvelope>>, ReserveError> {
if !self.accepting() {
return Err(ReserveError::Closed);
}
let reservation = self.sender.reserve()?;
self.depth.fetch_add(1, Ordering::AcqRel);
Ok(reservation)
}
pub(crate) fn commit_reserved(&self) -> usize {
self.renew();
self.depth.load(Ordering::Acquire)
}
pub(crate) fn abort_reserved(&self) {
let decremented = self
.depth
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |value| {
value.checked_sub(1)
})
.is_ok();
debug_assert!(decremented, "non-strict FIFO depth authority lost");
self.close();
}
pub(crate) fn poll(&self) -> ConsumerPoll<Arc<TaskEnvelope>> {
let result = self
.receiver
.lock()
.unwrap_or_else(|e| e.into_inner())
.try_recv();
if matches!(
result,
ConsumerPoll::Item { .. } | ConsumerPoll::Poisoned { .. }
) {
let decremented = self
.depth
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |value| {
value.checked_sub(1)
})
.is_ok();
debug_assert!(decremented, "non-strict FIFO depth authority lost");
self.renew();
}
result
}
pub(crate) fn close(&self) {
self.accepting.store(false, Ordering::Release);
self.sender.close();
}
pub(crate) fn close_if_expired(&self) -> bool {
if self.expired() {
self.close();
}
!self.accepting.load(Ordering::Acquire)
}
pub(crate) fn drained(&self) -> bool {
!self.accepting.load(Ordering::Acquire)
&& self.depth() == 0
&& self.sender.producer_inflight() == 0
&& self.sender.outstanding_reservations() == 0
}
pub(crate) fn depth(&self) -> usize {
self.depth.load(Ordering::Acquire)
}
pub(crate) fn producer_inflight(&self) -> usize {
self.sender
.producer_inflight()
.saturating_add(self.sender.outstanding_reservations())
}
fn renew(&self) {
let now = self.elapsed_nanos();
self.expires_at_nanos
.store(now.saturating_add(self.lease_nanos), Ordering::Release);
}
fn expired(&self) -> bool {
self.elapsed_nanos() >= self.expires_at_nanos.load(Ordering::Acquire)
}
fn elapsed_nanos(&self) -> u64 {
u64::try_from(self.clock_origin.elapsed().as_nanos()).unwrap_or(u64::MAX)
}
}