use std::collections::BTreeSet;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use orbit_events::{
DefaultEventLayout, EventLayout, FleetEvent, FleetEventBus,
FleetEventCursor,
};
use crate::inbox::{INTEREST_BITS, INTEREST_WORDS};
use crate::{DirectoryWatcher, Error, LinkSegment, Result, frame};
const INTEREST_TAG: &[u8] = b"events\0";
#[derive(Clone, Copy)]
pub enum Routing {
Topic,
Key(fn(&FleetEvent) -> Option<Vec<u8>>),
}
pub struct LinkEvents<L: EventLayout = DefaultEventLayout> {
segment: Arc<LinkSegment>,
entry: usize,
far: fn(&str) -> bool,
bus: Arc<FleetEventBus<L>>,
routing: Routing,
cursor: Mutex<FleetEventCursor>,
republished: Mutex<BTreeSet<u64>>,
dropped: AtomicU64,
lagged: AtomicU64,
}
impl<L: EventLayout> LinkEvents<L> {
pub fn for_lane(
segment: &Arc<LinkSegment>,
lane: usize,
bus: Arc<FleetEventBus<L>>,
far: fn(&str) -> bool,
routing: Routing,
) -> Result<Self> {
if segment.inbox().owner(lane)? != Some(std::process::id()) {
return Err(Error::Malformed(
"this process does not hold the lane",
));
}
Ok(Self::new(Arc::clone(segment), lane, bus, far, routing))
}
pub fn for_watcher(
watcher: &DirectoryWatcher,
bus: Arc<FleetEventBus<L>>,
far: fn(&str) -> bool,
routing: Routing,
) -> Self {
let segment = Arc::clone(watcher.segment());
let entry = segment.inbox().lanes() + watcher.slot();
Self::new(segment, entry, bus, far, routing)
}
fn new(
segment: Arc<LinkSegment>,
entry: usize,
bus: Arc<FleetEventBus<L>>,
far: fn(&str) -> bool,
routing: Routing,
) -> Self {
let cursor = Mutex::new(bus.cursor_at_head());
Self {
segment,
entry,
far,
bus,
routing,
cursor,
republished: Mutex::new(BTreeSet::new()),
dropped: AtomicU64::new(0),
lagged: AtomicU64::new(0),
}
}
pub fn interest<K: AsRef<[u8]>>(
&self,
keys: &[K],
) {
let mut bits = [0u64; INTEREST_WORDS];
for key in keys {
for bit in positions(INTEREST_TAG, key.as_ref()) {
bits[bit / 64] |= 1 << (bit % 64);
}
}
self.segment.inbox().write_interest(self.entry, &bits);
}
pub fn accept<'frame>(
&self,
frame: &'frame [u8],
) -> Result<(&'frame str, &'frame [u8])> {
let (topic, payload) = frame::decode_event(frame)?;
let id = self.bus.publish(topic, payload).map_err(Error::Events)?;
self.republished
.lock()
.map_err(|_| Error::Malformed("link event memory is poisoned"))?
.insert(id.counter());
Ok((topic, payload))
}
pub fn pump(&self) -> Result<()> {
let mut cursor = self
.cursor
.lock()
.map_err(|_| Error::Malformed("link event cursor is poisoned"))?;
let poll = self.bus.poll(&mut cursor);
if poll.lagged > 0 {
self.lagged.fetch_add(poll.lagged, Ordering::Relaxed);
}
let own = self.bus.node_id().get();
let mut frame = Vec::new();
for event in poll.events {
if event.id.node() != own || self.came_back(event.id.counter())? {
continue;
}
let key = match self.routing {
Routing::Topic => event.topic.as_bytes().to_vec(),
Routing::Key(extract) => match extract(&event) {
Some(key) => key,
None => continue,
},
};
if !self.far_wants(&key) {
continue;
}
if self.send(&event, &mut frame).is_err() {
self.dropped.fetch_add(1, Ordering::Relaxed);
}
}
Ok(())
}
#[cfg(any(
target_os = "linux",
target_os = "freebsd",
target_os = "macos"
))]
pub async fn drive(&self) -> Result<()> {
let event_fd = self.bus.event_fd().map_err(Error::Events)?;
let ready = unsafe { tokio::io::unix::AsyncFd::register(event_fd) }
.map_err(std::io::Error::from)
.map_err(Error::Io)?;
loop {
self.pump()?;
let mut guard = ready.readable().await.map_err(Error::Io)?;
ready.get_ref().drain().map_err(Error::Io)?;
guard.clear_ready();
}
}
pub fn dropped(&self) -> u64 {
self.dropped.load(Ordering::Relaxed)
}
pub fn lagged(&self) -> u64 {
self.lagged.load(Ordering::Relaxed)
}
fn came_back(
&self,
counter: u64,
) -> Result<bool> {
let mut republished = self
.republished
.lock()
.map_err(|_| Error::Malformed("link event memory is poisoned"))?;
let ours = republished.contains(&counter);
*republished = republished.split_off(&(counter + 1));
Ok(ours)
}
fn far_wants(
&self,
key: &[u8],
) -> bool {
let inbox = self.segment.inbox();
let lanes = inbox.lanes();
let mut union = [0u64; INTEREST_WORDS];
let mut merge = |entry: usize| {
for (word, bits) in union.iter_mut().zip(inbox.read_interest(entry))
{
*word |= bits;
}
};
for lane in 0..lanes {
if self.is_far_lane(lane) {
merge(lane);
}
}
for slot in 0..lanes {
if inbox
.watcher_role(slot)
.ok()
.flatten()
.is_some_and(|role| (self.far)(&role))
{
merge(lanes + slot);
}
}
positions(INTEREST_TAG, key)
.iter()
.all(|bit| union[bit / 64] & (1 << (bit % 64)) != 0)
}
fn is_far_lane(
&self,
lane: usize,
) -> bool {
let inbox = self.segment.inbox();
inbox.consumers(lane).is_ok_and(|consumers| consumers != 0)
&& inbox
.role(lane)
.ok()
.flatten()
.is_some_and(|role| (self.far)(&role))
}
fn send(
&self,
event: &FleetEvent,
frame: &mut Vec<u8>,
) -> Result<()> {
let inbox = self.segment.inbox();
let far: Vec<usize> =
(0..inbox.lanes()).filter(|lane| self.is_far_lane(*lane)).collect();
let Some((lane, _)) = inbox.ready(&far).into_iter().next() else {
for lane in far {
self.segment.reclaim_if_gone(lane)?;
}
return Err(Error::NoLane);
};
frame::encode_event(&event.topic, &event.payload, frame)?;
inbox.write(lane, frame)?;
Ok(())
}
}
impl<L: EventLayout> Drop for LinkEvents<L> {
fn drop(&mut self) {
self.segment.inbox().write_interest(self.entry, &[0; INTEREST_WORDS]);
}
}
fn positions(
tag: &[u8],
key: &[u8],
) -> [usize; 2] {
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
for byte in tag.iter().chain(key) {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
}
let bits = INTEREST_BITS as u64;
[(hash % bits) as usize, ((hash >> 32) % bits) as usize]
}