use std::fmt;
use orbit_stream::StreamSpec;
#[cfg(unix)]
mod bell;
mod body;
mod inbox;
#[cfg(all(unix, feature = "tokio"))]
mod receiver;
#[cfg(unix)]
mod segment;
pub use body::LinkBodies;
pub use inbox::{Admission, Inbox, InboxGeometry, LANE_NAME_MAX, LANE_ROLE_MAX, Reclaimed};
#[cfg(all(unix, feature = "tokio"))]
pub use receiver::InboxReceiver;
#[cfg(unix)]
pub use segment::{Joined, LinkSegment, LinkSegmentHandle, check_name};
pub type Result<T, E = Error> = std::result::Result<T, E>;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct LinkSpec {
pub fleet_capacity: u16,
pub inbox_kind: u8,
pub inbox: InboxGeometry,
pub streams: StreamSpec
}
impl LinkSpec {
pub const fn new(
fleet_capacity: u16,
inbox_kind: u8,
inbox: InboxGeometry,
streams: StreamSpec
) -> Self {
Self { fleet_capacity, inbox_kind, inbox, streams }
}
pub const fn inbox_segment_bytes(self) -> usize {
self.inbox.segment_bytes(self.fleet_capacity as usize)
}
fn validate(self) -> Result<()> {
if self.fleet_capacity == 0 {
return Err(Error::Malformed("link fleet capacity must not be zero"));
}
if self.inbox_kind == self.streams.kind {
return Err(Error::Malformed("link inbox and stream table need distinct SHM kinds"));
}
self.inbox.validate()
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
InboxFull,
NoLane,
FrameTooLarge,
Malformed(&'static str),
InvalidName { name: String, reason: String },
RoleConflict { name: String, role: String, held_by: String, lane: usize, pid: u32 },
Io(std::io::Error),
Core(orbit_core::Error),
Stream(orbit_stream::Error)
}
impl fmt::Display for Error {
fn fmt(
&self,
formatter: &mut fmt::Formatter<'_>
) -> fmt::Result {
match self {
Self::InboxFull => formatter.write_str("the target inbox lane is full or unowned"),
Self::NoLane => formatter.write_str("every lane in the named fleet is held"),
Self::FrameTooLarge => formatter.write_str("the frame does not fit in one inbox slot"),
Self::Malformed(message) => formatter.write_str(message),
Self::InvalidName { name, reason } => {
write!(formatter, "{name:?} cannot name a link fleet: {reason}")
}
Self::RoleConflict { name, role, held_by, lane, pid } => write!(
formatter,
"{name:?} is already served by {held_by} on lane {lane} (pid {pid}); role {role:?} cannot join under the same name"
),
Self::Io(error) => write!(formatter, "Orbit link IO error: {error}"),
Self::Core(error) => write!(formatter, "Orbit link core error: {error}"),
Self::Stream(error) => write!(formatter, "Orbit link stream error: {error}")
}
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(error) => Some(error),
Self::Core(error) => Some(error),
Self::Stream(error) => Some(error),
_ => None
}
}
}
impl From<std::io::Error> for Error {
fn from(error: std::io::Error) -> Self {
Self::Io(error)
}
}
impl From<orbit_core::Error> for Error {
fn from(error: orbit_core::Error) -> Self {
Self::Core(error)
}
}
impl From<orbit_stream::Error> for Error {
fn from(error: orbit_stream::Error) -> Self {
Self::Stream(error)
}
}
pub fn parking_supported() -> bool {
orbit_core::sync::supported()
}