#[cfg(feature = "tokio")]
use std::collections::HashSet;
use std::sync::{Arc, Mutex};
#[cfg(feature = "tokio")]
use orbit_core::shm::try_hold_watcher;
use orbit_core::shm::{LaneHold, ShmRegion, ring_segment_name, try_hold_lane};
use super::{Error, Inbox, LinkSpec, Reclaimed, Result};
pub struct LinkSegment {
region: ShmRegion,
inbox: Inbox,
name: String,
fleet_name: String,
spec: LinkSpec,
group: Option<orbit_core::shm::GroupAccess>,
reclaimed: Mutex<Vec<Reclaimed>>,
#[cfg(feature = "tokio")]
receivers: Mutex<HashSet<usize>>,
}
pub struct Joined {
pub lane: usize,
pub hold: LaneHold,
pub reclaimed: Vec<Reclaimed>,
}
impl LinkSegment {
pub fn open(
name: &str,
spec: LinkSpec,
) -> Result<Self> {
Self::open_inner(name, spec, None)
}
pub fn open_group(
name: &str,
spec: LinkSpec,
access: orbit_core::shm::GroupAccess,
) -> Result<Self> {
Self::open_inner(name, spec, Some(access))
}
fn open_inner(
name: &str,
spec: LinkSpec,
group: Option<orbit_core::shm::GroupAccess>,
) -> Result<Self> {
spec.validate()?;
let segment_name = if let Some(access) = &group {
validate_name(name)?;
let segment = access.segment_name(name, spec.inbox_kind);
crate::bell::Bell::validate_group_address(
access,
&segment,
usize::from(spec.fleet_capacity - 1),
)
.map_err(Error::Io)?;
access
.prepare_locks(&segment, 3 * usize::from(spec.fleet_capacity))
.map_err(Error::Io)?;
orbit_stream::Streams::prepare_group(
name,
spec.fleet_capacity,
spec.streams,
access.clone(),
)?;
segment
} else {
check_name(name, spec)?;
ring_segment_name(name, spec.inbox_kind)
};
let bytes = spec.inbox_segment_bytes();
let (region, lock) = match &group {
Some(access) => access.open_region(&segment_name, bytes)?,
None => ShmRegion::open_or_create_locked(&segment_name, bytes)?,
};
let mut inbox = if region.created() {
unsafe {
Inbox::initialize(
region.as_ptr(),
spec.fleet_capacity as usize,
spec.inbox,
)?
}
} else {
unsafe {
Inbox::attach(
region.as_ptr(),
spec.fleet_capacity as usize,
spec.inbox,
)?
}
};
inbox.install_bell_with_group(&segment_name, group.clone())?;
let mut segment = Self {
region,
inbox,
name: segment_name,
fleet_name: name.to_owned(),
spec,
group,
reclaimed: Mutex::new(Vec::new()),
#[cfg(feature = "tokio")]
receivers: Mutex::new(HashSet::new()),
};
if let Err(error) = segment.register_producer() {
if !matches!(error, Error::InboxFull) {
return Err(error);
}
let reclaimed = segment.recover_abandoned()?;
*segment.reclaimed.get_mut().map_err(|_| {
Error::Malformed("Link recovery observations are poisoned")
})? = reclaimed;
segment.register_producer()?;
}
drop(lock);
Ok(segment)
}
fn register_producer(&mut self) -> Result<()> {
let lanes = usize::from(self.spec.fleet_capacity);
let name = &self.name;
let group = &self.group;
self.inbox.register_producer(|index| {
match group {
Some(access) => access.try_hold_lane(name, lanes + index),
None => try_hold_lane(name, lanes + index),
}
.map_err(Error::Io)
})
}
pub fn join(
&self,
service: &str,
role: &str,
incarnation: u64,
) -> Result<Joined> {
let recovered = self.recover_abandoned()?;
let (lane, hold) =
self.inbox.join(service, role, incarnation, |lane| {
let Some(hold) = self.hold(lane)? else { return Ok(None) };
if let Some((_, previous)) = self.inbox.last_owner(lane)? {
self.recover_streams(lane, previous)?;
}
Ok(Some(hold))
})?;
let mut reclaimed =
std::mem::take(&mut *self.reclaimed.lock().map_err(|_| {
Error::Malformed("Link recovery observations are poisoned")
})?);
for gone in recovered {
if !reclaimed.contains(&gone) {
reclaimed.push(gone);
}
}
Ok(Joined { lane, hold, reclaimed })
}
fn recover_abandoned(&self) -> Result<Vec<Reclaimed>> {
self.recover_producers(None)?;
let mut reclaimed = Vec::new();
for lane in 0..self.inbox.lanes() {
if let Some(gone) = self.recover_lane(lane, |gone| {
self.recover_streams(gone.lane, gone.incarnation)
})? {
reclaimed.push(gone);
}
}
Ok(reclaimed)
}
fn recover_streams(
&self,
lane: usize,
incarnation: u64,
) -> Result<()> {
if let Some(access) = &self.group {
return orbit_stream::Streams::node_dead_in_group(
&self.fleet_name,
self.spec.fleet_capacity,
self.spec.streams,
orbit_core::NodeId::new(lane as u16),
orbit_stream::Incarnation::new(incarnation),
access.clone(),
)
.map_err(Error::Stream);
}
orbit_stream::Streams::node_dead_in_shm(
&self.fleet_name,
self.spec.fleet_capacity,
self.spec.streams,
orbit_core::NodeId::new(lane as u16),
orbit_stream::Incarnation::new(incarnation),
)
.map(|_| ())
.map_err(Error::Stream)
}
pub fn reclaim_if_gone(
&self,
lane: usize,
) -> Result<Option<Reclaimed>> {
self.reclaim_if_gone_with(lane, |_| {})
}
pub fn reclaim_if_gone_with(
&self,
lane: usize,
recover: impl FnOnce(&Reclaimed),
) -> Result<Option<Reclaimed>> {
self.recover_lane(lane, |gone| {
recover(gone);
Ok(())
})
}
fn recover_lane(
&self,
lane: usize,
recover: impl FnOnce(&Reclaimed) -> Result<()>,
) -> Result<Option<Reclaimed>> {
if self.inbox.consumers(lane)? == 0 && self.inbox.depth(lane)? == 0 {
return Ok(None);
}
match self.hold(lane)? {
Some(_gone) => {
let gone = match self.inbox.reclaim(lane)? {
Some(gone) => Some(gone),
None => self.inbox.last_owner(lane)?.map(
|(pid, incarnation)| Reclaimed {
lane,
pid,
incarnation,
},
),
};
if let Some(gone) = &gone {
recover(gone)?;
}
self.inbox.retire_lane(lane)?;
Ok(gone)
}
None => Ok(None),
}
}
pub fn reclaim_process(
&self,
pid: u32,
incarnation: u64,
mut recover: impl FnMut(&Reclaimed),
) -> Result<Vec<Reclaimed>> {
self.recover_producers(Some(pid))?;
let mut reclaimed = Vec::new();
for lane in 0..self.inbox.lanes() {
if self.inbox.last_owner(lane)? != Some((pid, incarnation)) {
continue;
}
let Some(_hold) = self.hold(lane)? else { continue };
if self.inbox.last_owner(lane)? != Some((pid, incarnation)) {
continue;
}
if self.inbox.consumers(lane)? != 0 {
self.inbox.release_lane(lane)?;
}
let gone = Reclaimed { lane, pid, incarnation };
recover(&gone);
self.inbox.retire_lane(lane)?;
reclaimed.push(gone);
}
Ok(reclaimed)
}
pub fn recover_producers(
&self,
pid: Option<u32>,
) -> Result<()> {
self.inbox.recover_producers(pid, |index| {
self.hold(self.inbox.lanes() + index)
})
}
fn hold(
&self,
lane: usize,
) -> Result<Option<LaneHold>> {
match &self.group {
Some(access) => access.try_hold_lane(&self.name, lane),
None => try_hold_lane(&self.name, lane),
}
.map_err(Error::Io)
}
pub fn inbox(&self) -> &Inbox {
&self.inbox
}
#[cfg(feature = "tokio")]
pub fn receiver(
self: &Arc<Self>,
lane: usize,
) -> Result<crate::InboxReceiver> {
self.inbox.wait_word(lane)?;
let mut held = self.receivers.lock().map_err(|_| {
Error::Malformed(
"the process-local inbox receiver registry is poisoned",
)
})?;
if !held.insert(lane) {
return Err(Error::Malformed(
"this process already receives the inbox lane",
));
}
drop(held);
match crate::InboxReceiver::bind(Arc::clone(self), lane) {
Ok(receiver) => Ok(receiver),
Err(error) => {
self.release_receiver(lane);
Err(error)
}
}
}
#[cfg(feature = "tokio")]
pub fn watch(
self: &Arc<Self>,
role: &str,
) -> Result<crate::DirectoryWatcher> {
for slot in 0..self.inbox.lanes() {
let Some(hold) = match &self.group {
Some(access) => access.try_hold_watcher(&self.name, slot),
None => try_hold_watcher(&self.name, slot),
}
.map_err(Error::Io)?
else {
continue;
};
return crate::DirectoryWatcher::bind(
Arc::clone(self),
slot,
role,
hold,
);
}
Err(Error::NoWatcher)
}
#[cfg(feature = "tokio")]
pub(crate) fn release_receiver(
&self,
lane: usize,
) {
if let Ok(mut held) = self.receivers.lock() {
held.remove(&lane);
}
}
pub fn spec(&self) -> LinkSpec {
self.spec
}
pub fn bodies(
&self,
lane: usize,
incarnation: u64,
) -> Result<super::LinkBodies> {
match &self.group {
Some(access) => super::LinkBodies::for_group(
&self.fleet_name,
lane,
incarnation,
self.spec,
access.clone(),
),
None => super::LinkBodies::for_name(
&self.fleet_name,
lane,
incarnation,
self.spec,
),
}
}
pub fn created(&self) -> bool {
self.region.created()
}
pub fn segment_bytes(&self) -> usize {
self.region.len()
}
pub fn unlink(&self) -> Result<()> {
if let Some(access) = &self.group {
return access.unlink_region(&self.region).map_err(Error::Io);
}
self.region.unlink().map_err(Error::Io)
}
}
pub struct LinkSegmentHandle(Arc<LinkSegment>);
impl LinkSegmentHandle {
pub fn new(segment: Arc<LinkSegment>) -> Self {
Self(segment)
}
pub fn segment(&self) -> &Arc<LinkSegment> {
&self.0
}
}
#[cfg(target_os = "macos")]
const SHM_NAME_MAX: usize = 31;
#[cfg(not(target_os = "macos"))]
const SHM_NAME_MAX: usize = 255;
pub fn check_name(
name: &str,
spec: LinkSpec,
) -> Result<()> {
validate_name(name)?;
let invalid = |reason: String| {
Err(Error::InvalidName { name: name.to_owned(), reason })
};
let inbox_segment = ring_segment_name(name, spec.inbox_kind);
let longest = inbox_segment
.len()
.max(ring_segment_name(name, spec.streams.kind).len());
if longest > SHM_NAME_MAX {
let room = name.len().saturating_sub(longest - SHM_NAME_MAX);
return invalid(format!(
"its segment name is {longest} bytes and this host takes {SHM_NAME_MAX}; at most {room} characters fit"
));
}
crate::bell::Bell::validate_address(
&inbox_segment,
usize::from(spec.fleet_capacity.saturating_sub(1)),
)
.map_err(|error| Error::InvalidName {
name: name.to_owned(),
reason: format!("its reactor socket address is invalid: {error}"),
})?;
Ok(())
}
fn validate_name(name: &str) -> Result<()> {
let invalid = |reason: String| {
Err(Error::InvalidName { name: name.to_owned(), reason })
};
if name.is_empty() {
return invalid("it is empty".into());
}
if let Some(bad) = name.chars().find(|character| {
!(character.is_ascii_alphanumeric()
|| matches!(character, '-' | '_' | '.'))
}) {
return invalid(format!(
"'{bad}' is not a letter, a digit, '-', '_' or '.'"
));
}
Ok(())
}