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: Option<tokio::net::UnixDatagram>,
directory: u64,
capacity: u64,
armed: bool,
owed: u32,
}
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: Some(socket),
directory,
capacity,
armed: false,
owed: 0,
})
}
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> {
Ok(self.next_inner(Some(out), None).await?.expect("no read boundary"))
}
pub async fn next_until_read(
&mut self,
out: &mut Vec<u8>,
boundary: u64,
) -> Result<Option<Received>> {
self.next_inner(Some(out), Some(boundary)).await
}
pub async fn next_notification(&mut self) -> Result<Received> {
Ok(self.next_inner(None, None).await?.expect("no read boundary"))
}
async fn next_inner(
&mut self,
mut out: Option<&mut Vec<u8>>,
boundary: Option<u64>,
) -> Result<Option<Received>> {
self.lower();
loop {
let inbox = self.segment.inbox();
let directory = inbox.directory();
if directory != self.directory {
self.directory = directory;
return Ok(Some(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(Some(Received::Capacity(capacity)));
}
if let Some(out) = out.as_deref_mut()
&& let Some(work) =
inbox.read_frame_before(self.lane, out, boundary)?
{
return Ok(Some(if let Some(ticket) = work {
Received::Work(ticket)
} else if crate::frame::is_event(out) {
Received::Event
} else {
Received::Frame
}));
}
if let Some(boundary) = boundary
&& inbox.read_position(self.lane)? >= boundary
{
return Ok(None);
}
self.settle()?;
let inbox = self.segment.inbox();
inbox.arm_receiver(self.lane)?;
self.armed = true;
if inbox.receiver_generation(self.lane)? != seen
|| inbox.directory() != self.directory
{
self.lower();
continue;
}
self.socket().readable().await?;
self.lower();
if self.owed == 0 {
crate::bell::drain(self.socket())?;
}
}
}
fn lower(&mut self) {
if std::mem::take(&mut self.armed)
&& !self.segment.inbox().take_receiver_arm(self.lane)
{
self.owed += 1;
}
}
fn settle(&mut self) -> std::io::Result<()> {
if self.owed == 0 {
return Ok(());
}
while self.owed > 0 && crate::bell::take_one(self.socket())? {
self.owed -= 1;
}
crate::bell::forget_readiness(self.socket());
Ok(())
}
fn socket(&self) -> &tokio::net::UnixDatagram {
self.socket.as_ref().expect("a live receiver owns its socket")
}
fn close(
&mut self,
release: impl FnOnce(&LinkSegment, usize),
) {
let Some(socket) = self.socket.take() else {
return;
};
self.segment.inbox().unbind_receiver(self.lane);
drop(socket);
release(&self.segment, self.lane);
}
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.close(LinkSegment::release_receiver);
}
}