use std::borrow::Cow;
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> {
let pid = orbit_core::process::ProcessOwner::current()?.pid();
if segment.inbox().owner(lane)? != Some(pid) {
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();
let mut far_side: Option<FarSide> = None;
for event in poll.events {
if event.id.node() != own || self.came_back(event.id.counter())? {
continue;
}
let key = match self.routing {
Routing::Topic => Cow::Borrowed(event.topic.as_bytes()),
Routing::Key(extract) => match extract(&event) {
Some(key) => Cow::Owned(key),
None => continue,
},
};
let side = far_side.get_or_insert_with(|| self.far_side());
if !side.wants(&key) {
continue;
}
if self.send(&event, &side.lanes, &mut frame).is_err() {
self.dropped.fetch_add(1, Ordering::Relaxed);
far_side = None;
}
}
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)?;
guard.clear_ready();
ready.get_ref().drain().map_err(Error::Io)?;
}
}
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);
while republished.first().is_some_and(|first| *first <= counter) {
republished.pop_first();
}
Ok(ours)
}
fn far_side(&self) -> FarSide {
let inbox = self.segment.inbox();
let lanes = inbox.lanes();
let far: Vec<usize> =
(0..lanes).filter(|lane| self.is_far_lane(*lane)).collect();
let mut interest = [0u64; INTEREST_WORDS];
let mut merge = |entry: usize| {
for (word, bits) in
interest.iter_mut().zip(inbox.read_interest(entry))
{
*word |= bits;
}
};
for &lane in &far {
merge(lane);
}
for slot in 0..lanes {
if inbox.watcher_role_accepted(slot, self.far) {
merge(lanes + slot);
}
}
FarSide { lanes: far, interest }
}
fn is_far_lane(
&self,
lane: usize,
) -> bool {
let inbox = self.segment.inbox();
inbox.consumers(lane).is_ok_and(|consumers| consumers != 0)
&& inbox.role_accepted(lane, self.far)
}
fn send(
&self,
event: &FleetEvent,
far: &[usize],
frame: &mut Vec<u8>,
) -> Result<()> {
let inbox = self.segment.inbox();
let Some((lane, _)) = inbox.idlest(far) 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]);
}
}
struct FarSide {
lanes: Vec<usize>,
interest: [u64; INTEREST_WORDS],
}
impl FarSide {
fn wants(
&self,
key: &[u8],
) -> bool {
positions(INTEREST_TAG, key)
.iter()
.all(|bit| self.interest[bit / 64] & (1 << (bit % 64)) != 0)
}
}
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]
}