use std::sync::Arc;
use crate::{LinkSegment, Result};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Received {
Frame,
Work(crate::WorkTicket),
Capacity(u64),
Event,
Directory(u64),
}
pub struct InboxReceiver {
segment: Arc<LinkSegment>,
lane: usize,
socket: tokio::net::UnixDatagram,
directory: u64,
capacity: u64,
}
impl InboxReceiver {
pub(crate) fn bind(
segment: Arc<LinkSegment>,
lane: usize,
) -> Result<Self> {
let socket = segment.inbox().bind_receiver(lane)?;
let directory = segment.inbox().directory();
let capacity = segment.inbox().capacity_generation(lane)?;
Ok(Self { segment, lane, socket, directory, capacity })
}
pub async fn recv(
&mut self,
out: &mut Vec<u8>,
) -> Result<()> {
loop {
match self.next(out).await? {
Received::Directory(_) | Received::Capacity(_) => {}
Received::Work(ticket) => {
self.segment.inbox().cancel_work(ticket);
return Err(crate::Error::Malformed(
"work frames require an admission-aware receiver",
));
}
Received::Frame | Received::Event => return Ok(()),
}
}
}
pub async fn next(
&mut self,
out: &mut Vec<u8>,
) -> Result<Received> {
let inbox = self.segment.inbox();
loop {
let directory = inbox.directory();
if directory != self.directory {
self.directory = directory;
return Ok(Received::Directory(directory));
}
let seen = inbox.receiver_generation(self.lane)?;
let capacity = inbox.capacity_generation(self.lane)?;
if capacity != self.capacity {
self.capacity = capacity;
return Ok(Received::Capacity(capacity));
}
if let Some(work) = inbox.read_frame(self.lane, out)? {
return Ok(if let Some(ticket) = work {
Received::Work(ticket)
} else if crate::frame::is_event(out) {
Received::Event
} else {
Received::Frame
});
}
inbox.disarm_receiver(self.lane);
crate::bell::drain(&self.socket)?;
inbox.arm_receiver(self.lane)?;
if inbox.receiver_generation(self.lane)? != seen
|| inbox.directory() != self.directory
{
inbox.disarm_receiver(self.lane);
continue;
}
self.socket.readable().await?;
let mut scratch = [0u8; 64];
while self.socket.try_recv(&mut scratch).is_ok() {}
}
}
pub fn lane(&self) -> usize {
self.lane
}
}
#[cfg(test)]
#[path = "../tests/unit/receiver.rs"]
mod tests;
impl Drop for InboxReceiver {
fn drop(&mut self) {
self.segment.inbox().unbind_receiver(self.lane);
self.segment.release_receiver(self.lane);
}
}